Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

If the code and the comments disagree, then both are probably wrong. -- Norm Schryer


devel / comp.theory / Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

SubjectAuthor
* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
+* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
|`* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
| `* Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Richard Damon
|  `* Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]olcott
|   `* Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]Richard Damon
|    `* Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]olcott
|     +- Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]Richard Damon
|     `* Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]André G. Isaak
|      `* Refuting the Peter Linz Halting Problem Proof V5 [ accurateolcott
|       `- Refuting the Peter Linz Halting Problem Proof V5 [ accurateRichard Damon
+* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
|`- Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
+* Refuting the Peter Linz Halting Problem Proof V5 [ without anwij
|`* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
| `- Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
`* Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Ben Bacarisse
 `* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
  +* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
  |`* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
  | `* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
  |  `* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
  |   `- Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
  `* Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Ben Bacarisse
   `* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
    +* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
    |`* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
    | `* Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Richard Damon
    |  `* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
    |   `- Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
    +* Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Ben Bacarisse
    |`* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
    | +* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
    | |`* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
    | | `* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
    | |  `* Refuting the Peter Linz Halting Problem Proof V5 [ without anolcott
    | |   `* Refuting the Peter Linz Halting Problem Proof V5 [ without anRichard Damon
    | |    `* Refuting the Peter Linz Halting Problem Proof V5 [ bald facedolcott
    | |     `* Refuting the Peter Linz Halting Problem Proof V5 [ bald facedRichard Damon
    | |      `* Refuting the Peter Linz Halting Problem Proof V5 [ correctolcott
    | |       `* Refuting the Peter Linz Halting Problem Proof V5 [ correctRichard Damon
    | |        `* Refuting the Peter Linz Halting Problem Proof V5 [ correctolcott
    | |         `* Refuting the Peter Linz Halting Problem Proof V5 [ correct criteria ]Richard Damon
    | |          `* Refuting the Peter Linz Halting Problem Proof V5 [ correctolcott
    | |           `* Refuting the Peter Linz Halting Problem Proof V5 [ correctRichard Damon
    | |            `* Refuting the Peter Linz Halting Problem Proof V5 [ correctolcott
    | |             `* Refuting the Peter Linz Halting Problem Proof V5 [ correctRichard Damon
    | |              +* Refuting the Peter Linz Halting Problem Proof V5 [ correctMr Flibble
    | |              |`* Refuting the Peter Linz Halting Problem Proof V5 [ correctolcott
    | |              | `- Refuting the Peter Linz Halting Problem Proof V5 [ correctRichard Damon
    | |              `- Refuting the Peter Linz Halting Problem Proof V5 [ correctolcott
    | `* Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Ben Bacarisse
    |  `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |   `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |    `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |     +- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |     `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |      `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       +* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |       |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       | `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |       |  `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |   +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |   |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |   | `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |   |  +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualwij
    |       |   |  |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |   |  | +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualwij
    |       |   |  | |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |   |  | | +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualwij
    |       |   |  | | |`- Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |   |  | | `- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |   |  | `- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |   |  `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |   |   `- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |   `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |       |    `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |     +- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |     `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |       |      `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |       +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |       |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |       | `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |       |  `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |       |   +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |       |   |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |       |   | `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |       |   |  `- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |       |   `- Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Richard Damon
    |       |       `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |       |        `* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |         +* Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |         |`* Refuting the Peter Linz Halting Problem Proof V5 [ mutualolcott
    |       |         | `- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    |       |         `* Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]Ben Bacarisse
    |       |          `* Refuting the Peter Linz Halting Problem Proof V8olcott
    |       |           +- Refuting the Peter Linz Halting Problem Proof V8Richard Damon
    |       |           `* Refuting the Peter Linz Halting Problem Proof V8Ben Bacarisse
    |       |            `* Refuting the Peter Linz Halting Problem Proof V8olcott
    |       |             +* Refuting the Peter Linz Halting Problem Proof V8Richard Damon
    |       |             |`* Refuting the Peter Linz Halting Problem Proof V8olcott
    |       |             `- Refuting the Peter Linz Halting Problem Proof V8Ben Bacarisse
    |       `- Refuting the Peter Linz Halting Problem Proof V5 [ mutualRichard Damon
    `- Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]Ben Bacarisse

Pages:12345
Re: Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]

<t1dmqs$9k7$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]
Date: Tue, 22 Mar 2022 17:41:14 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 25
Message-ID: <t1dmqs$9k7$1@dont-email.me>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<rvs_J.318099$mF2.144337@fx11.iad>
<rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 22 Mar 2022 23:41:17 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="107ceaae1c112756d4b2487a31c48ac2";
logging-data="9863"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18Bnx46csdeDkbHvU9ag0FI"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:kVTzEHszDolUH/KvUYKH8GKGAZQ=
In-Reply-To: <rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 22 Mar 2022 23:41 UTC

On 2022-03-22 17:07, olcott wrote:
> On 3/22/2022 5:57 PM, Richard Damon wrote:

>> The problem you have is that that the simulation that shows it would
>> never reach a final state requries that H/embedded_H NEVER abort its
>> simulation.
> So basically when the simulated input has had it simulation aborted it
> continues on and reaches its final state even though it was aborted.
>

As usual, you are horrendously confused.

If a TM acting on some input halts after 125 steps and I simulate it in
some partial simulator which simulates 100 steps and then aborts its
simulation, the simulation never reaches a final state, but the
computation is still a halting computation.

When you abort a simulation after N steps, all that tells us is that the
computation either doesn't halt or halts after more than N steps.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ accurate assessment ]

<Kd6dncVdn6VL5af_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!nntp.club.cc.cmu.edu!45.76.7.193.MISMATCH!3.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 20:33:10 -0500
Date: Tue, 22 Mar 2022 20:33:08 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ accurate
assessment ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<rvs_J.318099$mF2.144337@fx11.iad>
<rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com> <t1dmqs$9k7$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <t1dmqs$9k7$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Kd6dncVdn6VL5af_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 37
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KoyIdgp/Ek6js6/l3bg6/eZU3aLQBxP0rUxvBJ+58zyjPyYxMWwDCodeapjunXLOeakBXaWMx4oIDYA!/fbNCEP1ez69EgvK+4qgAH2Fn49KQJa2YegUlLkv0NNHgIv9l4uRA7cnkG2SmXx4z7rewhTcr1a1
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: 2928
 by: olcott - Wed, 23 Mar 2022 01:33 UTC

On 3/22/2022 6:41 PM, André G. Isaak wrote:
> On 2022-03-22 17:07, olcott wrote:
>> On 3/22/2022 5:57 PM, Richard Damon wrote:
>
>>> The problem you have is that that the simulation that shows it would
>>> never reach a final state requries that H/embedded_H NEVER abort its
>>> simulation.
>> So basically when the simulated input has had it simulation aborted it
>> continues on and reaches its final state even though it was aborted.
>>
>
> As usual, you are horrendously confused.
>
> If a TM acting on some input halts after 125 steps and I simulate it in
> some partial simulator which simulates 100 steps and then aborts its
> simulation, the simulation never reaches a final state, but the
> computation is still a halting computation.
>

Yes you are correct. When a simulating halt decider correctly determines
that its correctly simulated input would never reach its final state
then and only then it can correctly abort the simulation of this input
and correctly transition to its reject state.

> When you abort a simulation after N steps, all that tells us is that the
> computation either doesn't halt or halts after more than N steps.
>
> André
>

--
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: Refuting the Peter Linz Halting Problem Proof V5 [ accurate assessment ]

<9hv_J.124953$ZmJ7.90358@fx06.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx06.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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ accurate
assessment ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<rvs_J.318099$mF2.144337@fx11.iad>
<rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com> <t1dmqs$9k7$1@dont-email.me>
<Kd6dncVdn6VL5af_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Kd6dncVdn6VL5af_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 43
Message-ID: <9hv_J.124953$ZmJ7.90358@fx06.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 22:07:05 -0400
X-Received-Bytes: 3024
 by: Richard Damon - Wed, 23 Mar 2022 02:07 UTC

On 3/22/22 9:33 PM, olcott wrote:
> On 3/22/2022 6:41 PM, André G. Isaak wrote:
>> On 2022-03-22 17:07, olcott wrote:
>>> On 3/22/2022 5:57 PM, Richard Damon wrote:
>>
>>>> The problem you have is that that the simulation that shows it would
>>>> never reach a final state requries that H/embedded_H NEVER abort its
>>>> simulation.
>>> So basically when the simulated input has had it simulation aborted
>>> it continues on and reaches its final state even though it was aborted.
>>>
>>
>> As usual, you are horrendously confused.
>>
>> If a TM acting on some input halts after 125 steps and I simulate it
>> in some partial simulator which simulates 100 steps and then aborts
>> its simulation, the simulation never reaches a final state, but the
>> computation is still a halting computation.
>>
>
> Yes you are correct. When a simulating halt decider correctly determines
> that its correctly simulated input would never reach its final state
> then and only then it can correctly abort the simulation of this input
> and correctly transition to its reject state.
>

And the key is CORRECTLY, so when you look at the actual input, based on
the decider that went to Qn, it must still not be halting.

This is not true for H^, so you Simulating Halt Decider never CORRECTLY
determined that H^ applied to <H^> was non-halting, because it used
unsound logic in assuming the H/embedded_H would never abort which is a
false premise if it does.

>> When you abort a simulation after N steps, all that tells us is that
>> the computation either doesn't halt or halts after more than N steps.
>>
>> André
>>
>
>

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<fMWdnWl9t-InEKf_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsfeed.CARNet.hr!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 22:02:18 -0500
Date: Tue, 22 Mar 2022 22:02:16 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<xys_J.318102$mF2.179107@fx11.iad>
<ULSdnTHJAPCFxaf_nZ2dnUU7_8xh4p2d@giganews.com>
<SZs_J.457801$aT3.60942@fx09.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <SZs_J.457801$aT3.60942@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fMWdnWl9t-InEKf_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 112
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vgqTxX0sOT0dOpiu7q9O3oIcVNALI6N5CVVFTFM8qnHG7KOkIbRfWlKjBXR7KILN6b7Sa+oGkU/tgH5!hyqs20PX57QobK4/Z06k7KSLwjT+CFB0Q6koAp0TW4xuT5TCJZiPbahiY2yfPVMzdf6e19uWNV+S
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: 6251
 by: olcott - Wed, 23 Mar 2022 03:02 UTC

On 3/22/2022 6:29 PM, Richard Damon wrote:
> On 3/22/22 7:13 PM, olcott wrote:
>> On 3/22/2022 6:00 PM, Richard Damon wrote:
>>> On 3/22/22 10:46 AM, olcott wrote:
>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>> decider (SHD).
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>>> final state.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>> reach its
>>>>>>>> final state.
>>>>>>> But for your "PO-machines":
>>>>>>>     "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>     corresponds to
>>>>>>>     H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>> and
>>>>>>>     "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>>> halts.
>>>>>>>     H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>> machines.
>>>>>>>
>>>>>>
>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>> machine
>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>> state
>>>>> transition functions can entail different configuration sequences for
>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>> machines until you categorically repudiate this nonsense.
>>>>>
>>>>
>>>> That your only rebuttal to what I say now is dredging up what I said
>>>> many months ago proves that you are being dishonest.
>>>>
>>>> It is the case that the pure simulation of the input to the
>>>> simulating halt decider Linz H embedded at Ĥ.qx would never reach
>>>> the final state of this simulated input.
>>>>
>>>> You ignore this and change the subject only because you know that it
>>>> is correct and have denigration rather than honest critique as your
>>>> only goal.
>>>>
>>>>>> I don't have time to diverge from this point:
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>>>>> state.
>>>>>
>>>>> And, since the action of your magic machines are not constrained by
>>>>> the
>>>>> state transition function and the input, I can assert that a copy of
>>>>> our Ĥ does this:
>>>>>
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>> ⟨Ĥ2⟩
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>> ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>> ⟨Ĥ4⟩...
>>>>
>>>> The above shows that the simulated input to embedded_H will never
>>>> reach its own final state whether or not its simulation is aborted
>>>> thus never meets the Linz definition of halting:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>
>>>>
>>>
>>> The above only doesn't halt if embedded_H never aborts its simulation,
>> And it doesn't halt if embedded_H DOES abort its simulation, therefore
>> it doesn't halt under any condition.
>>
>
> Except that the actual machine DOES Halt, as does the UTM simulation.

Because the simulated Turing machine description cannot possibly reach
its final state it is necessarily correct for embedded_ to compute the
mapping from its input ⟨Ĥ⟩ ⟨Ĥ⟩ to its final reject state Ĥ.qn

When you have a dog in your living room you know that this dog is not a
cat, not even if the theory of computation says 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

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<87bkxxjq50.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Date: Wed, 23 Mar 2022 03:37:15 +0000
Organization: A noiseless patient Spider
Lines: 63
Message-ID: <87bkxxjq50.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk>
<tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e742c43ca1743bcf3f6ce6190600a15e";
logging-data="20626"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19h7+kTwG1agpUcq63FPFgCzwMi5fQxLEI="
Cancel-Lock: sha1:PypfRyZEBTmqq1xbM/LyIPuzMSM=
sha1:TIH1kfiq5jSngYNekekUv7Vl4dM=
X-BSB-Auth: 1.360aa3552199f56b0633.20220323033715GMT.87bkxxjq50.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 23 Mar 2022 03:37 UTC

olcott <NoOne@NoWhere.com> writes:

> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>> final state.
>>>> But for your "PO-machines":
>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>> corresponds to
>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>> and
>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>> so this has nothing to do with Linz. He is talking about Turing
>>>> machines.
>>>>
>>>
>>> The Linz conclusion only pertains to the behavior the copy of H
>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Everything Linz says, everything, is predicated on what a Turing machine
>> is. Unlike Turing machines, your machines are magic -- identical state
>> transition functions can entail different configuration sequences for
>> the same input. Nothing you say has any relevance to Linz's Turing
>> machines until you categorically repudiate this nonsense.
>
> That your only rebuttal to what I say now is dredging up what I said
> many months ago proves that you are being dishonest.

You said this:

"The copy of H at Ĥ.qx correctly decides that its input never halts.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

four days ago and you haven't retracted it. Until you do, when you
write Ĥ your readers must assume that you are referring to something
about which this quote applies.

What's more, for your remarks to have any bearing on Linz's Ĥ you must
not only repudiate what you said, you must accept the converse,
i.e. that if

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn

then

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

So, do you retract what you said and accept this fact about Linz's H and
Ĥ?

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<875yo5jpnv.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Date: Wed, 23 Mar 2022 03:47:32 +0000
Organization: A noiseless patient Spider
Lines: 64
Message-ID: <875yo5jpnv.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk>
<tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e742c43ca1743bcf3f6ce6190600a15e";
logging-data="20626"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18TpiTUWhDI7byQHMQTCwIRMtDujk5qWKg="
Cancel-Lock: sha1:5xNGQnQTL0+TGMQTbNFieXWxyrY=
sha1:4jhwap/lWiaIRgNObtTmxqyWfV4=
X-BSB-Auth: 1.571a0a8f71a04042f178.20220323034732GMT.875yo5jpnv.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 23 Mar 2022 03:47 UTC

This post may be a duplicate. Something went wrong the first time...

olcott <NoOne@NoWhere.com> writes:

> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>> final state.
>>>> But for your "PO-machines":
>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>> corresponds to
>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>> and
>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>> so this has nothing to do with Linz. He is talking about Turing
>>>> machines.
>>>>
>>>
>>> The Linz conclusion only pertains to the behavior the copy of H
>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>> Everything Linz says, everything, is predicated on what a Turing machine
>> is. Unlike Turing machines, your machines are magic -- identical state
>> transition functions can entail different configuration sequences for
>> the same input. Nothing you say has any relevance to Linz's Turing
>> machines until you categorically repudiate this nonsense.
>
> That your only rebuttal to what I say now is dredging up what I said
> many months ago proves that you are being dishonest.

You said this:

"The copy of H at Ĥ.qx correctly decides that its input never halts.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

four days ago and you haven't retracted it. Until you do, when you
write Ĥ your readers must assume that you are referring to something
about which this quote applies.

What's more, for your remarks to have any bearing on Linz's Ĥ you must
not only repudiate what you said, you must accept the converse,
i.e. that if

Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn

then

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn

So, do you retract what you said and accept this fact about Linz's H and
Ĥ?

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 23:00:44 -0500
Date: Tue, 22 Mar 2022 23:00:43 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <87bkxxjq50.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 100
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-KnXDEMu9xRscNBmKinrAhsp4ZjeAENpcOPVuEW9Hsx0iJqPK0kHO5Aeaiud3YIpAjC5rHuNS7w50kWk!A94lz6CRAzkupv7e0iLqCheL9bQ7iW8MgDPN7JuP4sHPJvYhilO4YOSI3jV3kXD5xOVHcjU6Fg2U
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: 5512
 by: olcott - Wed, 23 Mar 2022 04:00 UTC

On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>> final state.
>>>>> But for your "PO-machines":
>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>> corresponds to
>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>> and
>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>> machines.
>>>>>
>>>>
>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> Everything Linz says, everything, is predicated on what a Turing machine
>>> is. Unlike Turing machines, your machines are magic -- identical state
>>> transition functions can entail different configuration sequences for
>>> the same input. Nothing you say has any relevance to Linz's Turing
>>> machines until you categorically repudiate this nonsense.
>>
>> That your only rebuttal to what I say now is dredging up what I said
>> many months ago proves that you are being dishonest.
>
> You said this:
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>

If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
same result. They are not identical final strings.

> four days ago and you haven't retracted it. Until you do, when you
> write Ĥ your readers must assume that you are referring to something
> about which this quote applies.
>
> What's more, for your remarks to have any bearing on Linz's Ĥ you must
> not only repudiate what you said, you must accept the converse,
> i.e. that if
>
> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>
> then
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>
> So, do you retract what you said and accept this fact about Linz's H and
> Ĥ?
>

You you continue to say that you believe that a decider must report on
its own behavior when you already know damn well that a decider only
computes the mapping from its inputs to its own final state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
state.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
final state.

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

Then these steps would keep repeating:
Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

The above shows that the simulated input to embedded_H will never reach
its own final state whether or not its simulation is aborted thus never
meets the Linz definition of halting:

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: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<qjD_J.459562$aT3.387015@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<xys_J.318102$mF2.179107@fx11.iad>
<ULSdnTHJAPCFxaf_nZ2dnUU7_8xh4p2d@giganews.com>
<SZs_J.457801$aT3.60942@fx09.iad>
<fMWdnWl9t-InEKf_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <fMWdnWl9t-InEKf_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 126
Message-ID: <qjD_J.459562$aT3.387015@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 23 Mar 2022 07:15:38 -0400
X-Received-Bytes: 6621
 by: Richard Damon - Wed, 23 Mar 2022 11:15 UTC

On 3/22/22 11:02 PM, olcott wrote:
> On 3/22/2022 6:29 PM, Richard Damon wrote:
>> On 3/22/22 7:13 PM, olcott wrote:
>>> On 3/22/2022 6:00 PM, Richard Damon wrote:
>>>> On 3/22/22 10:46 AM, olcott wrote:
>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>> decider (SHD).
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>>>> final state.
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>> reach its
>>>>>>>>> final state.
>>>>>>>> But for your "PO-machines":
>>>>>>>>     "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>     corresponds to
>>>>>>>>     H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>> and
>>>>>>>>     "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>> never halts.
>>>>>>>>     H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>> machines.
>>>>>>>>
>>>>>>>
>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>>> machine
>>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>>> state
>>>>>> transition functions can entail different configuration sequences for
>>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>
>>>>>
>>>>> That your only rebuttal to what I say now is dredging up what I
>>>>> said many months ago proves that you are being dishonest.
>>>>>
>>>>> It is the case that the pure simulation of the input to the
>>>>> simulating halt decider Linz H embedded at Ĥ.qx would never reach
>>>>> the final state of this simulated input.
>>>>>
>>>>> You ignore this and change the subject only because you know that
>>>>> it is correct and have denigration rather than honest critique as
>>>>> your only goal.
>>>>>
>>>>>>> I don't have time to diverge from this point:
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>> final
>>>>>>> state.
>>>>>>
>>>>>> And, since the action of your magic machines are not constrained
>>>>>> by the
>>>>>> state transition function and the input, I can assert that a copy of
>>>>>> our Ĥ does this:
>>>>>>
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>
>>>>> Then these steps would keep repeating:
>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>>> ⟨Ĥ2⟩
>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>>> ⟨Ĥ3⟩
>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>>> ⟨Ĥ4⟩...
>>>>>
>>>>> The above shows that the simulated input to embedded_H will never
>>>>> reach its own final state whether or not its simulation is aborted
>>>>> thus never meets the Linz definition of halting:
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>>>
>>>>>
>>>>
>>>> The above only doesn't halt if embedded_H never aborts its simulation,
>>> And it doesn't halt if embedded_H DOES abort its simulation,
>>> therefore it doesn't halt under any condition.
>>>
>>
>> Except that the actual machine DOES Halt, as does the UTM simulation.
>
> Because the simulated Turing machine description cannot possibly reach
> its final state it is necessarily correct for embedded_ to compute the
> mapping from its input ⟨Ĥ⟩ ⟨Ĥ⟩ to its final reject state Ĥ.qn

Except that isn't the critera, the ACTUAL machine or a simulation by a
UTM WILL reach its final state if the copy of embedded_H in it aborts
its simulation and go to Qn. And all copies of H/embedded_H do the same
thing on this.

You just start from the wrong definition, which just isn't true.
>
> When you have a dog in your living room you know that this dog is not a
> cat, not even if the theory of computation says that it is.
>

Except in this case you just THINK it is a Dog, when it is a cat.

You can not actually show / prove that you definition is correct, you
just 'know' it by the 'meaning of the words', but you have shown that
you don't actually even know the meaning of the words.

So, you claim is just a LIE.

FAIL.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<XmD_J.161395$4JN7.131178@fx05.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 120
Message-ID: <XmD_J.161395$4JN7.131178@fx05.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 23 Mar 2022 07:19:23 -0400
X-Received-Bytes: 5964
 by: Richard Damon - Wed, 23 Mar 2022 11:19 UTC

On 3/23/22 12:00 AM, olcott wrote:
> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>>> (SHD).
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>> final state.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>>>> its
>>>>>>> final state.
>>>>>> But for your "PO-machines":
>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>      corresponds to
>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>> and
>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>> halts.
>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>> machines.
>>>>>>
>>>>>
>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> Everything Linz says, everything, is predicated on what a Turing
>>>> machine
>>>> is.  Unlike Turing machines, your machines are magic -- identical state
>>>> transition functions can entail different configuration sequences for
>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>> machines until you categorically repudiate this nonsense.
>>>
>>> That your only rebuttal to what I say now is dredging up what I said
>>> many months ago proves that you are being dishonest.
>>
>> You said this:
>>
>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>
>
> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
> same result. They are not identical final strings.
>
>> four days ago and you haven't retracted it.  Until you do, when you
>> write Ĥ your readers must assume that you are referring to something
>> about which this quote applies.
>>
>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>> not only repudiate what you said, you must accept the converse,
>> i.e. that if
>>
>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>
>> then
>>
>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>
>> So, do you retract what you said and accept this fact about Linz's H and
>> Ĥ?
>>
>
> You you continue to say that you believe that a decider must report on
> its own behavior when you already know damn well that a decider only
> computes the mapping from its inputs to its own final state.

A Decider must report on its own behavior (or the behavior of a copy of
it) if that is what the input asks for.

FAIL.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
> state.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
> final state.
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...

Which only happens IF embedded_H never aborts.

>
> The above shows that the simulated input to embedded_H will never reach
> its own final state whether or not its simulation is aborted thus never
> meets the Linz definition of halting:

Nope, flat out lie, it only shows that if embedded_H never aborts. Note,
your statement STARTS with the direct running of H^ applied to <H^>,
there is nothing that can abort that. You haven't shown wht happens when
that embedded_H in that H^ aborts, so you have no proof of the behavior
if it does.

This has been pointed out enough times the the repeating is just a
deliberate LIE, proving you don't know what truth is.

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

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 08:09:32 -0500
Date: Wed, 23 Mar 2022 08:09:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <XmD_J.161395$4JN7.131178@fx05.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 94
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jp4K4FPIC/Z/TRJL/m29in+eFZ73Xs99c4cmUPT2UZMkmsxV+jSPbQH8kt7Vq4BY7EJXdnqr8eUxcOz!CsdUwCtP8L51oI1V1Xph2oOmDKPCf0cIsiOFUplzBzKiMkbsp6yL+4l44PxbuMWOFR9HrcVMMFvo
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: 5248
 by: olcott - Wed, 23 Mar 2022 13:09 UTC

On 3/23/2022 6:19 AM, Richard Damon wrote:
> On 3/23/22 12:00 AM, olcott wrote:
>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>> decider (SHD).
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>>> final state.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>> reach its
>>>>>>>> final state.
>>>>>>> But for your "PO-machines":
>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>      corresponds to
>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>> and
>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>> never halts.
>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>> machines.
>>>>>>>
>>>>>>
>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>> machine
>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>> state
>>>>> transition functions can entail different configuration sequences for
>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>> machines until you categorically repudiate this nonsense.
>>>>
>>>> That your only rebuttal to what I say now is dredging up what I said
>>>> many months ago proves that you are being dishonest.
>>>
>>> You said this:
>>>
>>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>
>>
>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>> same result. They are not identical final strings.
>>
>>> four days ago and you haven't retracted it.  Until you do, when you
>>> write Ĥ your readers must assume that you are referring to something
>>> about which this quote applies.
>>>
>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>> not only repudiate what you said, you must accept the converse,
>>> i.e. that if
>>>
>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>
>>> then
>>>
>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>
>>> So, do you retract what you said and accept this fact about Linz's H and
>>> Ĥ?
>>>
>>
>> You you continue to say that you believe that a decider must report on
>> its own behavior when you already know damn well that a decider only
>> computes the mapping from its inputs to its own final state.
>
> A Decider must report on its own behavior (or the behavior of a copy of
> it) if that is what the input asks for.
>
You know that a decider only computes the mapping from its input finite
strings to its own final state thus you know that you lie what you say
that a decider must compute the mapping from a non-finite sting non-input.

WHY LIE ? WHY LIE ? WHY LIE ? WHY LIE ?

--
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: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<875yo4itma.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Date: Wed, 23 Mar 2022 15:19:41 +0000
Organization: A noiseless patient Spider
Lines: 82
Message-ID: <875yo4itma.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk>
<tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk>
<qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e742c43ca1743bcf3f6ce6190600a15e";
logging-data="3458"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX186PYW+zIZ7kww6zi9kDf45BXCqGu5EooY="
Cancel-Lock: sha1:GKPo9vx852oo7DZLkAQ/IVsU9Q0=
sha1:qPyPWXWPOyhf4JjWD1V5Ysdd++k=
X-BSB-Auth: 1.01b5b9b89a87be63ac7b.20220323151941GMT.875yo4itma.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 23 Mar 2022 15:19 UTC

olcott <NoOne@NoWhere.com> writes:

> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>> final state.
>>>>>> But for your "PO-machines":
>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>> corresponds to
>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>> and
>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>> machines.
>>>>>>
>>>>>
>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>> transition functions can entail different configuration sequences for
>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>> machines until you categorically repudiate this nonsense.
>>>
>>> That your only rebuttal to what I say now is dredging up what I said
>>> many months ago proves that you are being dishonest.
>> You said this:
>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>
> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
> same result. They are not identical final strings.

If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
different transitions than H does, since they both have identical
inputs. If one compares some strings, the other will too and they will
both arrive as the same result and they will both behave in the same
way. You H and Ĥ are obviously not Turing machines.

I regret dropping down into simplistic metaphors. I'd rather keep this
about formal Turing machines, but you don't really know what they are,
and you certainly can't reason about them, so that hits a brick wall
pretty quickly.

>> four days ago and you haven't retracted it. Until you do, when you
>> write Ĥ your readers must assume that you are referring to something
>> about which this quote applies.
>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>> not only repudiate what you said, you must accept the converse,
>> i.e. that if
>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>> then
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>> So, do you retract what you said and accept this fact about Linz's H and
>> Ĥ?
>
> You you continue to say that you believe that a decider must report on
> its own behavior when you already know damn well that a decider only
> computes the mapping from its inputs to its own final state.

I continue to believe that I know what a Turing machine is and that you
don't. A Turing machine and an exact copy of it can't entail different
sequences of transitions. Your H and Ĥ don't have this property. They
are not Turing machines.

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]

<DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 10:26:28 -0500
Date: Wed, 23 Mar 2022 10:26:26 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual
agreement ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<875yo4itma.fsf@bsb.me.uk>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <875yo4itma.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 91
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jpGctFNbQzl9wQmaRk22C+msHpjWHj9Zb7hXYhDR7nHU496e9AWkzwF01SS8uUq2qyoiI6X5+l2pf8t!h94leMrKS/h898w0rSR1rQA0TxZ3ytJBYh1PxJmM/LmM5CAIRb3Y5RTJSFVEEWxEcepQbFMP8CNB
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: 5687
 by: olcott - Wed, 23 Mar 2022 15:26 UTC

On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>> final state.
>>>>>>> But for your "PO-machines":
>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>> corresponds to
>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>> and
>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>> machines.
>>>>>>>
>>>>>>
>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>> transition functions can entail different configuration sequences for
>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>> machines until you categorically repudiate this nonsense.
>>>>
>>>> That your only rebuttal to what I say now is dredging up what I said
>>>> many months ago proves that you are being dishonest.
>>> You said this:
>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>
>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>> same result. They are not identical final strings.
>
> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
> different transitions than H does, since they both have identical
> inputs. If one compares some strings, the other will too and they will
> both arrive as the same result and they will both behave in the same
> way. You H and Ĥ are obviously not Turing machines.
>
> I regret dropping down into simplistic metaphors. I'd rather keep this
> about formal Turing machines, but you don't really know what they are,
> and you certainly can't reason about them, so that hits a brick wall
> pretty quickly.
>
>>> four days ago and you haven't retracted it. Until you do, when you
>>> write Ĥ your readers must assume that you are referring to something
>>> about which this quote applies.
>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>> not only repudiate what you said, you must accept the converse,
>>> i.e. that if
>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>> then
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>> So, do you retract what you said and accept this fact about Linz's H and
>>> Ĥ?
>>
>> You you continue to say that you believe that a decider must report on
>> its own behavior when you already know damn well that a decider only
>> computes the mapping from its inputs to its own final state.
>
> I continue to believe that I know what a Turing machine is and that you
> don't. A Turing machine and an exact copy of it can't entail different
> sequences of transitions. Your H and Ĥ don't have this property. They
> are not Turing machines.
>

I agree that a TM and an exact copy of it must entail the same sequence
of transitions when applied to identical 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: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]

<87ils4gxdn.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]
Date: Wed, 23 Mar 2022 21:41:24 +0000
Organization: A noiseless patient Spider
Lines: 96
Message-ID: <87ils4gxdn.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk>
<tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk>
<qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<875yo4itma.fsf@bsb.me.uk>
<DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="e742c43ca1743bcf3f6ce6190600a15e";
logging-data="14004"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+2My2O4XfUtuyK6jjIPT4zfMbCSMExLJ4="
Cancel-Lock: sha1:dx8+3GXmydIR1nSQ6V8WnjS4l+I=
sha1:Swu3yO8mF0re/8WAUUnJTadEkAk=
X-BSB-Auth: 1.d8d1c96ca08fe68be82b.20220323214124GMT.87ils4gxdn.fsf@bsb.me.uk
 by: Ben Bacarisse - Wed, 23 Mar 2022 21:41 UTC

olcott <NoOne@NoWhere.com> writes:

> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>> final state.
>>>>>>>> But for your "PO-machines":
>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>> corresponds to
>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>> and
>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>> machines.
>>>>>>>>
>>>>>>>
>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>> transition functions can entail different configuration sequences for
>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>> machines until you categorically repudiate this nonsense.
>>>>>
>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>> many months ago proves that you are being dishonest.
>>>> You said this:
>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>
>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>> same result. They are not identical final strings.
>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>> different transitions than H does, since they both have identical
>> inputs. If one compares some strings, the other will too and they will
>> both arrive as the same result and they will both behave in the same
>> way. You H and Ĥ are obviously not Turing machines.
>> I regret dropping down into simplistic metaphors. I'd rather keep this
>> about formal Turing machines, but you don't really know what they are,
>> and you certainly can't reason about them, so that hits a brick wall
>> pretty quickly.
>>
>>>> four days ago and you haven't retracted it. Until you do, when you
>>>> write Ĥ your readers must assume that you are referring to something
>>>> about which this quote applies.
>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>> not only repudiate what you said, you must accept the converse,
>>>> i.e. that if
>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>> then
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>> Ĥ?
>>>
>>> You you continue to say that you believe that a decider must report on
>>> its own behavior when you already know damn well that a decider only
>>> computes the mapping from its inputs to its own final state.
>>
>> I continue to believe that I know what a Turing machine is and that you
>> don't. A Turing machine and an exact copy of it can't entail different
>> sequences of transitions. Your H and Ĥ don't have this property. They
>> are not Turing machines.
>
> I agree that a TM and an exact copy of it must entail the same
> sequence of transitions when applied to identical input.

OK, but what about your magic PO-machines? They don't behave like this
(apparently). It's easy to agree to facts about Turing machines, if
your plan is to keep talking about machines where

"The copy of H at Ĥ.qx correctly decides that its input never halts.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

When you talk about H and Ĥ, we need to know if you are talking about
TMs or about the H and Ĥ as described in that remark from a few days ago.

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]

<CuudnRRb-NdZA6b_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 17:27:16 -0500
Date: Wed, 23 Mar 2022 17:27:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual
agreement ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<875yo4itma.fsf@bsb.me.uk> <DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ils4gxdn.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <87ils4gxdn.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <CuudnRRb-NdZA6b_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 111
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-bGUaw0U9xzTPiip8k2z66i1ouvnIuSNuxlepbACreXlJmpas6bOgMXcNsd6k94VD+cauXWFIbLWCeDN!1yqKNg0V6DC/cI1Z+a29wOUs1VqxvsYE6x2O4WU0YqAj7rQj1nq6P5gRPo9z4EZ4eRaWUH6OMsUJ
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: 6895
 by: olcott - Wed, 23 Mar 2022 22:27 UTC

On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>>> final state.
>>>>>>>>> But for your "PO-machines":
>>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>> corresponds to
>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>> and
>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>>> machines.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>>> transition functions can entail different configuration sequences for
>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>
>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>> many months ago proves that you are being dishonest.
>>>>> You said this:
>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>
>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>> same result. They are not identical final strings.
>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>> different transitions than H does, since they both have identical
>>> inputs. If one compares some strings, the other will too and they will
>>> both arrive as the same result and they will both behave in the same
>>> way. You H and Ĥ are obviously not Turing machines.
>>> I regret dropping down into simplistic metaphors. I'd rather keep this
>>> about formal Turing machines, but you don't really know what they are,
>>> and you certainly can't reason about them, so that hits a brick wall
>>> pretty quickly.
>>>
>>>>> four days ago and you haven't retracted it. Until you do, when you
>>>>> write Ĥ your readers must assume that you are referring to something
>>>>> about which this quote applies.
>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>> not only repudiate what you said, you must accept the converse,
>>>>> i.e. that if
>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>> then
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>>> Ĥ?
>>>>
>>>> You you continue to say that you believe that a decider must report on
>>>> its own behavior when you already know damn well that a decider only
>>>> computes the mapping from its inputs to its own final state.
>>>
>>> I continue to believe that I know what a Turing machine is and that you
>>> don't. A Turing machine and an exact copy of it can't entail different
>>> sequences of transitions. Your H and Ĥ don't have this property. They
>>> are not Turing machines.
>>
>> I agree that a TM and an exact copy of it must entail the same
>> sequence of transitions when applied to identical input.
>
> OK, but what about your magic PO-machines? They don't behave like this
> (apparently). It's easy to agree to facts about Turing machines, if
> your plan is to keep talking about machines where
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"

Not if H and Ĥ are identical and are not allowed to use their machine
address to tell them apart.

In my prior claims either H and Ĥ were not identical finite stings or
they were identical finite stings at different machine addresses and
they were allowed to use this machine address difference as their halt
status criteria.

From what I recall I explained all this before in complete detail but
you were so sure that I must be wrong that your made sure to repeatedly
always ignore this explanation.

--
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: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<ZHN_J.207360$Y1A7.26196@fx43.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 113
Message-ID: <ZHN_J.207360$Y1A7.26196@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: Wed, 23 Mar 2022 19:04:29 -0400
X-Received-Bytes: 6030
 by: Richard Damon - Wed, 23 Mar 2022 23:04 UTC

On 3/23/22 9:09 AM, olcott wrote:
> On 3/23/2022 6:19 AM, Richard Damon wrote:
>> On 3/23/22 12:00 AM, olcott wrote:
>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>> decider (SHD).
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>>>> final state.
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>> reach its
>>>>>>>>> final state.
>>>>>>>> But for your "PO-machines":
>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>      corresponds to
>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>> and
>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>> never halts.
>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>> machines.
>>>>>>>>
>>>>>>>
>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>>> machine
>>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>>> state
>>>>>> transition functions can entail different configuration sequences for
>>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>>> machines until you categorically repudiate this nonsense.
>>>>>
>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>> many months ago proves that you are being dishonest.
>>>>
>>>> You said this:
>>>>
>>>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>
>>>
>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive
>>> the same result. They are not identical final strings.
>>>
>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>> write Ĥ your readers must assume that you are referring to something
>>>> about which this quote applies.
>>>>
>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>> not only repudiate what you said, you must accept the converse,
>>>> i.e. that if
>>>>
>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>
>>>> then
>>>>
>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>
>>>> So, do you retract what you said and accept this fact about Linz's H
>>>> and
>>>> Ĥ?
>>>>
>>>
>>> You you continue to say that you believe that a decider must report
>>> on its own behavior when you already know damn well that a decider
>>> only computes the mapping from its inputs to its own final state.
>>
>> A Decider must report on its own behavior (or the behavior of a copy
>> of it) if that is what the input asks for.
>>
> You know that a decider only computes the mapping from its input finite
> strings to its own final state thus you know that you lie what you say
> that a decider must compute the mapping from a non-finite sting non-input.
>
> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>

I don't, but you seem to like to.

I never said that H needs to compute a mapping of anything but what has
been given as an input.

The only thing H needs to compute the mapping of is <H^> <H^>, which is
EXACTLY the string on its input.

The problem which you don't seem to understand is that the MAPPING it
needs to try and compute (and which is not guaranteed to BE Computable),
is the Behavior of the machine it represents, H^ applied to <H^>, as
that is the mapping of the Halting Function.

You seem to have this fundamental problem distinguishing between what
the input is, and what the output it needs to map to.

Yes, if we were guaranteed that the mapping WAS computatable, then there
would have to be some method, perhaps your simulation, to computate that
mapping, but we aren't given that guarantee, and in fact, that
computability is the crux of the question. It turns out that, because of
ths allowed form of reference to a decider in the machine, we can make a
machine that will stump any given decider.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]

<iLN_J.199728$r6p7.31253@fx41.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual
agreement ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<875yo4itma.fsf@bsb.me.uk> <DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ils4gxdn.fsf@bsb.me.uk> <CuudnRRb-NdZA6b_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <CuudnRRb-NdZA6b_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 122
Message-ID: <iLN_J.199728$r6p7.31253@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: Wed, 23 Mar 2022 19:08:02 -0400
X-Received-Bytes: 7031
 by: Richard Damon - Wed, 23 Mar 2022 23:08 UTC

On 3/23/22 6:27 PM, olcott wrote:
> On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>> its final state.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>>> reach its
>>>>>>>>>>> final state.
>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>        "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>        corresponds to
>>>>>>>>>>        H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>> and
>>>>>>>>>>        "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>> never halts.
>>>>>>>>>>        H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>> halts"
>>>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>>>> machines.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>>>>> machine
>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>> identical state
>>>>>>>> transition functions can entail different configuration
>>>>>>>> sequences for
>>>>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>
>>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>>> many months ago proves that you are being dishonest.
>>>>>> You said this:
>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>> halts.
>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>
>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>>> same result. They are not identical final strings.
>>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>>> different transitions than H does, since they both have identical
>>>> inputs.  If one compares some strings, the other will too and they will
>>>> both arrive as the same result and they will both behave in the same
>>>> way.  You H and Ĥ are obviously not Turing machines.
>>>> I regret dropping down into simplistic metaphors.  I'd rather keep this
>>>> about formal Turing machines, but you don't really know what they are,
>>>> and you certainly can't reason about them, so that hits a brick wall
>>>> pretty quickly.
>>>>
>>>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>> about which this quote applies.
>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you
>>>>>> must
>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>> i.e. that if
>>>>>>      Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>> then
>>>>>>      H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>> So, do you retract what you said and accept this fact about Linz's
>>>>>> H and
>>>>>> Ĥ?
>>>>>
>>>>> You you continue to say that you believe that a decider must report on
>>>>> its own behavior when you already know damn well that a decider only
>>>>> computes the mapping from its inputs to its own final state.
>>>>
>>>> I continue to believe that I know what a Turing machine is and that you
>>>> don't.  A Turing machine and an exact copy of it can't entail different
>>>> sequences of transitions.  Your H and Ĥ don't have this property.  They
>>>> are not Turing machines.
>>>
>>> I agree that a TM and an exact copy of it must entail the same
>>> sequence of transitions when applied to identical input.
>>
>> OK, but what about your magic PO-machines?  They don't behave like this
>> (apparently).  It's easy to agree to facts about Turing machines, if
>> your plan is to keep talking about machines where
>>
>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>
> Not if H and Ĥ are identical and are not allowed to use their machine
> address to tell them apart.
>
> In my prior claims either H and Ĥ were not identical finite stings or
> they were identical finite stings at different machine addresses and
> they were allowed to use this machine address difference as their halt
> status criteria.
>
> From what I recall I explained all this before in complete detail but
> you were so sure that I must be wrong that your made sure to repeatedly
> always ignore this explanation.
>
>

But what about H and the IDENTICAL copy of H embedded in H^?

They have the exact same 'instructions' and the exact same input, so
should trave the exact same sequence of transitions, right?

Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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: Wed, 23 Mar 2022 18:20:22 -0500
Date: Wed, 23 Mar 2022 18:20:20 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <ZHN_J.207360$Y1A7.26196@fx43.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 116
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vK7zKh5Fq1UyLq72r65tx+k4eDussfIkhqzglb01TTMwqvqISfB03pVu4iJHPRFLFZje/yIScxJfFV8!kUNsjtXj4WqHIay7rEJqUL/SRNY11J2p1aMFl0AhHXSmKGclDlpnjl+RxUmYessoIlWo9ehro9yJ
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: 6162
 by: olcott - Wed, 23 Mar 2022 23:20 UTC

On 3/23/2022 6:04 PM, Richard Damon wrote:
> On 3/23/22 9:09 AM, olcott wrote:
>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>> On 3/23/22 12:00 AM, olcott wrote:
>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>> decider (SHD).
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>> its final state.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>> reach its
>>>>>>>>>> final state.
>>>>>>>>> But for your "PO-machines":
>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>      corresponds to
>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>> and
>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>> never halts.
>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>>> machines.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>>>> machine
>>>>>>> is.  Unlike Turing machines, your machines are magic -- identical
>>>>>>> state
>>>>>>> transition functions can entail different configuration sequences
>>>>>>> for
>>>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>
>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>> many months ago proves that you are being dishonest.
>>>>>
>>>>> You said this:
>>>>>
>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>> halts.
>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>
>>>>
>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive
>>>> the same result. They are not identical final strings.
>>>>
>>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>>> write Ĥ your readers must assume that you are referring to something
>>>>> about which this quote applies.
>>>>>
>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>> not only repudiate what you said, you must accept the converse,
>>>>> i.e. that if
>>>>>
>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>
>>>>> then
>>>>>
>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>
>>>>> So, do you retract what you said and accept this fact about Linz's
>>>>> H and
>>>>> Ĥ?
>>>>>
>>>>
>>>> You you continue to say that you believe that a decider must report
>>>> on its own behavior when you already know damn well that a decider
>>>> only computes the mapping from its inputs to its own final state.
>>>
>>> A Decider must report on its own behavior (or the behavior of a copy
>>> of it) if that is what the input asks for.
>>>
>> You know that a decider only computes the mapping from its input
>> finite strings to its own final state thus you know that you lie what
>> you say that a decider must compute the mapping from a non-finite
>> sting non-input.
>>
>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>
>
> I don't, but you seem to like to.
>
> I never said that H needs to compute a mapping of anything but what has
> been given as an input.
>
> The only thing H needs to compute the mapping of is <H^> <H^>, which is
> EXACTLY the string on its input.
>
> The problem which you don't seem to understand is that the MAPPING it
> needs to try and compute (and which is not guaranteed to BE Computable),
> is the Behavior of the machine it represents, H^ applied to <H^>, as
> that is the mapping of the Halting Function.

That is a non finite string non input, so you lied.

--
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: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]

<k0O_J.200092$r6p7.595@fx41.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!peer02.ams4!peer.am4.highwinds-media.com!peer01.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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 121
Message-ID: <k0O_J.200092$r6p7.595@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: Wed, 23 Mar 2022 19:26:13 -0400
X-Received-Bytes: 6211
 by: Richard Damon - Wed, 23 Mar 2022 23:26 UTC

On 3/23/22 7:20 PM, olcott wrote:
> On 3/23/2022 6:04 PM, Richard Damon wrote:
>> On 3/23/22 9:09 AM, olcott wrote:
>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>> its final state.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>>> reach its
>>>>>>>>>>> final state.
>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>      corresponds to
>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>> and
>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>> never halts.
>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>>>> machines.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> Everything Linz says, everything, is predicated on what a Turing
>>>>>>>> machine
>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>> identical state
>>>>>>>> transition functions can entail different configuration
>>>>>>>> sequences for
>>>>>>>> the same input.  Nothing you say has any relevance to Linz's Turing
>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>
>>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>>> many months ago proves that you are being dishonest.
>>>>>>
>>>>>> You said this:
>>>>>>
>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>> halts.
>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>
>>>>>
>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive
>>>>> the same result. They are not identical final strings.
>>>>>
>>>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>> about which this quote applies.
>>>>>>
>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you
>>>>>> must
>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>> i.e. that if
>>>>>>
>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>
>>>>>> then
>>>>>>
>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>
>>>>>> So, do you retract what you said and accept this fact about Linz's
>>>>>> H and
>>>>>> Ĥ?
>>>>>>
>>>>>
>>>>> You you continue to say that you believe that a decider must report
>>>>> on its own behavior when you already know damn well that a decider
>>>>> only computes the mapping from its inputs to its own final state.
>>>>
>>>> A Decider must report on its own behavior (or the behavior of a copy
>>>> of it) if that is what the input asks for.
>>>>
>>> You know that a decider only computes the mapping from its input
>>> finite strings to its own final state thus you know that you lie what
>>> you say that a decider must compute the mapping from a non-finite
>>> sting non-input.
>>>
>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>
>>
>> I don't, but you seem to like to.
>>
>> I never said that H needs to compute a mapping of anything but what
>> has been given as an input.
>>
>> The only thing H needs to compute the mapping of is <H^> <H^>, which
>> is EXACTLY the string on its input.
>>
>> The problem which you don't seem to understand is that the MAPPING it
>> needs to try and compute (and which is not guaranteed to BE
>> Computable), is the Behavior of the machine it represents, H^ applied
>> to <H^>, as that is the mapping of the Halting Function.
>
> That is a non finite string non input, so you lied.
>

<H^> <H^> is a finite string, which is what needs to be mapped, so you
are just lying.

You don't understand the difference between the INPUT and the required
mapping OUTPUT.

2+3 = 5, but 5 is NOT an input to + so how can it be?

Re: Refuting the Peter Linz Halting Problem Proof V5 [ bald faced liar ]

<i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 18:50:36 -0500
Date: Wed, 23 Mar 2022 18:50:34 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ bald faced
liar ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
<k0O_J.200092$r6p7.595@fx41.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <k0O_J.200092$r6p7.595@fx41.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 138
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VBy6ncRDI7aOUwM22KL2Gsgw0pVA6NwuvtdkbSCMKM0h3ZTkvDervAXY3qq88dHv95iXRfYUpo0FmYo!1rzQyzvyelwBAvChN3PMtqDBWpfNWg4mtwC8ndnM676Ci+GMreDRd85g+BUx9OxRrrlNopihejO/
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: 7103
 by: olcott - Wed, 23 Mar 2022 23:50 UTC

On 3/23/2022 6:26 PM, Richard Damon wrote:
> On 3/23/22 7:20 PM, olcott wrote:
>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>> On 3/23/22 9:09 AM, olcott wrote:
>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>> its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>>>> reach its
>>>>>>>>>>>> final state.
>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>      corresponds to
>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>> and
>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>>> never halts.
>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>> halts"
>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>>>>>>> machines.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>> Turing machine
>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>> identical state
>>>>>>>>> transition functions can entail different configuration
>>>>>>>>> sequences for
>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>> Turing
>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>
>>>>>>>> That your only rebuttal to what I say now is dredging up what I
>>>>>>>> said
>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>
>>>>>>> You said this:
>>>>>>>
>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>>> halts.
>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>
>>>>>>
>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive
>>>>>> the same result. They are not identical final strings.
>>>>>>
>>>>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>>> about which this quote applies.
>>>>>>>
>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you
>>>>>>> must
>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>> i.e. that if
>>>>>>>
>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>
>>>>>>> then
>>>>>>>
>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>
>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>> Linz's H and
>>>>>>> Ĥ?
>>>>>>>
>>>>>>
>>>>>> You you continue to say that you believe that a decider must
>>>>>> report on its own behavior when you already know damn well that a
>>>>>> decider only computes the mapping from its inputs to its own final
>>>>>> state.
>>>>>
>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>> copy of it) if that is what the input asks for.
>>>>>
>>>> You know that a decider only computes the mapping from its input
>>>> finite strings to its own final state thus you know that you lie
>>>> what you say that a decider must compute the mapping from a
>>>> non-finite sting non-input.
>>>>
>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>
>>>
>>> I don't, but you seem to like to.
>>>
>>> I never said that H needs to compute a mapping of anything but what
>>> has been given as an input.
>>>
>>> The only thing H needs to compute the mapping of is <H^> <H^>, which
>>> is EXACTLY the string on its input.
>>>
>>> The problem which you don't seem to understand is that the MAPPING it
>>> needs to try and compute (and which is not guaranteed to BE
>>> Computable), is the Behavior of the machine it represents, H^ applied
>>> to <H^>, as that is the mapping of the Halting Function.
>>
>> That is a non finite string non input, so you lied.
>>
>
> <H^> <H^> is a finite string, which is what needs to be mapped, so you
> are just lying.
>

On 3/23/2022 6:04 PM, Richard Damon wrote:
> the MAPPING it needs to try and compute (and which is
> not guaranteed to BE Computable), is the Behavior of
> the machine it represents, H^ applied to <H^>,

So you are just bald faced liar then.
It does not map H^ applied to <H^> to anything.
It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn

--
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: Refuting the Peter Linz Halting Problem Proof V5 [ bald faced liar ]

<NKO_J.440293$Rza5.166859@fx47.iad>

 copy mid

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

 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!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ bald faced
liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
<k0O_J.200092$r6p7.595@fx41.iad>
<i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 147
Message-ID: <NKO_J.440293$Rza5.166859@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 23 Mar 2022 20:15:45 -0400
X-Received-Bytes: 7300
 by: Richard Damon - Thu, 24 Mar 2022 00:15 UTC

On 3/23/22 7:50 PM, olcott wrote:
> On 3/23/2022 6:26 PM, Richard Damon wrote:
>> On 3/23/22 7:20 PM, olcott wrote:
>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach
>>>>>>>>>>>>> its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
>>>>>>>>>>>>> reach its
>>>>>>>>>>>>> final state.
>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>> and
>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>>>> never halts.
>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>> halts"
>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>> Turing
>>>>>>>>>>>> machines.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>
>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>> Turing machine
>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>> identical state
>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>> sequences for
>>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>>> Turing
>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>
>>>>>>>>> That your only rebuttal to what I say now is dredging up what I
>>>>>>>>> said
>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>
>>>>>>>> You said this:
>>>>>>>>
>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>>>> halts.
>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>
>>>>>>>
>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>
>>>>>>>> four days ago and you haven't retracted it.  Until you do, when you
>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>> something
>>>>>>>> about which this quote applies.
>>>>>>>>
>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>> you must
>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>> i.e. that if
>>>>>>>>
>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>
>>>>>>>> then
>>>>>>>>
>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>
>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>> Linz's H and
>>>>>>>> Ĥ?
>>>>>>>>
>>>>>>>
>>>>>>> You you continue to say that you believe that a decider must
>>>>>>> report on its own behavior when you already know damn well that a
>>>>>>> decider only computes the mapping from its inputs to its own
>>>>>>> final state.
>>>>>>
>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>> copy of it) if that is what the input asks for.
>>>>>>
>>>>> You know that a decider only computes the mapping from its input
>>>>> finite strings to its own final state thus you know that you lie
>>>>> what you say that a decider must compute the mapping from a
>>>>> non-finite sting non-input.
>>>>>
>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>
>>>>
>>>> I don't, but you seem to like to.
>>>>
>>>> I never said that H needs to compute a mapping of anything but what
>>>> has been given as an input.
>>>>
>>>> The only thing H needs to compute the mapping of is <H^> <H^>, which
>>>> is EXACTLY the string on its input.
>>>>
>>>> The problem which you don't seem to understand is that the MAPPING
>>>> it needs to try and compute (and which is not guaranteed to BE
>>>> Computable), is the Behavior of the machine it represents, H^
>>>> applied to <H^>, as that is the mapping of the Halting Function.
>>>
>>> That is a non finite string non input, so you lied.
>>>
>>
>> <H^> <H^> is a finite string, which is what needs to be mapped, so you
>> are just lying.
>>
>
> On 3/23/2022 6:04 PM, Richard Damon wrote:
> > the MAPPING it needs to try and compute (and which is
> > not guaranteed to BE Computable), is the Behavior of
> > the machine it represents, H^ applied to <H^>,
>
> So you are just bald faced liar then.
> It does not map H^ applied to <H^> to anything.
> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>
>

I never said it did.

It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
FUNCTION) whether H^ applied to <H^> will Halt.

Do you NOT UNDERSTAND what a mapping is and the difference between its
domain and its range and on what basis it maps?

we can run the COSINE mapping of 0 to 1, but 1 isn't a 'behavior' of 0,
it is the results of the mapping of the COSINE function.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ correct criteria ]

<AOedncbY-vP7VKb_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 20:29:10 -0500
Date: Wed, 23 Mar 2022 20:29:07 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ correct
criteria ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
<k0O_J.200092$r6p7.595@fx41.iad>
<i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>
<NKO_J.440293$Rza5.166859@fx47.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <NKO_J.440293$Rza5.166859@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AOedncbY-vP7VKb_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 154
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gfGFuq2Hs0JpPE76+LhSjc5GrMRUIx1yzW72r46pfK4glUMcsY+8+hdiBdVpb+Ou6A2/fKHtim1RvyC!yQ/U4t/HNYOILqJ+3rLJIVWyAEjpTZI53sKjmTWNU1Oqz9vUtrc+SWBiycTRFlnI+z4hr6gLuJb8
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: 7932
 by: olcott - Thu, 24 Mar 2022 01:29 UTC

On 3/23/2022 7:15 PM, Richard Damon wrote:
> On 3/23/22 7:50 PM, olcott wrote:
>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>> On 3/23/22 7:20 PM, olcott wrote:
>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>> and
>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>>> halts"
>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>>> Turing
>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>
>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>> Turing machine
>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>> identical state
>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>> sequences for
>>>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>>>> Turing
>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>
>>>>>>>>>> That your only rebuttal to what I say now is dredging up what
>>>>>>>>>> I said
>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>
>>>>>>>>> You said this:
>>>>>>>>>
>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>> never halts.
>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>
>>>>>>>>
>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>
>>>>>>>>> four days ago and you haven't retracted it.  Until you do, when
>>>>>>>>> you
>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>> something
>>>>>>>>> about which this quote applies.
>>>>>>>>>
>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>>> you must
>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>> i.e. that if
>>>>>>>>>
>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>
>>>>>>>>> then
>>>>>>>>>
>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>
>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>> Linz's H and
>>>>>>>>> Ĥ?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>> report on its own behavior when you already know damn well that
>>>>>>>> a decider only computes the mapping from its inputs to its own
>>>>>>>> final state.
>>>>>>>
>>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>>> copy of it) if that is what the input asks for.
>>>>>>>
>>>>>> You know that a decider only computes the mapping from its input
>>>>>> finite strings to its own final state thus you know that you lie
>>>>>> what you say that a decider must compute the mapping from a
>>>>>> non-finite sting non-input.
>>>>>>
>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>
>>>>>
>>>>> I don't, but you seem to like to.
>>>>>
>>>>> I never said that H needs to compute a mapping of anything but what
>>>>> has been given as an input.
>>>>>
>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>> which is EXACTLY the string on its input.
>>>>>
>>>>> The problem which you don't seem to understand is that the MAPPING
>>>>> it needs to try and compute (and which is not guaranteed to BE
>>>>> Computable), is the Behavior of the machine it represents, H^
>>>>> applied to <H^>, as that is the mapping of the Halting Function.
>>>>
>>>> That is a non finite string non input, so you lied.
>>>>
>>>
>>> <H^> <H^> is a finite string, which is what needs to be mapped, so
>>> you are just lying.
>>>
>>
>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>  > the MAPPING it needs to try and compute (and which is
>>  > not guaranteed to BE Computable), is the Behavior of
>>  > the machine it represents, H^ applied to <H^>,
>>
>> So you are just bald faced liar then.
>> It does not map H^ applied to <H^> to anything.
>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>
>>
>
> I never said it did.
>
> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
> FUNCTION) whether H^ applied to <H^> will Halt.

It must map the input to an accept or reject state based on the actual
behavior actually specified by this input as measured by N steps of the
correct UTM simulation of this input.


Click here to read the complete article
Re: Refuting the Peter Linz Halting Problem Proof V5 [ correct criteria ]

<EZP_J.169268$4JN7.90286@fx05.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ correct
criteria ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
<k0O_J.200092$r6p7.595@fx41.iad>
<i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>
<NKO_J.440293$Rza5.166859@fx47.iad>
<AOedncbY-vP7VKb_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <AOedncbY-vP7VKb_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 174
Message-ID: <EZP_J.169268$4JN7.90286@fx05.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 23 Mar 2022 21:39:53 -0400
X-Received-Bytes: 8552
 by: Richard Damon - Thu, 24 Mar 2022 01:39 UTC

On 3/23/22 9:29 PM, olcott wrote:
> On 3/23/2022 7:15 PM, Richard Damon wrote:
>> On 3/23/22 7:50 PM, olcott wrote:
>>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>>> On 3/23/22 7:20 PM, olcott wrote:
>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt
>>>>>>>>>>>>>>> decider (SHD).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input
>>>>>>>>>>>>>> halts"
>>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy
>>>>>>>>>>>>> of H
>>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>
>>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>>> Turing machine
>>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>>> identical state
>>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>>> sequences for
>>>>>>>>>>>> the same input.  Nothing you say has any relevance to Linz's
>>>>>>>>>>>> Turing
>>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>>
>>>>>>>>>>> That your only rebuttal to what I say now is dredging up what
>>>>>>>>>>> I said
>>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>>
>>>>>>>>>> You said this:
>>>>>>>>>>
>>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>> never halts.
>>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>>
>>>>>>>>>> four days ago and you haven't retracted it.  Until you do,
>>>>>>>>>> when you
>>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>>> something
>>>>>>>>>> about which this quote applies.
>>>>>>>>>>
>>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>>>> you must
>>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>>> i.e. that if
>>>>>>>>>>
>>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> then
>>>>>>>>>>
>>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>>
>>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>>> Linz's H and
>>>>>>>>>> Ĥ?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>>> report on its own behavior when you already know damn well that
>>>>>>>>> a decider only computes the mapping from its inputs to its own
>>>>>>>>> final state.
>>>>>>>>
>>>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>>>> copy of it) if that is what the input asks for.
>>>>>>>>
>>>>>>> You know that a decider only computes the mapping from its input
>>>>>>> finite strings to its own final state thus you know that you lie
>>>>>>> what you say that a decider must compute the mapping from a
>>>>>>> non-finite sting non-input.
>>>>>>>
>>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>>
>>>>>>
>>>>>> I don't, but you seem to like to.
>>>>>>
>>>>>> I never said that H needs to compute a mapping of anything but
>>>>>> what has been given as an input.
>>>>>>
>>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>>> which is EXACTLY the string on its input.
>>>>>>
>>>>>> The problem which you don't seem to understand is that the MAPPING
>>>>>> it needs to try and compute (and which is not guaranteed to BE
>>>>>> Computable), is the Behavior of the machine it represents, H^
>>>>>> applied to <H^>, as that is the mapping of the Halting Function.
>>>>>
>>>>> That is a non finite string non input, so you lied.
>>>>>
>>>>
>>>> <H^> <H^> is a finite string, which is what needs to be mapped, so
>>>> you are just lying.
>>>>
>>>
>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>  > the MAPPING it needs to try and compute (and which is
>>>  > not guaranteed to BE Computable), is the Behavior of
>>>  > the machine it represents, H^ applied to <H^>,
>>>
>>> So you are just bald faced liar then.
>>> It does not map H^ applied to <H^> to anything.
>>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>
>>>
>>
>> I never said it did.
>>
>> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
>> FUNCTION) whether H^ applied to <H^> will Halt.
>
> It must map the input to an accept or reject state based on the actual
> behavior actually specified by this input as measured by N steps of the
> correct UTM simulation of this input.
>
>


Click here to read the complete article
Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]

<87sfr8f7e9.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]
Date: Thu, 24 Mar 2022 01:47:58 +0000
Organization: A noiseless patient Spider
Lines: 119
Message-ID: <87sfr8f7e9.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk>
<tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk>
<qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<875yo4itma.fsf@bsb.me.uk>
<DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ils4gxdn.fsf@bsb.me.uk>
<CuudnRRb-NdZA6b_nZ2dnUU7_83NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="78c7aa729bd6a3a0acfdd4b6ad03f8ab";
logging-data="23585"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX188gBOlfbZAyUV33wTs/VYf93fPpkL2QNY="
Cancel-Lock: sha1:GzA3MIGEYbRMZwco6SS27//5kuc=
sha1:C1+Wpbw24n8L8x3XhrTg2OUPRZE=
X-BSB-Auth: 1.08813029eea38f50e6f6.20220324014758GMT.87sfr8f7e9.fsf@bsb.me.uk
 by: Ben Bacarisse - Thu, 24 Mar 2022 01:47 UTC

olcott <NoOne@NoWhere.com> writes:

> On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>>>> final state.
>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>> corresponds to
>>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>> and
>>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>>>> machines.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>>>> transition functions can entail different configuration sequences for
>>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>
>>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>>> many months ago proves that you are being dishonest.
>>>>>> You said this:
>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>
>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>>> same result. They are not identical final strings.
>>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>>> different transitions than H does, since they both have identical
>>>> inputs. If one compares some strings, the other will too and they will
>>>> both arrive as the same result and they will both behave in the same
>>>> way. You H and Ĥ are obviously not Turing machines.
>>>> I regret dropping down into simplistic metaphors. I'd rather keep this
>>>> about formal Turing machines, but you don't really know what they are,
>>>> and you certainly can't reason about them, so that hits a brick wall
>>>> pretty quickly.
>>>>
>>>>>> four days ago and you haven't retracted it. Until you do, when you
>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>> about which this quote applies.
>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>> i.e. that if
>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>> then
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>>>> Ĥ?
>>>>>
>>>>> You you continue to say that you believe that a decider must report on
>>>>> its own behavior when you already know damn well that a decider only
>>>>> computes the mapping from its inputs to its own final state.
>>>>
>>>> I continue to believe that I know what a Turing machine is and that you
>>>> don't. A Turing machine and an exact copy of it can't entail different
>>>> sequences of transitions. Your H and Ĥ don't have this property. They
>>>> are not Turing machines.
>>>
>>> I agree that a TM and an exact copy of it must entail the same
>>> sequence of transitions when applied to identical input.
>> OK, but what about your magic PO-machines? They don't behave like this
>> (apparently). It's easy to agree to facts about Turing machines, if
>> your plan is to keep talking about machines where
>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>
> Not if H and Ĥ are identical and are not allowed to use their machine
> address to tell them apart.

H and Ĥ are never identical. You know what the hat means don't you? So
your magic PO-machines have machine addresses, do they? If so, that's
another difference with Turing machines. You won't be able to say
anything about Linz's proof unless you start to talk about Turing
machines.

> In my prior claims either H and Ĥ were not identical finite stings

You've lost the plot mate. Nether is even a string. If you made a
prior claim about H or Ĥ being strings (whether identical or not), that
was wrong too.

As far as I can tell, when you write H and Ĥ we must assume that these
refer to some kind of as yet unspecified machine that has "machine
addresses" (so definitely not what Linz is taking about). And that
these H and Ĥ have the property that H applied to some string can
transition to a different state to an exact copy of H if it's embedded
in some other machine. I suppose they don't actually have to be
literally magic to do this, but they are certainly not Turing machines.

Do you have anything to say about Linz's proof?

--
Ben.

Re: Refuting the Peter Linz Halting Problem Proof V5 [ correct criteria ]

<T6ydnWVxPKmFTKb_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 21:02:00 -0500
Date: Wed, 23 Mar 2022 21:01:58 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ correct
criteria ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<XmD_J.161395$4JN7.131178@fx05.iad>
<xsudnfT7pbiRgab_nZ2dnUU7_8zNnZ2d@giganews.com>
<ZHN_J.207360$Y1A7.26196@fx43.iad>
<mbadnWPfYbarNqb_nZ2dnUU7_8xh4p2d@giganews.com>
<k0O_J.200092$r6p7.595@fx41.iad>
<i5idnalkHYDRL6b_nZ2dnUU7_83NnZ2d@giganews.com>
<NKO_J.440293$Rza5.166859@fx47.iad>
<AOedncbY-vP7VKb_nZ2dnUU7_8zNnZ2d@giganews.com>
<EZP_J.169268$4JN7.90286@fx05.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <EZP_J.169268$4JN7.90286@fx05.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <T6ydnWVxPKmFTKb_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 175
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zYg938w2ueQbjwPgegfSHxlJjQv6vsXjvogV8AnMpHPSphoz5EYYY5YySlLLlxo0i/ypZ/fLlq1Ql6x!lzeoeAKcboFyU9vPd43VwYWewN6GOeY6LbKJyEo/67eD1+G3sJpHZpFZqqaRexLXGuBqU8S+aX6k
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: 8989
 by: olcott - Thu, 24 Mar 2022 02:01 UTC

On 3/23/2022 8:39 PM, Richard Damon wrote:
> On 3/23/22 9:29 PM, olcott wrote:
>> On 3/23/2022 7:15 PM, Richard Damon wrote:
>>> On 3/23/22 7:50 PM, olcott wrote:
>>>> On 3/23/2022 6:26 PM, Richard Damon wrote:
>>>>> On 3/23/22 7:20 PM, olcott wrote:
>>>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>>>> On 3/23/22 9:09 AM, olcott wrote:
>>>>>>>> On 3/23/2022 6:19 AM, Richard Damon wrote:
>>>>>>>>> On 3/23/22 12:00 AM, olcott wrote:
>>>>>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating
>>>>>>>>>>>>>>>> halt decider (SHD).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>>>> final state.
>>>>>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>>>>>>      "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>>>>>>      corresponds to
>>>>>>>>>>>>>>>      H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>      "The copy of H at Ĥ.qx correctly decides that its
>>>>>>>>>>>>>>> input never halts.
>>>>>>>>>>>>>>>      H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its
>>>>>>>>>>>>>>> input halts"
>>>>>>>>>>>>>>> so this has nothing to do with Linz.  He is talking about
>>>>>>>>>>>>>>> Turing
>>>>>>>>>>>>>>> machines.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy
>>>>>>>>>>>>>> of H
>>>>>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Everything Linz says, everything, is predicated on what a
>>>>>>>>>>>>> Turing machine
>>>>>>>>>>>>> is.  Unlike Turing machines, your machines are magic --
>>>>>>>>>>>>> identical state
>>>>>>>>>>>>> transition functions can entail different configuration
>>>>>>>>>>>>> sequences for
>>>>>>>>>>>>> the same input.  Nothing you say has any relevance to
>>>>>>>>>>>>> Linz's Turing
>>>>>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>>>>>
>>>>>>>>>>>> That your only rebuttal to what I say now is dredging up
>>>>>>>>>>>> what I said
>>>>>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>>>>>>
>>>>>>>>>>> You said this:
>>>>>>>>>>>
>>>>>>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input
>>>>>>>>>>> never halts.
>>>>>>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must
>>>>>>>>>> derive the same result. They are not identical final strings.
>>>>>>>>>>
>>>>>>>>>>> four days ago and you haven't retracted it.  Until you do,
>>>>>>>>>>> when you
>>>>>>>>>>> write Ĥ your readers must assume that you are referring to
>>>>>>>>>>> something
>>>>>>>>>>> about which this quote applies.
>>>>>>>>>>>
>>>>>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ
>>>>>>>>>>> you must
>>>>>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>>>>>> i.e. that if
>>>>>>>>>>>
>>>>>>>>>>>    Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> then
>>>>>>>>>>>
>>>>>>>>>>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>>>>>>
>>>>>>>>>>> So, do you retract what you said and accept this fact about
>>>>>>>>>>> Linz's H and
>>>>>>>>>>> Ĥ?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You you continue to say that you believe that a decider must
>>>>>>>>>> report on its own behavior when you already know damn well
>>>>>>>>>> that a decider only computes the mapping from its inputs to
>>>>>>>>>> its own final state.
>>>>>>>>>
>>>>>>>>> A Decider must report on its own behavior (or the behavior of a
>>>>>>>>> copy of it) if that is what the input asks for.
>>>>>>>>>
>>>>>>>> You know that a decider only computes the mapping from its input
>>>>>>>> finite strings to its own final state thus you know that you lie
>>>>>>>> what you say that a decider must compute the mapping from a
>>>>>>>> non-finite sting non-input.
>>>>>>>>
>>>>>>>> WHY LIE ?  WHY LIE ?  WHY LIE ?  WHY LIE ?
>>>>>>>>
>>>>>>>
>>>>>>> I don't, but you seem to like to.
>>>>>>>
>>>>>>> I never said that H needs to compute a mapping of anything but
>>>>>>> what has been given as an input.
>>>>>>>
>>>>>>> The only thing H needs to compute the mapping of is <H^> <H^>,
>>>>>>> which is EXACTLY the string on its input.
>>>>>>>
>>>>>>> The problem which you don't seem to understand is that the
>>>>>>> MAPPING it needs to try and compute (and which is not guaranteed
>>>>>>> to BE Computable), is the Behavior of the machine it represents,
>>>>>>> H^ applied to <H^>, as that is the mapping of the Halting Function.
>>>>>>
>>>>>> That is a non finite string non input, so you lied.
>>>>>>
>>>>>
>>>>> <H^> <H^> is a finite string, which is what needs to be mapped, so
>>>>> you are just lying.
>>>>>
>>>>
>>>> On 3/23/2022 6:04 PM, Richard Damon wrote:
>>>>  > the MAPPING it needs to try and compute (and which is
>>>>  > not guaranteed to BE Computable), is the Behavior of
>>>>  > the machine it represents, H^ applied to <H^>,
>>>>
>>>> So you are just bald faced liar then.
>>>> It does not map H^ applied to <H^> to anything.
>>>> It maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>
>>>>
>>>
>>> I never said it did.
>>>
>>> It maps the INPUT: <H^> <H^> to (OUTPUT) Qy or Qn based on (THE
>>> FUNCTION) whether H^ applied to <H^> will Halt.
>>
>> It must map the input to an accept or reject state based on the actual
>> behavior actually specified by this input as measured by N steps of
>> the correct UTM simulation of this input.
>>
>>
>
> Almost, it must map the INPUT <H^> <H^> to an OUTPUT Qy or Qn, based on
> the FUNCTION it is computing.
>
> There is NO requirement that it be based on its on simulation, or only N
> steps of a UTM.
>


Click here to read the complete article
Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual agreement ]

<StWdnYZg3vUbSab_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.mixmin.net!news2.arglkargh.de!news.in-chemnitz.de!3.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 23 Mar 2022 21:16:38 -0500
Date: Wed, 23 Mar 2022 21:16:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ mutual
agreement ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87bkxxjq50.fsf@bsb.me.uk> <qeydnSNLM57xBqf_nZ2dnUU7_8zNnZ2d@giganews.com>
<875yo4itma.fsf@bsb.me.uk> <DbCdnRtYle25oab_nZ2dnUU7_8zNnZ2d@giganews.com>
<87ils4gxdn.fsf@bsb.me.uk> <CuudnRRb-NdZA6b_nZ2dnUU7_83NnZ2d@giganews.com>
<87sfr8f7e9.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <87sfr8f7e9.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <StWdnYZg3vUbSab_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 138
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NP1JEapkd5NQQtgtd50J+uOBia/4xq3BTIQUsleg0dL7o/If29E20tBxuA9gIaRqBQ/IV1LHl4eAYlB!qX4cQukk6NYpBRqmIB9WrtftztIbsTnUbXUqBaLdLCmxugeh5ALNXXj2KEvlyQK8vBRPBgHVsxKh
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: 8476
 by: olcott - Thu, 24 Mar 2022 02:16 UTC

On 3/23/2022 8:47 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/23/2022 4:41 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/23/2022 10:19 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/22/2022 10:37 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/22/2022 9:32 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>>>>>>>> final state.
>>>>>>>>>>> But for your "PO-machines":
>>>>>>>>>>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>>>>>> corresponds to
>>>>>>>>>>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>>>>>> and
>>>>>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>>>>>> so this has nothing to do with Linz. He is talking about Turing
>>>>>>>>>>> machines.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>>>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>>
>>>>>>>>> Everything Linz says, everything, is predicated on what a Turing machine
>>>>>>>>> is. Unlike Turing machines, your machines are magic -- identical state
>>>>>>>>> transition functions can entail different configuration sequences for
>>>>>>>>> the same input. Nothing you say has any relevance to Linz's Turing
>>>>>>>>> machines until you categorically repudiate this nonsense.
>>>>>>>>
>>>>>>>> That your only rebuttal to what I say now is dredging up what I said
>>>>>>>> many months ago proves that you are being dishonest.
>>>>>>> You said this:
>>>>>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>
>>>>>> If ⟨H⟩ and ⟨Ĥ⟩ were identical finite strings then they must derive the
>>>>>> same result. They are not identical final strings.
>>>>> If H and Ĥ are Turing machines the copy of H at Ĥ.qx cannot make any
>>>>> different transitions than H does, since they both have identical
>>>>> inputs. If one compares some strings, the other will too and they will
>>>>> both arrive as the same result and they will both behave in the same
>>>>> way. You H and Ĥ are obviously not Turing machines.
>>>>> I regret dropping down into simplistic metaphors. I'd rather keep this
>>>>> about formal Turing machines, but you don't really know what they are,
>>>>> and you certainly can't reason about them, so that hits a brick wall
>>>>> pretty quickly.
>>>>>
>>>>>>> four days ago and you haven't retracted it. Until you do, when you
>>>>>>> write Ĥ your readers must assume that you are referring to something
>>>>>>> about which this quote applies.
>>>>>>> What's more, for your remarks to have any bearing on Linz's Ĥ you must
>>>>>>> not only repudiate what you said, you must accept the converse,
>>>>>>> i.e. that if
>>>>>>> Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* Ĥ.qn
>>>>>>> then
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn
>>>>>>> So, do you retract what you said and accept this fact about Linz's H and
>>>>>>> Ĥ?
>>>>>>
>>>>>> You you continue to say that you believe that a decider must report on
>>>>>> its own behavior when you already know damn well that a decider only
>>>>>> computes the mapping from its inputs to its own final state.
>>>>>
>>>>> I continue to believe that I know what a Turing machine is and that you
>>>>> don't. A Turing machine and an exact copy of it can't entail different
>>>>> sequences of transitions. Your H and Ĥ don't have this property. They
>>>>> are not Turing machines.
>>>>
>>>> I agree that a TM and an exact copy of it must entail the same
>>>> sequence of transitions when applied to identical input.
>>> OK, but what about your magic PO-machines? They don't behave like this
>>> (apparently). It's easy to agree to facts about Turing machines, if
>>> your plan is to keep talking about machines where
>>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>
>> Not if H and Ĥ are identical and are not allowed to use their machine
>> address to tell them apart.
>
> H and Ĥ are never identical. You know what the hat means don't you? So
> your magic PO-machines have machine addresses, do they? If so, that's
> another difference with Turing machines. You won't be able to say
> anything about Linz's proof unless you start to talk about Turing
> machines.
>
>> In my prior claims either H and Ĥ were not identical finite stings
>
> You've lost the plot mate. Nether is even a string. If you made a
> prior claim about H or Ĥ being strings (whether identical or not), that
> was wrong too.
>
> As far as I can tell, when you write H and Ĥ we must assume that these
> refer to some kind of as yet unspecified machine that has "machine
> addresses" (so definitely not what Linz is taking about). And that
> these H and Ĥ have the property that H applied to some string can
> transition to a different state to an exact copy of H if it's embedded
> in some other machine. I suppose they don't actually have to be
> literally magic to do this, but they are certainly not Turing machines.
>
> Do you have anything to say about Linz's proof?
>

All halt deciders must map their input to an accept or reject state
based on the actual behavior actually specified by this input as
measured by a finite number of N steps of the correct UTM simulation of
this input.

This does not mean that they must simulate their input. It means that
the behavior that they are reporting on must be the same behavior that
would occur by a UTM simulation of N steps.

The constraint of a finite number of N steps is required to guarantee
that the halt decider always reports.

--
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:12345
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor