Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Death, when unnecessary, is a tragic thing. -- Flint, "Requiem for Methuselah", stardate 5843.7


devel / comp.theory / Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

SubjectAuthor
* Concise refutation of halting problem proofs V42 [where people getolcott
+* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
|+- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
|`* Concise refutation of halting problem proofs V42 [where peopleolcott
| +* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |`* Concise refutation of halting problem proofs V42 [where peopleolcott
| | +- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
| | `* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |  `* Concise refutation of halting problem proofs V42 [where peopleolcott
| |   +* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |   |+* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |   ||`* Concise refutation of halting problem proofs V42 [where peopleolcott
| |   || +- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
| |   || `* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |   ||  `* Concise refutation of halting problem proofs V42 [where peopleolcott
| |   ||   +* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |   ||   |`* Concise refutation of halting problem proofs V42 [where peopleolcott
| |   ||   | `- Concise refutation of halting problem proofs V42 [where people get stuck]Richard Damon
| |   ||   `- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
| |   |`* Concise refutation of halting problem proofs V42 [where peopleolcott
| |   | +* Concise refutation of halting problem proofs V42 [where peopleAndré G. Isaak
| |   | |`* Concise refutation of halting problem proofs V42 [where people get stuck]olcott
| |   | | `- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
| |   | `- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
| |   `- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
| `- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
+- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
`* Concise refutation of halting problem proofs V42 [where people get stuck]Ben Bacarisse
 +* Concise refutation of halting problem proofs V42 [where peopleolcott
 |`- Concise refutation of halting problem proofs V42 [where peopleRichard Damon
 `* Concise refutation of halting problem proofs V42 [compute theolcott
  `* Concise refutation of halting problem proofs V42 [compute theRichard Damon
   `* Concise refutation of halting problem proofs V42 [compute theolcott
    +* Concise refutation of halting problem proofs V42 [compute theAndré G. Isaak
    |+- Concise refutation of halting problem proofs V42 [compute the mapping]Julio Di Egidio
    |`* Concise refutation of halting problem proofs V42 [compute theolcott
    | `* Concise refutation of halting problem proofs V42 [compute theRichard Damon
    |  `* Concise refutation of halting problem proofs V42 [compute theolcott
    |   `* Concise refutation of halting problem proofs V42 [compute theRichard Damon
    |    `* Concise refutation of halting problem proofs V42 [ultimateolcott
    |     +* Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    |     |`* Concise refutation of halting problem proofs V42 [ultimateolcott
    |     | `- Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    |     `* Concise refutation of halting problem proofs V42 [ultimateAndré G. Isaak
    |      `* Concise refutation of halting problem proofs V42 [ultimateolcott
    |       +- Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    |       `* Concise refutation of halting problem proofs V42 [ultimateAndré G. Isaak
    |        `* Concise refutation of halting problem proofs V42 [ultimateolcott
    |         +* Concise refutation of halting problem proofs V42 [ultimateAndré G. Isaak
    |         |+* Concise refutation of halting problem proofs V42 [ultimateolcott
    |         ||+- Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    |         ||`* Concise refutation of halting problem proofs V42 [ultimateAndré G. Isaak
    |         || `* Concise refutation of halting problem proofs V42 [ultimateolcott
    |         ||  +* Concise refutation of halting problem proofs V42 [ultimateAndré G. Isaak
    |         ||  |`* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  | +* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  | |`* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  | | `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  | |  `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  | |   `- Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  | `* Concise refutation of halting problem proofs V42 [computerAndré G. Isaak
    |         ||  |  `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |   `* Concise refutation of halting problem proofs V42 [computerAndré G. Isaak
    |         ||  |    +* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |`* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    | `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |  `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    |   `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |    `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    |     `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |      `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    |       `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |        `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    |         `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |          `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    |           `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |            `* Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    |             `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |              `* Concise refutation of halting problem proofs V42 [computer scientist]Richard Damon
    |         ||  |    |               `* Concise refutation of halting problem proofs V42 [computerolcott
    |         ||  |    |                `- Concise refutation of halting problem proofs V42 [computerRichard Damon
    |         ||  |    +* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |`* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    | `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |  `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |   `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |    `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |     `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |      `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |       `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |        `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |         `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |          `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |           `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |            `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |             `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |              `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |               `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |                `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |                 `* Concise refutation of halting problem proofs V42 [honestolcott
    |         ||  |    |                  +- Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    |                  `* Concise refutation of halting problem proofs V42 [honestRichard Damon
    |         ||  |    `* Concise refutation of halting problem proofs V46 [computerolcott
    |         ||  `- Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    |         |+- Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    |         |`* Concise refutation of halting problem proofs V42 [ultimateolcott
    |         `- Concise refutation of halting problem proofs V42 [ultimateRichard Damon
    `* Concise refutation of halting problem proofs V42 [compute theRichard Damon

Pages:123456
Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<sqktb6$thq$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Date: Thu, 30 Dec 2021 11:21:25 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 40
Message-ID: <sqktb6$thq$1@dont-email.me>
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 30 Dec 2021 18:21:27 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="281e34967abc652e32513cf7d24af717";
logging-data="30266"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19o5N7P25ulvUD9bepMzPrC"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:569Bcp5t8kSI5U+ninYsizemzyw=
In-Reply-To: <C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 30 Dec 2021 18:21 UTC

On 2021-12-30 09:54, olcott wrote:
> On 12/30/2021 10:11 AM, Richard Damon wrote:
>> On 12/30/21 10:58 AM, olcott wrote:
>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>
>>>> We don't care if embedded_H is 'Correct', we care that it give the
>>>> same answer as H.
>>>>
>>>
>>> If it is correct and gives a different answer than H then it remains
>>> correct even if it gives a different answer than H.
>>>
>>
>> But since it IS a copy of H, then if it gives a different answer than
>> 'H' does, it shows that H fails to be a Computation, and thus Can't be
>> a Decider, and thus can't be a Halt Decider.
> H and embedded_H are able to give a different halt status determinations
> on the basis that embedded_H had its copy of H corrupted by the appended
> infinite loop.
>
> This means that a finite string comparison performed by H will determine
> that embedded_H is not identical to H.

And which two strings are being compared here? H hasn't been provided a
string describing itself nor a string describing embedded_H as part of
its input. All it has is a string describing Ĥ. What does it compare
this string to?

André

> When embedded_H is about to simulate embedded_H with identical inputs it
> terminates this simulation as matching the infinitely nested simulation
> infinite behavior pattern.
>
>

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<3EnzJ.189432$831.128951@fx40.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx40.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com>
<PTlzJ.235027$aF1.87891@fx98.iad>
<nJ-dnXnUS_4mb1D8nZ2dnUU7-I_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <nJ-dnXnUS_4mb1D8nZ2dnUU7-I_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 80
Message-ID: <3EnzJ.189432$831.128951@fx40.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 14:20:31 -0500
X-Received-Bytes: 4530
 by: Richard Damon - Thu, 30 Dec 2021 19:20 UTC

On 12/30/21 12:56 PM, olcott wrote:
> On 12/30/2021 11:20 AM, Richard Damon wrote:
>>
>> On 12/30/21 11:54 AM, olcott wrote:
>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>
>>>>>> We don't care if embedded_H is 'Correct', we care that it give the
>>>>>> same answer as H.
>>>>>>
>>>>>
>>>>> If it is correct and gives a different answer than H then it
>>>>> remains correct even if it gives a different answer than H.
>>>>>
>>>>
>>>> But since it IS a copy of H, then if it gives a different answer
>>>> than 'H' does, it shows that H fails to be a Computation, and thus
>>>> Can't be a Decider, and thus can't be a Halt Decider.
>>> H and embedded_H are able to give a different halt status
>>> determinations on the basis that embedded_H had its copy of H
>>> corrupted by the appended infinite loop.
>>
>> Which is AFTER all the code that matters. embedded_H must still get to
>> H.qy or H.qn exactly like H does.
>>
>> FAIL.
>
> *My criterion measure with Ben's notational conventions*
> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> As soon as embedded_H sees that its simulated input Turing machine
> description is about to invoke an identical copy of itself with
> identical inputs to its own inputs it aborts its simulation of this
> input and transitions to Ĥ.qn. When H performs this same process it does
> not see any identical copy of itself.
>

Except that this is NOT a pattern that leads to infinite execution, so H
gets the wrong answer. This has been shows to be true before, but I will
repeat it.

Let us look at the behavior of H^ <H^> or equivalently the running of
UTM(<H^>,<H^>) which is the definition of the correct answer that H
needs to return to be correct.

We Start at H^.q0 <H^>
That goes to H^.qx <H^> <H^>
Which is a copy of H.q0 <H^> <H^>

This H then starts its simulation at H^.q0 <H^> <H^>
It then simulates to H^.qx <H^> <H^>

It then sees that this is the same as a simulation of H^.q0 <H^> <H^>

Then, by your rule above, H goes to H.qn
Which is the same as H^.qn
Which means H^ Halts.

Thus H^ <H^> Halts.
Thus the RIGHT answer for H <H^> <H^> is to go to H.qy, but it went to
H.qn, so it gave the wrong answer.

Please point out which step is incorrect!

Note, H and embedded_H have the exact same algorithm, so need to behave
exactly the same for the same input data.

There is no way for H or embedded_H to know if it is 'H' or
'embedded_H', as it can't see the computation that it is part of, as
that would be an additional input that is NOT provided to it.

If you want to claim that these two identical copies of code, with the
exact same input, can behave differently, you need to PROVE that this is
possible, which it isn't.

Re: Concise refutation of halting problem proofs V42 [compute the mapping]

<FOnzJ.162569$np6.119786@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
<8GkzJ.67666$cW6.42695@fx08.iad>
<Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
<J7lzJ.133156$7D4.56836@fx37.iad>
<C-CdnTqrLLFIeVD8nZ2dnUU7-RWdnZ2d@giganews.com>
<uWlzJ.235028$aF1.204961@fx98.iad>
<X8qdnaH5EPMZaVD8nZ2dnUU7-LXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <X8qdnaH5EPMZaVD8nZ2dnUU7-LXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 135
Message-ID: <FOnzJ.162569$np6.119786@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 14:31:49 -0500
X-Received-Bytes: 7110
X-Original-Bytes: 6977
 by: Richard Damon - Thu, 30 Dec 2021 19:31 UTC

On 12/30/21 1:03 PM, olcott wrote:
> On 12/30/2021 11:23 AM, Richard Damon wrote:
>> On 12/30/21 11:56 AM, olcott wrote:
>>> On 12/30/2021 10:29 AM, Richard Damon wrote:
>>>> On 12/30/21 11:11 AM, olcott wrote:
>>>>> On 12/30/2021 9:57 AM, Richard Damon wrote:
>>>>>> On 12/30/21 10:20 AM, olcott wrote:
>>>>>>> On 12/30/2021 8:19 AM, Richard Damon wrote:
>>>>>>>> On 12/29/21 11:51 PM, olcott wrote:
>>>>>>>>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>>>>>>>>> On 12/29/21 11:02 PM, olcott wrote:
>>>>>>>>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>
>>>>>>>>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> It's not your criterion, it's mine.  It's also Linz's.  If
>>>>>>>>>>>> yours is not
>>>>>>>>>>>> the same as his (and mine), it should be different in some
>>>>>>>>>>>> way. (And we
>>>>>>>>>>>> can safely ignore it, since no one cares about your alternative
>>>>>>>>>>>> criteria.)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It has always been my criterion measure that halt deciders
>>>>>>>>>>> base their halt status decision on the pure simulation of
>>>>>>>>>>> their inputs.
>>>>>>>>>>>
>>>>>>>>>>> That your notational conventions very cleanly express this
>>>>>>>>>>> idea as applied to the Linz H is a good breakthrough.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> As soon as people understand that this same criterion measure
>>>>>>>>>>> applies recursively to every embedded_H at Ĥ.qx, then they
>>>>>>>>>>> will see how this criterion measure provides the means for
>>>>>>>>>>> embedded_H to correctly compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to
>>>>>>>>>>> Ĥ.qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes each level can use the test to determine if the halt
>>>>>>>>>> decider at that level got the right answer or not.
>>>>>>>>>>
>>>>>>>>>> The issue is that when we are doing this check, you check JUST
>>>>>>>>>> that level, and not lower levels.
>>>>>>>>>
>>>>>>>>> No you are wrong.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Source? (Some REAL reference)
>>>>>>>>
>>>>>>>
>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>
>>>>>>> The source is the correct reasoning of how the above criterion
>>>>>>> measure would be applied when H is copied to Ĥ.qx.
>>>>>>
>>>>>> We copy the ALGORITHM of H, the detailed step by step instructions
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> You keep thinking that a subsequent level UTM magically turns
>>>>>>> into embedded_H and aborts its simulation.
>>>>>>
>>>>>> There IS no UTM in the machine. PERIOD. (unless H IS a UTM)
>>>>>>
>>>>> H always bases its halt status decision on the behavior of the UTM
>>>>> simulation of its input. Thus embedded_H bases its halt status
>>>>> decision on the behavior of the UTM simulation of its input. This
>>>>> means that H and embedded_H continue a pure simulation of N steps
>>>>> of their input until their input halts on its own or this input
>>>>> demonstrates an infinite behavior pattern.
>>>>
>>>> And that means that H must NEVER halt its simulation of H^, and thus
>>>
>>> The reason why I ignore most of your posts is that I stop at the very
>>> first very stupid mistake.
>>>
>>
>> You mean you stop at the first thing you can't answer.
>>
>
> It is very stupid to say that
> "H must NEVER halt its simulation of H^"
>
> When I just said exactly how and when H does correctly halt its
> simulation of Ĥ:
>
> >>>> H and embedded_H continue a pure simulation of N steps of
> >>>> their input until their input halts on its own or this input
> >>>> demonstrates an infinite behavior pattern.
>
> In the future I will simply ignore these stupid mistakes so that other
> respondents only need to pay attention to my responses and can equally
> ignore the clutter of your stupid mistakes.
>

But there IS no finite pattern that demonstrates an infitite behavior
pattern.

FAIR WARNING. I reserve the right to just mention this proof every time
you repeat that claim without actually showing a problem with it.

If their IS a pattern that H thinks demonstrates an infinite behavior
pattern, and when it sees this it aborts its simulation and returns the
Non-Halting answer, then when we run an actual computation of H^ <H^>
then we will see that

H^ <H^> goes to H^.qx <H^> <H^> which is a copy of H.q0 <H^> <H^> which
will then run for some time until it sees the pattern that it thinks
demonstrates an infinite behavior pattern, and goes to H.qn which means
H^ goes to H^.qn which Halts.

This thus shows that H^ <H^> which is the equiavlent to UTM(<H^>,<H^>)
halts, and thus the pattern that H thought was proof of non-halting can
actually lead to a Halting behavior, so H was INCORRECT that this
pattern was actually proof of infinite behavior.

This means that you H, using that definition either fails to return an
answer at all, and thus fails to be a decider, or it fails to follow its
algorithm that your just defined.

FAIL.

You ar just assuming the existance of a finite set of patterns that
detect non-halting behavior. In other words, your 'proof' that the
problem is solvable requires as an assumption, that the problem is
solvable. This leads to a contradiction, showing that assumption to be
false.

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 30 Dec 2021 13:33:18 -0600
Date: Thu, 30 Dec 2021 13:33:16 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sqktb6$thq$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com>
Lines: 75
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-o1SoTatLmMfvR2iCsJ6gJXnjEuxa7Tmw+cCq2xQtaGdHjckWbiHswLfe55VfcXZ1O2/D0Y/sU21uFkz!fxBlZNLKadiPdhQnCgc0e6MYF1r7eXV1Z5/PsrtUdArt0yvEU0kWYrGzY9BlFtvaexsuDmiGexTA!WA==
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: 4441
 by: olcott - Thu, 30 Dec 2021 19:33 UTC

On 12/30/2021 12:21 PM, André G. Isaak wrote:
> On 2021-12-30 09:54, olcott wrote:
>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>> On 12/30/21 10:58 AM, olcott wrote:
>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>
>>>>> We don't care if embedded_H is 'Correct', we care that it give the
>>>>> same answer as H.
>>>>>
>>>>
>>>> If it is correct and gives a different answer than H then it remains
>>>> correct even if it gives a different answer than H.
>>>>
>>>
>>> But since it IS a copy of H, then if it gives a different answer than
>>> 'H' does, it shows that H fails to be a Computation, and thus Can't
>>> be a Decider, and thus can't be a Halt Decider.
>> H and embedded_H are able to give a different halt status
>> determinations on the basis that embedded_H had its copy of H
>> corrupted by the appended infinite loop.
>>
>> This means that a finite string comparison performed by H will
>> determine that embedded_H is not identical to H.
>
> And which two strings are being compared here? H hasn't been provided a
> string describing itself nor a string describing embedded_H as part of
> its input. All it has is a string describing Ĥ. What does it compare
> this string to?
>
> André

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

We as humans can see that while embedded_H performs a pure simulation of
its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:

copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this input
over and over without ever stopping.

Since a pure simulation of the input never stops we know that the UTM
simulation of this same input never stops because a UTM performs a pure
simulation of its input.

Thus we know that the "does not halt" halt status criteria of embedded_H
has been met.

In order for embedded_H to see this it needs to see that an identical
sequence of configurations keeps repeating.

We as humans can see that the input to embedded_H is always identical.
We as humans can see that the copy of embedded_H is always identical.
We as humans can see that these two things can verified by finite string
comparison.

That an identical copy of a function is called with identical inputs
proves infinite behavior.

>
>> When embedded_H is about to simulate embedded_H with identical inputs
>> it terminates this simulation as matching the infinitely nested
>> simulation infinite behavior pattern.
>>
>>
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<gfozJ.193364$qz4.96088@fx97.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx97.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 94
Message-ID: <gfozJ.193364$qz4.96088@fx97.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 15:02:21 -0500
X-Received-Bytes: 5065
X-Original-Bytes: 4932
 by: Richard Damon - Thu, 30 Dec 2021 20:02 UTC

On 12/30/21 2:33 PM, olcott wrote:
> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>> On 2021-12-30 09:54, olcott wrote:
>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>
>>>>>> We don't care if embedded_H is 'Correct', we care that it give the
>>>>>> same answer as H.
>>>>>>
>>>>>
>>>>> If it is correct and gives a different answer than H then it
>>>>> remains correct even if it gives a different answer than H.
>>>>>
>>>>
>>>> But since it IS a copy of H, then if it gives a different answer
>>>> than 'H' does, it shows that H fails to be a Computation, and thus
>>>> Can't be a Decider, and thus can't be a Halt Decider.
>>> H and embedded_H are able to give a different halt status
>>> determinations on the basis that embedded_H had its copy of H
>>> corrupted by the appended infinite loop.
>>>
>>> This means that a finite string comparison performed by H will
>>> determine that embedded_H is not identical to H.
>>
>> And which two strings are being compared here? H hasn't been provided
>> a string describing itself nor a string describing embedded_H as part
>> of its input. All it has is a string describing Ĥ. What does it
>> compare this string to?
>>
>> André
>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> We as humans can see that while embedded_H performs a pure simulation of
> its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>
> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this input
> over and over without ever stopping.
>
> Since a pure simulation of the input never stops we know that the UTM
> simulation of this same input never stops because a UTM performs a pure
> simulation of its input.
>
> Thus we know that the "does not halt" halt status criteria of embedded_H
> has been met.
>
> In order for embedded_H to see this it needs to see that an identical
> sequence of configurations keeps repeating.
>
> We as humans can see that the input to embedded_H is always identical.
> We as humans can see that the copy of embedded_H is always identical.
> We as humans can see that these two things can verified by finite string
> comparison.
>
> That an identical copy of a function is called with identical inputs
> proves infinite behavior.

Nope. Can you actually PROVE this. (See next paragraph).

Remember, H doesn't actually 'call' the computation at its input, but
simulates it with a requirement that H (to meet its requirement) does
its processing in finite time, and so may abort its simulation. This
means rules based on actual function calls do not apply.

If H DOES act like a direct call or pure simulation, then your argument
proves that H(<H^>,<H^>) will fail to answer, and thus fail to meet its
requirement to be a decider.

If H DOES abort its simulation, then it CAN'T support infinite
recursion, and the act of aborting converts a potentially infinite
behavior based on calling/pure simulation into potentially finite
behavior of the using computation.

When we examine this actual computation, we see that if H answers
non-halting then the H^ that uses is will be halting, so for the case of
H^(<H^>) which uses H(<H^>,<H^>) we see that H is wrong to say non-halting.

FAIL.

>
>>
>>> When embedded_H is about to simulate embedded_H with identical inputs
>>> it terminates this simulation as matching the infinitely nested
>>> simulation infinite behavior pattern.
>>>
>>>
>>
>>
>
>

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<sql4qd$dre$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Date: Thu, 30 Dec 2021 13:29:01 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 74
Message-ID: <sql4qd$dre$1@dont-email.me>
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 30 Dec 2021 20:29:01 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="281e34967abc652e32513cf7d24af717";
logging-data="14190"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+RBzv28xgfEFDxKwE5B8nr"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:HMuGY7gyY7S2UXOddQEhY+5mcRk=
In-Reply-To: <qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 30 Dec 2021 20:29 UTC

On 2021-12-30 12:33, olcott wrote:
> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>> On 2021-12-30 09:54, olcott wrote:
>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>
>>>>>> We don't care if embedded_H is 'Correct', we care that it give the
>>>>>> same answer as H.
>>>>>>
>>>>>
>>>>> If it is correct and gives a different answer than H then it
>>>>> remains correct even if it gives a different answer than H.
>>>>>
>>>>
>>>> But since it IS a copy of H, then if it gives a different answer
>>>> than 'H' does, it shows that H fails to be a Computation, and thus
>>>> Can't be a Decider, and thus can't be a Halt Decider.
>>> H and embedded_H are able to give a different halt status
>>> determinations on the basis that embedded_H had its copy of H
>>> corrupted by the appended infinite loop.
>>>
>>> This means that a finite string comparison performed by H will
>>> determine that embedded_H is not identical to H.
>>
>> And which two strings are being compared here? H hasn't been provided
>> a string describing itself nor a string describing embedded_H as part
>> of its input. All it has is a string describing Ĥ. What does it
>> compare this string to?
>>
>> André
>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> We as humans can see that while embedded_H performs a pure simulation of
> its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>
> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this input
> over and over without ever stopping.
>
> Since a pure simulation of the input never stops we know that the UTM
> simulation of this same input never stops because a UTM performs a pure
> simulation of its input.
>
> Thus we know that the "does not halt" halt status criteria of embedded_H
> has been met.
>
> In order for embedded_H to see this it needs to see that an identical
> sequence of configurations keeps repeating.
>
> We as humans can see that the input to embedded_H is always identical.
> We as humans can see that the copy of embedded_H is always identical.
> We as humans can see that these two things can verified by finite string
> comparison.

You didn't actually answer my question. Which two strings are being
compared? Ĥ has access to exactly one string, the string representing
its input. What is this being compared to?

What we as humans can or cannot do has very little bearing on what a
Turing Machine can do.

André

> That an identical copy of a function is called with identical inputs
> proves infinite behavior.

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 14:51:29 -0600
Date: Thu, 30 Dec 2021 14:51:25 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sql4qd$dre$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com>
Lines: 95
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-QNQ+ikfg/tnHewE9Iwwl7jGw5hdALalx6pwRYy7X0+MZLSFQrnCtjt/UyPjgxcp6iD2uSWhxGwjLJDg!abRqXah/GHcvodxj188FsCWXWKOljAX78g/VQrj9WzWwKeCW/Pu2lVF0hc9fUiZ55c5z7/rsMGKN!hg==
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: 5343
 by: olcott - Thu, 30 Dec 2021 20:51 UTC

On 12/30/2021 2:29 PM, André G. Isaak wrote:
> On 2021-12-30 12:33, olcott wrote:
>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>> On 2021-12-30 09:54, olcott wrote:
>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>
>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>> the same answer as H.
>>>>>>>
>>>>>>
>>>>>> If it is correct and gives a different answer than H then it
>>>>>> remains correct even if it gives a different answer than H.
>>>>>>
>>>>>
>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>> than 'H' does, it shows that H fails to be a Computation, and thus
>>>>> Can't be a Decider, and thus can't be a Halt Decider.
>>>> H and embedded_H are able to give a different halt status
>>>> determinations on the basis that embedded_H had its copy of H
>>>> corrupted by the appended infinite loop.
>>>>
>>>> This means that a finite string comparison performed by H will
>>>> determine that embedded_H is not identical to H.
>>>
>>> And which two strings are being compared here? H hasn't been provided
>>> a string describing itself nor a string describing embedded_H as part
>>> of its input. All it has is a string describing Ĥ. What does it
>>> compare this string to?
>>>
>>> André
>>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> We as humans can see that while embedded_H performs a pure simulation
>> of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>
>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>> input over and over without ever stopping.
>>
>> Since a pure simulation of the input never stops we know that the UTM
>> simulation of this same input never stops because a UTM performs a
>> pure simulation of its input.
>>
>> Thus we know that the "does not halt" halt status criteria of
>> embedded_H has been met.
>>
>> In order for embedded_H to see this it needs to see that an identical
>> sequence of configurations keeps repeating.
>>
>> We as humans can see that the input to embedded_H is always identical.
>> We as humans can see that the copy of embedded_H is always identical.
>> We as humans can see that these two things can verified by finite
>> string comparison.
>
> You didn't actually answer my question. Which two strings are being
> compared? Ĥ has access to exactly one string, the string representing
> its input. What is this being compared to?
>
> What we as humans can or cannot do has very little bearing on what a
> Turing Machine can do.
>

Understanding what humans can do is a necessary prerequisite to
understanding which strings are compared and why.

Ultimately embedded_H sees a repeating sequence of configurations.
Humans can most easily understand this in terms an identical function
being called with identical arguments, thus three finite strings that
must be compared.

All of these tedious details are mostly moot once it is understood that
embedded_H has met its criterion measure to transition to Ĥ.qn on the
basis of the UTM simulation of its input.

> André
>
>> That an identical copy of a function is called with identical inputs
>> proves infinite behavior.
>
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<sql6he$khm$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Date: Thu, 30 Dec 2021 13:58:22 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 84
Message-ID: <sql6he$khm$1@dont-email.me>
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 30 Dec 2021 20:58:23 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="281e34967abc652e32513cf7d24af717";
logging-data="21046"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19Mk1AYRWmyopmEdNZYloUL"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:EhcVXW1jfR+HGe2/hQx27OhSTGM=
In-Reply-To: <W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 30 Dec 2021 20:58 UTC

On 2021-12-30 13:51, olcott wrote:
> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>> On 2021-12-30 12:33, olcott wrote:
>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>> On 2021-12-30 09:54, olcott wrote:
>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>
>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>> the same answer as H.
>>>>>>>>
>>>>>>>
>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>
>>>>>>
>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>> than 'H' does, it shows that H fails to be a Computation, and thus
>>>>>> Can't be a Decider, and thus can't be a Halt Decider.
>>>>> H and embedded_H are able to give a different halt status
>>>>> determinations on the basis that embedded_H had its copy of H
>>>>> corrupted by the appended infinite loop.
>>>>>
>>>>> This means that a finite string comparison performed by H will
>>>>> determine that embedded_H is not identical to H.
>>>>
>>>> And which two strings are being compared here? H hasn't been
>>>> provided a string describing itself nor a string describing
>>>> embedded_H as part of its input. All it has is a string describing
>>>> Ĥ. What does it compare this string to?
>>>>
>>>> André
>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> We as humans can see that while embedded_H performs a pure simulation
>>> of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>
>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>> input over and over without ever stopping.
>>>
>>> Since a pure simulation of the input never stops we know that the UTM
>>> simulation of this same input never stops because a UTM performs a
>>> pure simulation of its input.
>>>
>>> Thus we know that the "does not halt" halt status criteria of
>>> embedded_H has been met.
>>>
>>> In order for embedded_H to see this it needs to see that an identical
>>> sequence of configurations keeps repeating.
>>>
>>> We as humans can see that the input to embedded_H is always identical.
>>> We as humans can see that the copy of embedded_H is always identical.
>>> We as humans can see that these two things can verified by finite
>>> string comparison.
>>
>> You didn't actually answer my question. Which two strings are being
>> compared? Ĥ has access to exactly one string, the string representing
>> its input. What is this being compared to?
>>
>> What we as humans can or cannot do has very little bearing on what a
>> Turing Machine can do.
>>
>
> Understanding what humans can do is a necessary prerequisite to
> understanding which strings are compared and why.
>
> Ultimately embedded_H sees a repeating sequence of configurations.
> Humans can most easily understand this in terms an identical function
> being called with identical arguments, thus three finite strings that
> must be compared.

Again, you failed to answer the question.

Which three strings are being compared?

André

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<35pzJ.878$jW.736@fx05.iad>

 copy mid

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

 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!peer02.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.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 101
Message-ID: <35pzJ.878$jW.736@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: Thu, 30 Dec 2021 15:59:44 -0500
X-Received-Bytes: 5456
 by: Richard Damon - Thu, 30 Dec 2021 20:59 UTC

On 12/30/21 3:51 PM, olcott wrote:
> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>> On 2021-12-30 12:33, olcott wrote:
>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>> On 2021-12-30 09:54, olcott wrote:
>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>
>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>> the same answer as H.
>>>>>>>>
>>>>>>>
>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>
>>>>>>
>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>> than 'H' does, it shows that H fails to be a Computation, and thus
>>>>>> Can't be a Decider, and thus can't be a Halt Decider.
>>>>> H and embedded_H are able to give a different halt status
>>>>> determinations on the basis that embedded_H had its copy of H
>>>>> corrupted by the appended infinite loop.
>>>>>
>>>>> This means that a finite string comparison performed by H will
>>>>> determine that embedded_H is not identical to H.
>>>>
>>>> And which two strings are being compared here? H hasn't been
>>>> provided a string describing itself nor a string describing
>>>> embedded_H as part of its input. All it has is a string describing
>>>> Ĥ. What does it compare this string to?
>>>>
>>>> André
>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> We as humans can see that while embedded_H performs a pure simulation
>>> of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>
>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>> input over and over without ever stopping.
>>>
>>> Since a pure simulation of the input never stops we know that the UTM
>>> simulation of this same input never stops because a UTM performs a
>>> pure simulation of its input.
>>>
>>> Thus we know that the "does not halt" halt status criteria of
>>> embedded_H has been met.
>>>
>>> In order for embedded_H to see this it needs to see that an identical
>>> sequence of configurations keeps repeating.
>>>
>>> We as humans can see that the input to embedded_H is always identical.
>>> We as humans can see that the copy of embedded_H is always identical.
>>> We as humans can see that these two things can verified by finite
>>> string comparison.
>>
>> You didn't actually answer my question. Which two strings are being
>> compared? Ĥ has access to exactly one string, the string representing
>> its input. What is this being compared to?
>>
>> What we as humans can or cannot do has very little bearing on what a
>> Turing Machine can do.
>>
>
> Understanding what humans can do is a necessary prerequisite to
> understanding which strings are compared and why.
>
> Ultimately embedded_H sees a repeating sequence of configurations.
> Humans can most easily understand this in terms an identical function
> being called with identical arguments, thus three finite strings that
> must be compared.

Except it ISN'T a sequence of function calls, as H DOES NOT CALL ITS
INPUT. Since H is just partially simulating its input with an abort
condition, this pattern is NOT an infinite recursion sequence, unless H
fails to abort, at which point it fails to give an answer, and just fails.

>
> All of these tedious details are mostly moot once it is understood that
> embedded_H has met its criterion measure to transition to Ĥ.qn on the
> basis of the UTM simulation of its input.
>

Except it didn't. FAIL.

>
>
>> André
>>
>>> That an identical copy of a function is called with identical inputs
>>> proves infinite behavior.
>>
>>
>>
>
>

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 15:15:31 -0600
Date: Thu, 30 Dec 2021 15:15:29 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sql6he$khm$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com>
Lines: 103
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kOJbM9B+BjV09ysN8Yk6CpqvrFKoEQGgnSBhkS/jxYxSQ4e1/D6p8Fm7eRnpJ8KPFNeu2ggvepkrJak!qcMD8PfXtBkgCoVerK+115LY4aa+Nh7Ef6+OdWot2iBByg4hdRUwXpELHeec8DqsTvEKGFyAoBwF!6A==
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: 6003
 by: olcott - Thu, 30 Dec 2021 21:15 UTC

On 12/30/2021 2:58 PM, André G. Isaak wrote:
> On 2021-12-30 13:51, olcott wrote:
>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>> On 2021-12-30 12:33, olcott wrote:
>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>>> the same answer as H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>
>>>>>>>
>>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>>> than 'H' does, it shows that H fails to be a Computation, and
>>>>>>> thus Can't be a Decider, and thus can't be a Halt Decider.
>>>>>> H and embedded_H are able to give a different halt status
>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>> corrupted by the appended infinite loop.
>>>>>>
>>>>>> This means that a finite string comparison performed by H will
>>>>>> determine that embedded_H is not identical to H.
>>>>>
>>>>> And which two strings are being compared here? H hasn't been
>>>>> provided a string describing itself nor a string describing
>>>>> embedded_H as part of its input. All it has is a string describing
>>>>> Ĥ. What does it compare this string to?
>>>>>
>>>>> André
>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> We as humans can see that while embedded_H performs a pure
>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>
>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>> input over and over without ever stopping.
>>>>
>>>> Since a pure simulation of the input never stops we know that the
>>>> UTM simulation of this same input never stops because a UTM performs
>>>> a pure simulation of its input.
>>>>
>>>> Thus we know that the "does not halt" halt status criteria of
>>>> embedded_H has been met.
>>>>
>>>> In order for embedded_H to see this it needs to see that an
>>>> identical sequence of configurations keeps repeating.
>>>>
>>>> We as humans can see that the input to embedded_H is always identical.
>>>> We as humans can see that the copy of embedded_H is always identical.
>>>> We as humans can see that these two things can verified by finite
>>>> string comparison.
>>>
>>> You didn't actually answer my question. Which two strings are being
>>> compared? Ĥ has access to exactly one string, the string representing
>>> its input. What is this being compared to?
>>>
>>> What we as humans can or cannot do has very little bearing on what a
>>> Turing Machine can do.
>>>
>>
>> Understanding what humans can do is a necessary prerequisite to
>> understanding which strings are compared and why.
>>
>> Ultimately embedded_H sees a repeating sequence of configurations.
>> Humans can most easily understand this in terms an identical function
>> being called with identical arguments, thus three finite strings that
>> must be compared.
>
> Again, you failed to answer the question.
>
> Which three strings are being compared?
>
> André
>

The answer is self-evident in order to verify that the same function is
being called with the same inputs embedded_H and its input pair must be
compared to the prior copy of these same three finite strings.

It does not matter if this is not the actual comparison that must
actually be done any equivalent comparison will do.

We can't keep jumping around to different points and ever have closure
before my cancer kills me.

We must stay focused on the point that embedded_H does have its correct
criterion measure to transition 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: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<8kpzJ.114415$OB3.103543@fx06.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <sql6he$khm$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 99
Message-ID: <8kpzJ.114415$OB3.103543@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: Thu, 30 Dec 2021 16:15:49 -0500
X-Received-Bytes: 5982
 by: Richard Damon - Thu, 30 Dec 2021 21:15 UTC

On 12/30/21 3:58 PM, André G. Isaak wrote:
> On 2021-12-30 13:51, olcott wrote:
>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>> On 2021-12-30 12:33, olcott wrote:
>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>>> the same answer as H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>
>>>>>>>
>>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>>> than 'H' does, it shows that H fails to be a Computation, and
>>>>>>> thus Can't be a Decider, and thus can't be a Halt Decider.
>>>>>> H and embedded_H are able to give a different halt status
>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>> corrupted by the appended infinite loop.
>>>>>>
>>>>>> This means that a finite string comparison performed by H will
>>>>>> determine that embedded_H is not identical to H.
>>>>>
>>>>> And which two strings are being compared here? H hasn't been
>>>>> provided a string describing itself nor a string describing
>>>>> embedded_H as part of its input. All it has is a string describing
>>>>> Ĥ. What does it compare this string to?
>>>>>
>>>>> André
>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> We as humans can see that while embedded_H performs a pure
>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>
>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>> input over and over without ever stopping.
>>>>
>>>> Since a pure simulation of the input never stops we know that the
>>>> UTM simulation of this same input never stops because a UTM performs
>>>> a pure simulation of its input.
>>>>
>>>> Thus we know that the "does not halt" halt status criteria of
>>>> embedded_H has been met.
>>>>
>>>> In order for embedded_H to see this it needs to see that an
>>>> identical sequence of configurations keeps repeating.
>>>>
>>>> We as humans can see that the input to embedded_H is always identical.
>>>> We as humans can see that the copy of embedded_H is always identical.
>>>> We as humans can see that these two things can verified by finite
>>>> string comparison.
>>>
>>> You didn't actually answer my question. Which two strings are being
>>> compared? Ĥ has access to exactly one string, the string representing
>>> its input. What is this being compared to?
>>>
>>> What we as humans can or cannot do has very little bearing on what a
>>> Turing Machine can do.
>>>
>>
>> Understanding what humans can do is a necessary prerequisite to
>> understanding which strings are compared and why.
>>
>> Ultimately embedded_H sees a repeating sequence of configurations.
>> Humans can most easily understand this in terms an identical function
>> being called with identical arguments, thus three finite strings that
>> must be compared.
>
> Again, you failed to answer the question.
>
> Which three strings are being compared?
>
> André
>

I think you don't understand that PO doesn't seem to be worried that it
is impossible to actually implement his 'program' just describe it in
vague enough terms to make someone who doesn't understand the field
either to think he has made a point. Which is enough to convince himself.

The probem he will run into is when he goes to submit the paper, if he
ever does, the reviews WILL understand the theory, and his arguments
will be not convincing at all.

I sometimes wonder if he is arguing here just as his excuse to NOT
submit the paper and get it rejected. In his mind he can dismiss us as
just 'random people who don't really know anything', but he needs to
acknowledge that the Journal reviews will be knowledgeable in the field,
so he can't just use the adhoninem rebuttals against them. This lets him
keep holding onto his (false) beliefs in his own mind, and not need to
challenge his long term idea of how things work.

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<NvpzJ.143667$Ql5.57426@fx39.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.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.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 124
Message-ID: <NvpzJ.143667$Ql5.57426@fx39.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: Thu, 30 Dec 2021 16:28:13 -0500
X-Received-Bytes: 6636
X-Original-Bytes: 6503
 by: Richard Damon - Thu, 30 Dec 2021 21:28 UTC

On 12/30/21 4:15 PM, olcott wrote:
> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>> On 2021-12-30 13:51, olcott wrote:
>>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>>> On 2021-12-30 12:33, olcott wrote:
>>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>>>> the same answer as H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>>>> than 'H' does, it shows that H fails to be a Computation, and
>>>>>>>> thus Can't be a Decider, and thus can't be a Halt Decider.
>>>>>>> H and embedded_H are able to give a different halt status
>>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>>> corrupted by the appended infinite loop.
>>>>>>>
>>>>>>> This means that a finite string comparison performed by H will
>>>>>>> determine that embedded_H is not identical to H.
>>>>>>
>>>>>> And which two strings are being compared here? H hasn't been
>>>>>> provided a string describing itself nor a string describing
>>>>>> embedded_H as part of its input. All it has is a string describing
>>>>>> Ĥ. What does it compare this string to?
>>>>>>
>>>>>> André
>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> We as humans can see that while embedded_H performs a pure
>>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>>
>>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>>> input over and over without ever stopping.
>>>>>
>>>>> Since a pure simulation of the input never stops we know that the
>>>>> UTM simulation of this same input never stops because a UTM
>>>>> performs a pure simulation of its input.
>>>>>
>>>>> Thus we know that the "does not halt" halt status criteria of
>>>>> embedded_H has been met.
>>>>>
>>>>> In order for embedded_H to see this it needs to see that an
>>>>> identical sequence of configurations keeps repeating.
>>>>>
>>>>> We as humans can see that the input to embedded_H is always identical.
>>>>> We as humans can see that the copy of embedded_H is always identical.
>>>>> We as humans can see that these two things can verified by finite
>>>>> string comparison.
>>>>
>>>> You didn't actually answer my question. Which two strings are being
>>>> compared? Ĥ has access to exactly one string, the string
>>>> representing its input. What is this being compared to?
>>>>
>>>> What we as humans can or cannot do has very little bearing on what a
>>>> Turing Machine can do.
>>>>
>>>
>>> Understanding what humans can do is a necessary prerequisite to
>>> understanding which strings are compared and why.
>>>
>>> Ultimately embedded_H sees a repeating sequence of configurations.
>>> Humans can most easily understand this in terms an identical function
>>> being called with identical arguments, thus three finite strings that
>>> must be compared.
>>
>> Again, you failed to answer the question.
>>
>> Which three strings are being compared?
>>
>> André
>>
>
> The answer is self-evident in order to verify that the same function is
> being called with the same inputs embedded_H and its input pair must be
> compared to the prior copy of these same three finite strings.
>

But where does H get these string?

> It does not matter if this is not the actual comparison that must
> actually be done any equivalent comparison will do.
>
> We can't keep jumping around to different points and ever have closure
> before my cancer kills me.
>
> We must stay focused on the point that embedded_H does have its correct
> criterion measure to transition to Ĥ.qn.
>
>

Except that it doesn't, since it is shown that if H (or embedded_H)
applies to <H^<H^> returns to H.qn, and answers non-halting, that H^
also goes to H^.qn and HALTS, so that answer is wrong.

All you are showing is that U^(<U^>) (where U is the UTM, and U^ is a
version of H^ built on that UTM) is non-halting.

Since H isn't U, then this answer doesn't really matter, what matter is
what the REAL H^ does.

By definition UTM(<H^>,<H^>), the criteria that H needs to match, will
be the same as H^(<H^>) which is halting if H^ goes to H^.qn and
Non-Halting of H^ goes to H^.qy

This means that either answer that H gives will be wrong, so any
algorithm that refuses to be wrong will just not halt and give an answer.

Which is what you seem to be detecting in your argument, except you then
assume that it does halt and give the wrong answer.

FAIL

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<mrqdnfKwCfiL7FP8nZ2dnUU7-cPNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 30 Dec 2021 20:55:18 -0600
Date: Thu, 30 Dec 2021 20:55:16 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sql6he$khm$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <mrqdnfKwCfiL7FP8nZ2dnUU7-cPNnZ2d@giganews.com>
Lines: 93
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-G7u+xpTUQb6mqyuu+nskSfoC0GrpI+zTKnaEXsa0Gvl9ix/iLAw3EyUrXSCt1RXALtNsmq4IF+iDkOo!1RRhyJ+rUrVGzdHPD3d1Ak/v643KZZ+M+hCpYtIOoKpfpzZs1tcnlW+LcTJ1wQmeJAsPdREEXIr9!2g==
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: 5665
 by: olcott - Fri, 31 Dec 2021 02:55 UTC

On 12/30/2021 2:58 PM, André G. Isaak wrote:
> On 2021-12-30 13:51, olcott wrote:
>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>> On 2021-12-30 12:33, olcott wrote:
>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>>> the same answer as H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>
>>>>>>>
>>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>>> than 'H' does, it shows that H fails to be a Computation, and
>>>>>>> thus Can't be a Decider, and thus can't be a Halt Decider.
>>>>>> H and embedded_H are able to give a different halt status
>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>> corrupted by the appended infinite loop.
>>>>>>
>>>>>> This means that a finite string comparison performed by H will
>>>>>> determine that embedded_H is not identical to H.
>>>>>
>>>>> And which two strings are being compared here? H hasn't been
>>>>> provided a string describing itself nor a string describing
>>>>> embedded_H as part of its input. All it has is a string describing
>>>>> Ĥ. What does it compare this string to?
>>>>>
>>>>> André
>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> We as humans can see that while embedded_H performs a pure
>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>
>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>> input over and over without ever stopping.
>>>>
>>>> Since a pure simulation of the input never stops we know that the
>>>> UTM simulation of this same input never stops because a UTM performs
>>>> a pure simulation of its input.
>>>>
>>>> Thus we know that the "does not halt" halt status criteria of
>>>> embedded_H has been met.
>>>>
>>>> In order for embedded_H to see this it needs to see that an
>>>> identical sequence of configurations keeps repeating.
>>>>
>>>> We as humans can see that the input to embedded_H is always identical.
>>>> We as humans can see that the copy of embedded_H is always identical.
>>>> We as humans can see that these two things can verified by finite
>>>> string comparison.
>>>
>>> You didn't actually answer my question. Which two strings are being
>>> compared? Ĥ has access to exactly one string, the string representing
>>> its input. What is this being compared to?
>>>
>>> What we as humans can or cannot do has very little bearing on what a
>>> Turing Machine can do.
>>>
>>
>> Understanding what humans can do is a necessary prerequisite to
>> understanding which strings are compared and why.
>>
>> Ultimately embedded_H sees a repeating sequence of configurations.
>> Humans can most easily understand this in terms an identical function
>> being called with identical arguments, thus three finite strings that
>> must be compared.
>
> Again, you failed to answer the question.
>
> Which three strings are being compared?
>
> André
>

The corrupted copy of H at Ĥ.qx (AKA embedded_H) and its two inputs are
three finite strings that infinitely repeat when embedded_H bases its
halt status decision on the behavior of the pure simulation of its input.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<KmuzJ.249740$IW4.164803@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx48.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.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<mrqdnfKwCfiL7FP8nZ2dnUU7-cPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <mrqdnfKwCfiL7FP8nZ2dnUU7-cPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 97
Message-ID: <KmuzJ.249740$IW4.164803@fx48.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: Thu, 30 Dec 2021 21:59:55 -0500
X-Received-Bytes: 5630
 by: Richard Damon - Fri, 31 Dec 2021 02:59 UTC

On 12/30/21 9:55 PM, olcott wrote:
> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>> On 2021-12-30 13:51, olcott wrote:
>>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>>> On 2021-12-30 12:33, olcott wrote:
>>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it give
>>>>>>>>>> the same answer as H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But since it IS a copy of H, then if it gives a different answer
>>>>>>>> than 'H' does, it shows that H fails to be a Computation, and
>>>>>>>> thus Can't be a Decider, and thus can't be a Halt Decider.
>>>>>>> H and embedded_H are able to give a different halt status
>>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>>> corrupted by the appended infinite loop.
>>>>>>>
>>>>>>> This means that a finite string comparison performed by H will
>>>>>>> determine that embedded_H is not identical to H.
>>>>>>
>>>>>> And which two strings are being compared here? H hasn't been
>>>>>> provided a string describing itself nor a string describing
>>>>>> embedded_H as part of its input. All it has is a string describing
>>>>>> Ĥ. What does it compare this string to?
>>>>>>
>>>>>> André
>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> We as humans can see that while embedded_H performs a pure
>>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>>
>>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>>> input over and over without ever stopping.
>>>>>
>>>>> Since a pure simulation of the input never stops we know that the
>>>>> UTM simulation of this same input never stops because a UTM
>>>>> performs a pure simulation of its input.
>>>>>
>>>>> Thus we know that the "does not halt" halt status criteria of
>>>>> embedded_H has been met.
>>>>>
>>>>> In order for embedded_H to see this it needs to see that an
>>>>> identical sequence of configurations keeps repeating.
>>>>>
>>>>> We as humans can see that the input to embedded_H is always identical.
>>>>> We as humans can see that the copy of embedded_H is always identical.
>>>>> We as humans can see that these two things can verified by finite
>>>>> string comparison.
>>>>
>>>> You didn't actually answer my question. Which two strings are being
>>>> compared? Ĥ has access to exactly one string, the string
>>>> representing its input. What is this being compared to?
>>>>
>>>> What we as humans can or cannot do has very little bearing on what a
>>>> Turing Machine can do.
>>>>
>>>
>>> Understanding what humans can do is a necessary prerequisite to
>>> understanding which strings are compared and why.
>>>
>>> Ultimately embedded_H sees a repeating sequence of configurations.
>>> Humans can most easily understand this in terms an identical function
>>> being called with identical arguments, thus three finite strings that
>>> must be compared.
>>
>> Again, you failed to answer the question.
>>
>> Which three strings are being compared?
>>
>> André
>>
>
> The corrupted copy of H at Ĥ.qx (AKA embedded_H) and its two inputs are
> three finite strings that infinitely repeat when embedded_H bases its
> halt status decision on the behavior of the pure simulation of its input.
>

Wrong.

See:
Mesage ID <FOnzJ.162569$np6.119786@fx46.iad>
Date: 2021-12-30 19:31:49 GMT
Subject: Re: Concise refutation of halting problem proofs V42 [compute
the mapping]

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<NpWdnQ8kO4hw6FP8nZ2dnUU7-SfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 21:15:57 -0600
Date: Thu, 30 Dec 2021 21:15:55 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<mrqdnfKwCfiL7FP8nZ2dnUU7-cPNnZ2d@giganews.com>
<KmuzJ.249740$IW4.164803@fx48.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <KmuzJ.249740$IW4.164803@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <NpWdnQ8kO4hw6FP8nZ2dnUU7-SfNnZ2d@giganews.com>
Lines: 113
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FQBc2jNL7/L4GegALO8aX82KwyY1fEcy8gCU2VLMSBCwj8d/0s9u1il6dscDaxwNUOCRTPw+fOZrrdC!71p2lZxUHIgrj8rkOMYOksZGKX6ew0rozrbWXxmkrsuKpdYfCk/CsyKVXst07zLhZ3WhjvwVmhBn!Ug==
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: 6335
 by: olcott - Fri, 31 Dec 2021 03:15 UTC

On 12/30/2021 8:59 PM, Richard Damon wrote:
> On 12/30/21 9:55 PM, olcott wrote:
>> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>>> On 2021-12-30 13:51, olcott wrote:
>>>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>>>> On 2021-12-30 12:33, olcott wrote:
>>>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it
>>>>>>>>>>> give the same answer as H.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But since it IS a copy of H, then if it gives a different
>>>>>>>>> answer than 'H' does, it shows that H fails to be a
>>>>>>>>> Computation, and thus Can't be a Decider, and thus can't be a
>>>>>>>>> Halt Decider.
>>>>>>>> H and embedded_H are able to give a different halt status
>>>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>>>> corrupted by the appended infinite loop.
>>>>>>>>
>>>>>>>> This means that a finite string comparison performed by H will
>>>>>>>> determine that embedded_H is not identical to H.
>>>>>>>
>>>>>>> And which two strings are being compared here? H hasn't been
>>>>>>> provided a string describing itself nor a string describing
>>>>>>> embedded_H as part of its input. All it has is a string
>>>>>>> describing Ĥ. What does it compare this string to?
>>>>>>>
>>>>>>> André
>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> We as humans can see that while embedded_H performs a pure
>>>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>>>
>>>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>>>> input over and over without ever stopping.
>>>>>>
>>>>>> Since a pure simulation of the input never stops we know that the
>>>>>> UTM simulation of this same input never stops because a UTM
>>>>>> performs a pure simulation of its input.
>>>>>>
>>>>>> Thus we know that the "does not halt" halt status criteria of
>>>>>> embedded_H has been met.
>>>>>>
>>>>>> In order for embedded_H to see this it needs to see that an
>>>>>> identical sequence of configurations keeps repeating.
>>>>>>
>>>>>> We as humans can see that the input to embedded_H is always
>>>>>> identical.
>>>>>> We as humans can see that the copy of embedded_H is always identical.
>>>>>> We as humans can see that these two things can verified by finite
>>>>>> string comparison.
>>>>>
>>>>> You didn't actually answer my question. Which two strings are being
>>>>> compared? Ĥ has access to exactly one string, the string
>>>>> representing its input. What is this being compared to?
>>>>>
>>>>> What we as humans can or cannot do has very little bearing on what
>>>>> a Turing Machine can do.
>>>>>
>>>>
>>>> Understanding what humans can do is a necessary prerequisite to
>>>> understanding which strings are compared and why.
>>>>
>>>> Ultimately embedded_H sees a repeating sequence of configurations.
>>>> Humans can most easily understand this in terms an identical
>>>> function being called with identical arguments, thus three finite
>>>> strings that must be compared.
>>>
>>> Again, you failed to answer the question.
>>>
>>> Which three strings are being compared?
>>>
>>> André
>>>
>>
>> The corrupted copy of H at Ĥ.qx (AKA embedded_H) and its two inputs
>> are three finite strings that infinitely repeat when embedded_H bases
>> its halt status decision on the behavior of the pure simulation of its
>> input.
>>
>
> Wrong.
>

It is a correct conceptual design even if it must be implemented
differently.

> See:
> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
> Date: 2021-12-30 19:31:49 GMT
> Subject: Re: Concise refutation of halting problem proofs V42 [compute
> the mapping]
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [compute the mapping]

<YZOdnYrgZ_gz4FP8nZ2dnUU7-efNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 21:49:02 -0600
Date: Thu, 30 Dec 2021 21:48:59 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
<8GkzJ.67666$cW6.42695@fx08.iad>
<Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
<J7lzJ.133156$7D4.56836@fx37.iad>
<C-CdnTqrLLFIeVD8nZ2dnUU7-RWdnZ2d@giganews.com>
<uWlzJ.235028$aF1.204961@fx98.iad>
<X8qdnaH5EPMZaVD8nZ2dnUU7-LXNnZ2d@giganews.com>
<FOnzJ.162569$np6.119786@fx46.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <FOnzJ.162569$np6.119786@fx46.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <YZOdnYrgZ_gz4FP8nZ2dnUU7-efNnZ2d@giganews.com>
Lines: 162
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-X04DlDUP1bzdrqdyaQB98ngMf99AG1VoSunEmvAgJ1i2TJgHBXWfgsEPTANPSv9xVYyuuwO1Bgx5Dgw!IhLIhtK6LTITjbP+VvJLoeivnODaalLBlDQYMB0gcR5NvuqDzsLQYmGLcV3+n1iD0b+mRFEL8aec!yA==
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: 8269
 by: olcott - Fri, 31 Dec 2021 03:48 UTC

On 12/30/2021 1:31 PM, Richard Damon wrote:
> On 12/30/21 1:03 PM, olcott wrote:
>> On 12/30/2021 11:23 AM, Richard Damon wrote:
>>> On 12/30/21 11:56 AM, olcott wrote:
>>>> On 12/30/2021 10:29 AM, Richard Damon wrote:
>>>>> On 12/30/21 11:11 AM, olcott wrote:
>>>>>> On 12/30/2021 9:57 AM, Richard Damon wrote:
>>>>>>> On 12/30/21 10:20 AM, olcott wrote:
>>>>>>>> On 12/30/2021 8:19 AM, Richard Damon wrote:
>>>>>>>>> On 12/29/21 11:51 PM, olcott wrote:
>>>>>>>>>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/29/21 11:02 PM, olcott wrote:
>>>>>>>>>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> It's not your criterion, it's mine.  It's also Linz's.  If
>>>>>>>>>>>>> yours is not
>>>>>>>>>>>>> the same as his (and mine), it should be different in some
>>>>>>>>>>>>> way. (And we
>>>>>>>>>>>>> can safely ignore it, since no one cares about your
>>>>>>>>>>>>> alternative
>>>>>>>>>>>>> criteria.)
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It has always been my criterion measure that halt deciders
>>>>>>>>>>>> base their halt status decision on the pure simulation of
>>>>>>>>>>>> their inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> That your notational conventions very cleanly express this
>>>>>>>>>>>> idea as applied to the Linz H is a good breakthrough.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> As soon as people understand that this same criterion
>>>>>>>>>>>> measure applies recursively to every embedded_H at Ĥ.qx,
>>>>>>>>>>>> then they will see how this criterion measure provides the
>>>>>>>>>>>> means for embedded_H to correctly compute the mapping from
>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yes each level can use the test to determine if the halt
>>>>>>>>>>> decider at that level got the right answer or not.
>>>>>>>>>>>
>>>>>>>>>>> The issue is that when we are doing this check, you check
>>>>>>>>>>> JUST that level, and not lower levels.
>>>>>>>>>>
>>>>>>>>>> No you are wrong.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Source? (Some REAL reference)
>>>>>>>>>
>>>>>>>>
>>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>>
>>>>>>>> The source is the correct reasoning of how the above criterion
>>>>>>>> measure would be applied when H is copied to Ĥ.qx.
>>>>>>>
>>>>>>> We copy the ALGORITHM of H, the detailed step by step instructions
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> You keep thinking that a subsequent level UTM magically turns
>>>>>>>> into embedded_H and aborts its simulation.
>>>>>>>
>>>>>>> There IS no UTM in the machine. PERIOD. (unless H IS a UTM)
>>>>>>>
>>>>>> H always bases its halt status decision on the behavior of the UTM
>>>>>> simulation of its input. Thus embedded_H bases its halt status
>>>>>> decision on the behavior of the UTM simulation of its input. This
>>>>>> means that H and embedded_H continue a pure simulation of N steps
>>>>>> of their input until their input halts on its own or this input
>>>>>> demonstrates an infinite behavior pattern.
>>>>>
>>>>> And that means that H must NEVER halt its simulation of H^, and thus
>>>>
>>>> The reason why I ignore most of your posts is that I stop at the
>>>> very first very stupid mistake.
>>>>
>>>
>>> You mean you stop at the first thing you can't answer.
>>>
>>
>> It is very stupid to say that
>> "H must NEVER halt its simulation of H^"
>>
>> When I just said exactly how and when H does correctly halt its
>> simulation of Ĥ:
>>
>>  >>>> H and embedded_H continue a pure simulation of N steps of
>>  >>>> their input until their input halts on its own or this input
>>  >>>> demonstrates an infinite behavior pattern.
>>
>> In the future I will simply ignore these stupid mistakes so that other
>> respondents only need to pay attention to my responses and can equally
>> ignore the clutter of your stupid mistakes.
>>
>
> But there IS no finite pattern that demonstrates an infitite behavior
> pattern.
>

This is a finite pattern that demonstrates an infinite behavior pattern.

void Infinite_Loop(int N)
{ HERE: goto HERE;
}

_Infinite_Loop()
[00000cb5](01) 55 push ebp
[00000cb6](02) 8bec mov ebp,esp
[00000cb8](02) ebfe jmp 00000cb8
[00000cba](01) 5d pop ebp
[00000cbb](01) c3 ret
Size in bytes:(0007) [00000cbb]

> FAIR WARNING. I reserve the right to just mention this proof every time
> you repeat that claim without actually showing a problem with it.
>
> If their IS a pattern that H thinks demonstrates an infinite behavior
> pattern, and when it sees this it aborts its simulation and returns the
> Non-Halting answer, then when we run an actual computation of H^ <H^>
> then we will see that
>
> H^ <H^> goes to H^.qx <H^> <H^> which is a copy of H.q0 <H^> <H^> which
> will then run for some time until it sees the pattern that it thinks
> demonstrates an infinite behavior pattern, and goes to H.qn which means
> H^ goes to H^.qn which Halts.
>
> This thus shows that H^ <H^> which is the equiavlent to UTM(<H^>,<H^>)
> halts, and thus the pattern that H thought was proof of non-halting can
> actually lead to a Halting behavior, so H was INCORRECT that this
> pattern was actually proof of infinite behavior.
>
>
> This means that you H, using that definition either fails to return an
> answer at all, and thus fails to be a decider, or it fails to follow its
> algorithm that your just defined.
>
> FAIL.
>
> You ar just assuming the existance of a finite set of patterns that
> detect non-halting behavior. In other words, your 'proof' that the
> problem is solvable requires as an assumption, that the problem is
> solvable. This leads to a contradiction, showing that assumption to be
> false.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<4UvzJ.170435$SW5.117753@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!news.neodome.net!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<mrqdnfKwCfiL7FP8nZ2dnUU7-cPNnZ2d@giganews.com>
<KmuzJ.249740$IW4.164803@fx48.iad>
<NpWdnQ8kO4hw6FP8nZ2dnUU7-SfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <NpWdnQ8kO4hw6FP8nZ2dnUU7-SfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 129
Message-ID: <4UvzJ.170435$SW5.117753@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 23:43:45 -0500
X-Received-Bytes: 6652
 by: Richard Damon - Fri, 31 Dec 2021 04:43 UTC

On 12/30/21 10:15 PM, olcott wrote:
> On 12/30/2021 8:59 PM, Richard Damon wrote:
>> On 12/30/21 9:55 PM, olcott wrote:
>>> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>>>> On 2021-12-30 13:51, olcott wrote:
>>>>> On 12/30/2021 2:29 PM, André G. Isaak wrote:
>>>>>> On 2021-12-30 12:33, olcott wrote:
>>>>>>> On 12/30/2021 12:21 PM, André G. Isaak wrote:
>>>>>>>> On 2021-12-30 09:54, olcott wrote:
>>>>>>>>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>>>>>>>>> On 12/30/21 10:58 AM, olcott wrote:
>>>>>>>>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>>> We don't care if embedded_H is 'Correct', we care that it
>>>>>>>>>>>> give the same answer as H.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If it is correct and gives a different answer than H then it
>>>>>>>>>>> remains correct even if it gives a different answer than H.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But since it IS a copy of H, then if it gives a different
>>>>>>>>>> answer than 'H' does, it shows that H fails to be a
>>>>>>>>>> Computation, and thus Can't be a Decider, and thus can't be a
>>>>>>>>>> Halt Decider.
>>>>>>>>> H and embedded_H are able to give a different halt status
>>>>>>>>> determinations on the basis that embedded_H had its copy of H
>>>>>>>>> corrupted by the appended infinite loop.
>>>>>>>>>
>>>>>>>>> This means that a finite string comparison performed by H will
>>>>>>>>> determine that embedded_H is not identical to H.
>>>>>>>>
>>>>>>>> And which two strings are being compared here? H hasn't been
>>>>>>>> provided a string describing itself nor a string describing
>>>>>>>> embedded_H as part of its input. All it has is a string
>>>>>>>> describing Ĥ. What does it compare this string to?
>>>>>>>>
>>>>>>>> André
>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> We as humans can see that while embedded_H performs a pure
>>>>>>> simulation of its input ⟨Ĥ⟩ ⟨Ĥ⟩ that this simulated input:
>>>>>>>
>>>>>>> copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then invokes embedded_H with this
>>>>>>> input over and over without ever stopping.
>>>>>>>
>>>>>>> Since a pure simulation of the input never stops we know that the
>>>>>>> UTM simulation of this same input never stops because a UTM
>>>>>>> performs a pure simulation of its input.
>>>>>>>
>>>>>>> Thus we know that the "does not halt" halt status criteria of
>>>>>>> embedded_H has been met.
>>>>>>>
>>>>>>> In order for embedded_H to see this it needs to see that an
>>>>>>> identical sequence of configurations keeps repeating.
>>>>>>>
>>>>>>> We as humans can see that the input to embedded_H is always
>>>>>>> identical.
>>>>>>> We as humans can see that the copy of embedded_H is always
>>>>>>> identical.
>>>>>>> We as humans can see that these two things can verified by finite
>>>>>>> string comparison.
>>>>>>
>>>>>> You didn't actually answer my question. Which two strings are
>>>>>> being compared? Ĥ has access to exactly one string, the string
>>>>>> representing its input. What is this being compared to?
>>>>>>
>>>>>> What we as humans can or cannot do has very little bearing on what
>>>>>> a Turing Machine can do.
>>>>>>
>>>>>
>>>>> Understanding what humans can do is a necessary prerequisite to
>>>>> understanding which strings are compared and why.
>>>>>
>>>>> Ultimately embedded_H sees a repeating sequence of configurations.
>>>>> Humans can most easily understand this in terms an identical
>>>>> function being called with identical arguments, thus three finite
>>>>> strings that must be compared.
>>>>
>>>> Again, you failed to answer the question.
>>>>
>>>> Which three strings are being compared?
>>>>
>>>> André
>>>>
>>>
>>> The corrupted copy of H at Ĥ.qx (AKA embedded_H) and its two inputs
>>> are three finite strings that infinitely repeat when embedded_H bases
>>> its halt status decision on the behavior of the pure simulation of
>>> its input.
>>>
>>
>> Wrong.
>>
>
> It is a correct conceptual design even if it must be implemented
> differently.
>

WRONG.

Whatever answer embedded_H gives, is wrong, by the construction of H^
and the definition of Halting for the Halting Problem.

There is no pattern that H/embedded_H can detect to answer Halting with
as show in:

Mesage ID <FOnzJ.162569$np6.119786@fx46.iad>
Date: 2021-12-30 19:31:49 GMT
Subject: Re: Concise refutation of halting problem proofs V42 [compute
the mapping]

You problem is you have a 'conceptual' design that doesn't actually have
a realizable solution.

FAIL.

>> See:
>> Mesage ID  <FOnzJ.162569$np6.119786@fx46.iad>
>> Date: 2021-12-30 19:31:49 GMT
>> Subject: Re: Concise refutation of halting problem proofs V42 [compute
>> the mapping]
>>
>
>

Re: Concise refutation of halting problem proofs V42 [compute the mapping]

<hXvzJ.266629$I%1.119345@fx36.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx36.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
<8GkzJ.67666$cW6.42695@fx08.iad>
<Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
<J7lzJ.133156$7D4.56836@fx37.iad>
<C-CdnTqrLLFIeVD8nZ2dnUU7-RWdnZ2d@giganews.com>
<uWlzJ.235028$aF1.204961@fx98.iad>
<X8qdnaH5EPMZaVD8nZ2dnUU7-LXNnZ2d@giganews.com>
<FOnzJ.162569$np6.119786@fx46.iad>
<YZOdnYrgZ_gz4FP8nZ2dnUU7-efNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <YZOdnYrgZ_gz4FP8nZ2dnUU7-efNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 173
Message-ID: <hXvzJ.266629$I%1.119345@fx36.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 23:47:09 -0500
X-Received-Bytes: 8545
X-Original-Bytes: 8412
 by: Richard Damon - Fri, 31 Dec 2021 04:47 UTC

On 12/30/21 10:48 PM, olcott wrote:
> On 12/30/2021 1:31 PM, Richard Damon wrote:
>> On 12/30/21 1:03 PM, olcott wrote:
>>> On 12/30/2021 11:23 AM, Richard Damon wrote:
>>>> On 12/30/21 11:56 AM, olcott wrote:
>>>>> On 12/30/2021 10:29 AM, Richard Damon wrote:
>>>>>> On 12/30/21 11:11 AM, olcott wrote:
>>>>>>> On 12/30/2021 9:57 AM, Richard Damon wrote:
>>>>>>>> On 12/30/21 10:20 AM, olcott wrote:
>>>>>>>>> On 12/30/2021 8:19 AM, Richard Damon wrote:
>>>>>>>>>> On 12/29/21 11:51 PM, olcott wrote:
>>>>>>>>>>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/29/21 11:02 PM, olcott wrote:
>>>>>>>>>>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>>>>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It's not your criterion, it's mine.  It's also Linz's.  If
>>>>>>>>>>>>>> yours is not
>>>>>>>>>>>>>> the same as his (and mine), it should be different in some
>>>>>>>>>>>>>> way. (And we
>>>>>>>>>>>>>> can safely ignore it, since no one cares about your
>>>>>>>>>>>>>> alternative
>>>>>>>>>>>>>> criteria.)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It has always been my criterion measure that halt deciders
>>>>>>>>>>>>> base their halt status decision on the pure simulation of
>>>>>>>>>>>>> their inputs.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That your notational conventions very cleanly express this
>>>>>>>>>>>>> idea as applied to the Linz H is a good breakthrough.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> As soon as people understand that this same criterion
>>>>>>>>>>>>> measure applies recursively to every embedded_H at Ĥ.qx,
>>>>>>>>>>>>> then they will see how this criterion measure provides the
>>>>>>>>>>>>> means for embedded_H to correctly compute the mapping from
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yes each level can use the test to determine if the halt
>>>>>>>>>>>> decider at that level got the right answer or not.
>>>>>>>>>>>>
>>>>>>>>>>>> The issue is that when we are doing this check, you check
>>>>>>>>>>>> JUST that level, and not lower levels.
>>>>>>>>>>>
>>>>>>>>>>> No you are wrong.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Source? (Some REAL reference)
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>>>
>>>>>>>>> The source is the correct reasoning of how the above criterion
>>>>>>>>> measure would be applied when H is copied to Ĥ.qx.
>>>>>>>>
>>>>>>>> We copy the ALGORITHM of H, the detailed step by step instructions
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> You keep thinking that a subsequent level UTM magically turns
>>>>>>>>> into embedded_H and aborts its simulation.
>>>>>>>>
>>>>>>>> There IS no UTM in the machine. PERIOD. (unless H IS a UTM)
>>>>>>>>
>>>>>>> H always bases its halt status decision on the behavior of the
>>>>>>> UTM simulation of its input. Thus embedded_H bases its halt
>>>>>>> status decision on the behavior of the UTM simulation of its
>>>>>>> input. This means that H and embedded_H continue a pure
>>>>>>> simulation of N steps of their input until their input halts on
>>>>>>> its own or this input demonstrates an infinite behavior pattern.
>>>>>>
>>>>>> And that means that H must NEVER halt its simulation of H^, and thus
>>>>>
>>>>> The reason why I ignore most of your posts is that I stop at the
>>>>> very first very stupid mistake.
>>>>>
>>>>
>>>> You mean you stop at the first thing you can't answer.
>>>>
>>>
>>> It is very stupid to say that
>>> "H must NEVER halt its simulation of H^"
>>>
>>> When I just said exactly how and when H does correctly halt its
>>> simulation of Ĥ:
>>>
>>>  >>>> H and embedded_H continue a pure simulation of N steps of
>>>  >>>> their input until their input halts on its own or this input
>>>  >>>> demonstrates an infinite behavior pattern.
>>>
>>> In the future I will simply ignore these stupid mistakes so that
>>> other respondents only need to pay attention to my responses and can
>>> equally ignore the clutter of your stupid mistakes.
>>>
>>
>> But there IS no finite pattern that demonstrates an infitite behavior
>> pattern.
>>
>
> This is a finite pattern that demonstrates an infinite behavior pattern.
>
> void Infinite_Loop(int N)
> {
>   HERE: goto HERE;
> }
>
> _Infinite_Loop()
> [00000cb5](01)  55              push ebp
> [00000cb6](02)  8bec            mov ebp,esp
> [00000cb8](02)  ebfe            jmp 00000cb8
> [00000cba](01)  5d              pop ebp
> [00000cbb](01)  c3              ret
> Size in bytes:(0007) [00000cbb]

I didn't say there aren't patterns that H could use to detect some machines.

There is no pattern that H can detect in H^ that can prove it Halts.

This is just another of your Strawmen.

Also, just because a pattern detects some non-halting machines doesn't
mean that all machines that show the pattern are non-halting.

You need to be able to actually PROVE that ALL Machine with this pattern
WILL BE Non-Halting.

FAIL.

>
>
>> FAIR WARNING. I reserve the right to just mention this proof every
>> time you repeat that claim without actually showing a problem with it.
>>
>> If their IS a pattern that H thinks demonstrates an infinite behavior
>> pattern, and when it sees this it aborts its simulation and returns
>> the Non-Halting answer, then when we run an actual computation of H^
>> <H^> then we will see that
>>
>> H^ <H^> goes to H^.qx <H^> <H^> which is a copy of H.q0 <H^> <H^>
>> which will then run for some time until it sees the pattern that it
>> thinks demonstrates an infinite behavior pattern, and goes to H.qn
>> which means H^ goes to H^.qn which Halts.
>>
>> This thus shows that H^ <H^> which is the equiavlent to UTM(<H^>,<H^>)
>> halts, and thus the pattern that H thought was proof of non-halting
>> can actually lead to a Halting behavior, so H was INCORRECT that this
>> pattern was actually proof of infinite behavior.
>>
>>
>> This means that you H, using that definition either fails to return an
>> answer at all, and thus fails to be a decider, or it fails to follow
>> its algorithm that your just defined.
>>
>> FAIL.
>>
>> You ar just assuming the existance of a finite set of patterns that
>> detect non-halting behavior. In other words, your 'proof' that the
>> problem is solvable requires as an assumption, that the problem is
>> solvable. This leads to a contradiction, showing that assumption to be
>> false.
>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<sqnutn$lbd$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Date: Fri, 31 Dec 2021 15:06:47 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 20
Message-ID: <sqnutn$lbd$1@dont-email.me>
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 31 Dec 2021 22:06:47 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="02d19adbf6a3ed5e056bed51cc544709";
logging-data="21869"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18L+q2p4Ve0qLfsxZ05WgrZ"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:AvGRpptBFmKcz2yIBdER+UJO8Jw=
In-Reply-To: <Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 31 Dec 2021 22:06 UTC

On 2021-12-30 14:15, olcott wrote:
> On 12/30/2021 2:58 PM, André G. Isaak wrote:

>> Which three strings are being compared?
>>
>
> The answer is self-evident in order to verify that the same function is
> being called with the same inputs embedded_H and its input pair must be
> compared to the prior copy of these same three finite strings.

'embedded_H' isn't even a string. And where is it supposed to get the
'prior copies' of these three strings from? You can't compare strings
that you don't have.

André

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 17:02:03 -0600
Date: Fri, 31 Dec 2021 17:02:02 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com> <sqnutn$lbd$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqnutn$lbd$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>
Lines: 50
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sBqCG0DhIfHuxylEfDrss6TjlbaUm6IrDme2gBgM+rmJIILSY4XcmoMIoWbneGaaR/uO+TqzQxhyMxm!MGmrzDSykFxiT8ZLGiwESq+0aqfUeiGiJnvAAeqcozku1cq+mD2Nv1fEC9gGjiwsSq7WtV8x5X2A!PA==
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: 3834
 by: olcott - Fri, 31 Dec 2021 23:02 UTC

On 12/31/2021 4:06 PM, André G. Isaak wrote:
> On 2021-12-30 14:15, olcott wrote:
>> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>
>>> Which three strings are being compared?
>>>
>>
>> The answer is self-evident in order to verify that the same function
>> is being called with the same inputs embedded_H and its input pair
>> must be compared to the prior copy of these same three finite strings.
>
> 'embedded_H' isn't even a string.

embedded_H is short hand so I don't have to keep repeating that embedded
copy of H at Ĥ.qx. When I refer to the string of embedded_H I am
referring to the string of the machine description of the copy of H at
Ĥ.qx with the infinite loop appended to the Ĥ.qy state of H.

> And where is it supposed to get the
> 'prior copies' of these three strings from? You can't compare strings
> that you don't have.
>

As soon as the TM equivalent of embedded_H being invoked by the
simulated ⟨Ĥ⟩ ⟨Ĥ⟩ occurs once the infinitely recursive simulation
criteria has been met. The halt decider might have to wait until the
second time this occurs so that it has a pair of finite string triples
to compare (for equality) using finite string comparison.

Much more important than the detailed underlying mechanics of this is
the fact that any human can see that Ĥ applied to ⟨Ĥ⟩ is infinitely
recursive unless aborted and the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches a final
state thus never halts whether or not its simulation is aborted.

An actual computer scientist will understand that embedded_H does
compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
final state Ĥ.qn on the basis that the actual input would never halt.

> 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: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<sqo3vg$lun$1@dont-email.me>

 copy mid

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

 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: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Date: Fri, 31 Dec 2021 16:33:02 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 58
Message-ID: <sqo3vg$lun$1@dont-email.me>
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com> <sqnutn$lbd$1@dont-email.me>
<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 31 Dec 2021 23:33:04 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="bff1373fde05290c993069d3ef3c39a2";
logging-data="22487"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+u3TlYQ7NxqjP8TqQpO06+"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:Zcz7cDNjrsc2MrrytmFNkUf59Oo=
In-Reply-To: <s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Fri, 31 Dec 2021 23:33 UTC

On 2021-12-31 16:02, olcott wrote:
> On 12/31/2021 4:06 PM, André G. Isaak wrote:
>> On 2021-12-30 14:15, olcott wrote:
>>> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>>
>>>> Which three strings are being compared?
>>>>
>>>
>>> The answer is self-evident in order to verify that the same function
>>> is being called with the same inputs embedded_H and its input pair
>>> must be compared to the prior copy of these same three finite strings.
>>
>> 'embedded_H' isn't even a string.
>
> embedded_H is short hand so I don't have to keep repeating that embedded
> copy of H at Ĥ.qx. When I refer to the string of embedded_H I am
> referring to the string of the machine description of the copy of H at
> Ĥ.qx with the infinite loop appended to the Ĥ.qy state of H.

Embedded_H isn't a string anymore than Ĥ is a string. It would be
possible to create a *description* of Embedded_H that is a string, but
Embedded_H has no access to such a string. The only string it has access
to is the input to Ĥ. When you've only got one string how can you
compare it to anything?

>> And where is it supposed to get the 'prior copies' of these three
>> strings from? You can't compare strings that you don't have.
>>

Nothing you write below addresses the above question. Where does
Embedded_H get these 'prior copies' from? They aren't an input to Ĥ. And
Embedded_H has absolutely no idea whether the Ĥ it is part of is being
run directly or being emulated by some sort of simulator. It has no idea
whether there even *are* prior copies.

> As soon as the TM equivalent of embedded_H being invoked by the
> simulated ⟨Ĥ⟩ ⟨Ĥ⟩ occurs once the infinitely recursive simulation
> criteria has been met. The halt decider might have to wait until the
> second time this occurs so that it has a pair of finite string triples
> to compare (for equality) using finite string comparison.
>
> Much more important than the detailed underlying mechanics of this is
> the fact that any human can see that Ĥ applied to ⟨Ĥ⟩ is infinitely
> recursive unless aborted and the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches a final
> state thus never halts whether or not its simulation is aborted.
>
> An actual computer scientist will understand that embedded_H does
> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
> final state Ĥ.qn on the basis that the actual input would never halt.

You're not really in a position to state what an actual computer
scientist would understand. Only an actual computer scientist can do that.

André

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

Re: Concise refutation of halting problem proofs V42 [ultimate criterion measure]

<yzMzJ.163035$np6.23363@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com> <sqnutn$lbd$1@dont-email.me>
<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 69
Message-ID: <yzMzJ.163035$np6.23363@fx46.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 18:42:24 -0500
X-Received-Bytes: 4379
 by: Richard Damon - Fri, 31 Dec 2021 23:42 UTC

On 12/31/21 6:02 PM, olcott wrote:
> On 12/31/2021 4:06 PM, André G. Isaak wrote:
>> On 2021-12-30 14:15, olcott wrote:
>>> On 12/30/2021 2:58 PM, André G. Isaak wrote:
>>
>>>> Which three strings are being compared?
>>>>
>>>
>>> The answer is self-evident in order to verify that the same function
>>> is being called with the same inputs embedded_H and its input pair
>>> must be compared to the prior copy of these same three finite strings.
>>
>> 'embedded_H' isn't even a string.
>
> embedded_H is short hand so I don't have to keep repeating that embedded
> copy of H at Ĥ.qx. When I refer to the string of embedded_H I am
> referring to the string of the machine description of the copy of H at
> Ĥ.qx with the infinite loop appended to the Ĥ.qy state of H.

Why not just call it H? they are all the same remember, or is that one
of the unfortunate facts you need us to forget for you 'proof' to work.

>
>> And where is it supposed to get the 'prior copies' of these three
>> strings from? You can't compare strings that you don't have.
>>
>
> As soon as the TM equivalent of embedded_H being invoked by the
> simulated ⟨Ĥ⟩ ⟨Ĥ⟩ occurs once the infinitely recursive simulation
> criteria has been met. The halt decider might have to wait until the
> second time this occurs so that it has a pair of finite string triples
> to compare (for equality) using finite string comparison.
>

Nope. Do you have a PROOF of that?

Remember, H is NOT a UTM and does not actually CALL it input, it
simulates with the ability to abort, so your 'rule' isn't an actual fact.

> Much more important than the detailed underlying mechanics of this is
> the fact that any human can see that Ĥ applied to ⟨Ĥ⟩ is infinitely
> recursive unless aborted and the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches a final
> state thus never halts whether or not its simulation is aborted.
>

Nope, any smart human can see that you are missing the imprtant point
that H^ halts when H goes to Qn, so H is wrong.

Didn't you once rave about how people need to lock at the actual facts
and not just intuition?

> An actual computer scientist will understand that embedded_H does
> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
> final state Ĥ.qn on the basis that the actual input would never halt.
>

Nope, a real computer scientist would understand the definition of
Halting, and that H got the answer wrong by simple observation, and
would see that all the smoke and mirrors is just being thrown up as a
distraction.

FAIL.

>> André
>>
>>
>
>

Re: Concise refutation of halting problem proofs V42 [computer scientist]

<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>

 copy mid

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

 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: Fri, 31 Dec 2021 18:05:11 -0600
Date: Fri, 31 Dec 2021 18:05:10 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [computer
scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com> <sqnutn$lbd$1@dont-email.me>
<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com> <sqo3vg$lun$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqo3vg$lun$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
Lines: 30
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-B6jlGqZxF6kufSxeLiSrQryrIZ+SLAcpqpLSJBbWbT2+LBAjVtNJJZ7wCuptw3dVYTbk2pP/lpIpbFT!CErzM7eGa5R0VLCyE90X+86a5OVJylllWw4lYfi4FZUdKQQgVKCZIuHV0kZOU4XODWnF4w9nqq5J!CQ==
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: 3117
 by: olcott - Sat, 1 Jan 2022 00:05 UTC

On 12/31/2021 5:33 PM, André G. Isaak wrote:
> On 2021-12-31 16:02, olcott wrote:
>> On 12/31/2021 4:06 PM, André G. Isaak wrote:

>> An actual computer scientist will understand that embedded_H does
>> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
>> final state Ĥ.qn on the basis that the actual input would never halt.
>
> You're not really in a position to state what an actual computer
> scientist would understand. Only an actual computer scientist can do that.
>

It is a self-evident truth that:
(a) The pure simulation of the Turing machine description of a machine
is computationally equivalent to the direct execution of this machine.

(b) The pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never halt.

(c) If the pure simulation of the input to a halt decider would never
halt then the halt decider correctly decides that this input does not halt.

A computer scientist would understand these things.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [computer scientist]

<J2NzJ.108317$zF3.46708@fx03.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx03.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.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [computer
scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com> <sqnutn$lbd$1@dont-email.me>
<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com> <sqo3vg$lun$1@dont-email.me>
<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 67
Message-ID: <J2NzJ.108317$zF3.46708@fx03.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: Fri, 31 Dec 2021 19:15:39 -0500
X-Received-Bytes: 4546
 by: Richard Damon - Sat, 1 Jan 2022 00:15 UTC

On 12/31/21 7:05 PM, olcott wrote:
> On 12/31/2021 5:33 PM, André G. Isaak wrote:
>> On 2021-12-31 16:02, olcott wrote:
>>> On 12/31/2021 4:06 PM, André G. Isaak wrote:
>
>>> An actual computer scientist will understand that embedded_H does
>>> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
>>> final state Ĥ.qn on the basis that the actual input would never halt.
>>
>> You're not really in a position to state what an actual computer
>> scientist would understand. Only an actual computer scientist can do
>> that.
>>
>
> It is a self-evident truth that:
> (a) The pure simulation of the Turing machine description of a machine
> is computationally equivalent to the direct execution of this machine.

Right.
>
> (b) The pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never halt.

Only if embedded_H does abort its simulation and return to Qn

>
> (c) If the pure simulation of the input to a halt decider would never
> halt then the halt decider correctly decides that this input does not halt.

Right, IF the REAL pure simulation of the input to a halt decider would
never halt, then the input compuation is non-halt.

Sincd H^ includes a copy of H in it, it means that H has to take into
account what H will do when it decides what answer is correct.

H can NOT assume that the copy of H will be just a pure UTM, unless H is
actually going to act like a pure UTM, which means it can't abort its
simulation.

IF H would do some actual correct logic analysis, which include looking
at what its own behavior would be, it might be able to answer some of
these recursive problems, the big issue is that the way YOU have decided
to structure your "Simulating Halt Decider", it basically has NO way of
deterining what might happen after the copy of H returns, so it really
can't know what happens.

This means that the BEST your decider can do is just loop forever as it
really doesn't know the answer to the problem, and has no way to figure
it out.

A Year or more ago, I gave you the outline of a slight improvement on
your machine that could handle variation like your H-double-dot, that
don't act contrary (assuming you also assume that H can actually detect
that a copy of H has been used, which in full generality can't be done),
but this still can't handle the contrry H^ case, as there really is no
correct answer that H can give.

>
> A computer scientist would understand these things.
>
>

They would uderstand the real Truth.

You problem is you have made a great recipe for Halt Detection, the only
problem is that it needs the Horn of a Unicorn, but those don't exist,
so you can't actually make your decider.

Re: Concise refutation of halting problem proofs V42 [computer scientist]

<PLGdnc9lidz8A1L8nZ2dnUU7-a3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 18:20:49 -0600
Date: Fri, 31 Dec 2021 18:20:48 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [computer
scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com> <sqktb6$thq$1@dont-email.me>
<qLidnVby_aDjlFP8nZ2dnUU7-UHNnZ2d@giganews.com> <sql4qd$dre$1@dont-email.me>
<W8OdnXzQIutMhlP8nZ2dnUU7-Q3NnZ2d@giganews.com> <sql6he$khm$1@dont-email.me>
<Y_mdnZp_XMbuvFP8nZ2dnUU7-dPNnZ2d@giganews.com> <sqnutn$lbd$1@dont-email.me>
<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com> <sqo3vg$lun$1@dont-email.me>
<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<J2NzJ.108317$zF3.46708@fx03.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <J2NzJ.108317$zF3.46708@fx03.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <PLGdnc9lidz8A1L8nZ2dnUU7-a3NnZ2d@giganews.com>
Lines: 41
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-H4e4Nv7odwo9mFza4ywZPdiJXRuKSjHa6AolHNL3Lh9i5lOr9lZ+KLZ+6Gmyc92jv8x96bm3GJhF8SK!ia27vq00ZMqaMXE4FbHalogoEMYokCQizXqNG5gpNJ2SmRDYkhwETYpHayJJZF+t5ogoZqxzxSa9!Ww==
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: 3454
 by: olcott - Sat, 1 Jan 2022 00:20 UTC

On 12/31/2021 6:15 PM, Richard Damon wrote:
> On 12/31/21 7:05 PM, olcott wrote:
>> On 12/31/2021 5:33 PM, André G. Isaak wrote:
>>> On 2021-12-31 16:02, olcott wrote:
>>>> On 12/31/2021 4:06 PM, André G. Isaak wrote:
>>
>>>> An actual computer scientist will understand that embedded_H does
>>>> compute the mapping from these inputs finite strings ⟨Ĥ⟩ ⟨Ĥ⟩ to this
>>>> final state Ĥ.qn on the basis that the actual input would never halt.
>>>
>>> You're not really in a position to state what an actual computer
>>> scientist would understand. Only an actual computer scientist can do
>>> that.
>>>
>>
>> It is a self-evident truth that:
>> (a) The pure simulation of the Turing machine description of a machine
>> is computationally equivalent to the direct execution of this machine.
>
> Right.
>>
>> (b) The pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never halt.
>
> Only if embedded_H does abort its simulation and return to Qn

Whether or not embedded_H aborts its simulation its input would never
halt. A computer scientist would know that.

A computer scientist also knows that the halt status decision basis is
whether or not the input would ever halt.

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

rocksolid light 0.9.7
clearnet tor