Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

A mathematician is a device for turning coffee into theorems. -- P. Erdos


devel / comp.theory / Re: Concise refutation of halting problem proofs V42 [computer scientist]

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 [computer scientist]

<PtNzJ.229017$AJ2.59482@fx33.iad>

 copy mid

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

 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!fx33.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>
<J2NzJ.108317$zF3.46708@fx03.iad>
<PLGdnc9lidz8A1L8nZ2dnUU7-a3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <PLGdnc9lidz8A1L8nZ2dnUU7-a3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 77
Message-ID: <PtNzJ.229017$AJ2.59482@fx33.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:44:33 -0500
X-Received-Bytes: 4633
X-Original-Bytes: 4500
 by: Richard Damon - Sat, 1 Jan 2022 00:44 UTC

On 12/31/21 7:20 PM, olcott wrote:
> 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.
>

WRONG.

First, you are using a incorrect term. The 'input' doesn't halt or not.
It is just a 'string'

Machines Halt when performing computation.

The input does REPRESENT a computation, and that is what halts or not.

That Computation is the appliation of <H^> to H^, which if embedded_H
aborts and goes to H.Qn, will Halt.

So your statement that:

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

Is just a big fat LIE. And a real computer scientist would actually know
that.

You have been reminded of this ffact so many times, you continual return
to this claim show that you really don't know what you are talking
about, and my advice is that you really need to just put this down and
take care of yourself.

My charatable evalutation is that you have some sort of mental condition
that makes you think this thing is true dispite all the evidence you
have been given. You are at the point that you have stopped looking at
evidence and thus have lost all touch with reality.

The only other possiblity in my mind is that you are just a pathalogical
liar, but even then, you really need to seek treatment before you get
yourself int trouble with it.

Maybe someone with a bit of logic skills talking to you face to face
might be able to show you your error, and prayerfully get you to
understand the real truth.

Insisting on something that is false, is not good for a person, it will
tear you apart.

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

<0f2dndcyDo9pOFL8nZ2dnUU7-S3NnZ2d@giganews.com>

 copy mid

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

 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:53:08 -0600
Date: Fri, 31 Dec 2021 18:53:07 -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>
<PLGdnc9lidz8A1L8nZ2dnUU7-a3NnZ2d@giganews.com>
<PtNzJ.229017$AJ2.59482@fx33.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <PtNzJ.229017$AJ2.59482@fx33.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <0f2dndcyDo9pOFL8nZ2dnUU7-S3NnZ2d@giganews.com>
Lines: 62
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jUMrw5OlXlITR8h7bggD6LmThWzv9ttybhAZUQ9miA9vIWstpWva79ptmwfDVn6vjVfZyiwGdHfaoNz!DN4sMKUW9zCeo4mdYvRXPG7SA/9gPDWGEeq7R0ea/TNGmKI/ty6NyQujTDHsNTJ3FkHRl+vYDEvl!Eg==
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: 4370
 by: olcott - Sat, 1 Jan 2022 00:53 UTC

On 12/31/2021 6:44 PM, Richard Damon wrote:
>
> On 12/31/21 7:20 PM, olcott wrote:
>> 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.
>>
>
> WRONG.
>
> First, you are using a incorrect term. The 'input' doesn't halt or not.
> It is just a 'string'
>
> Machines Halt when performing computation.
>
> The input does REPRESENT a computation, and that is what halts or not.
>

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever. https://en.wikipedia.org/wiki/Halting_problem

When embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis the the pure
simulation of its input would never halt it is necessarily correct.

--
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]

<sqo9o5$hh6$1@dont-email.me>

 copy mid

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

 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 [computer
scientist]
Date: Fri, 31 Dec 2021 18:11:32 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 38
Message-ID: <sqo9o5$hh6$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> <sqo3vg$lun$1@dont-email.me>
<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 1 Jan 2022 01:11:34 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="bff1373fde05290c993069d3ef3c39a2";
logging-data="17958"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+Ux2YxP/2U9yMvmLEyFSY9"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:WroJQKKdCehLmtEalhydm2TBZ1Y=
In-Reply-To: <FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sat, 1 Jan 2022 01:11 UTC

On 2021-12-31 17:05, 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.
>
> (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.

It would appear that you ignored (and cut) all the actual points in my post.

Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does Ĥ
determine that its input describes itself? You claim this is done by
string comparisons, but which strings are being compared? The only
string Ĥ has access to its input string. What does it compare this
string with?

André

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

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

<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>

 copy mid

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

 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 19:17:25 -0600
Date: Fri, 31 Dec 2021 19:17:23 -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> <sqo9o5$hh6$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqo9o5$hh6$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-8WW2Sg8vgGqx+dLPb1UVTbh4lfwAt+qO1s6FV3XasTgx58cqNg+OrjSCX2fi+L6I/U192AzAgudHZGR!ZFLffhX9t3daK3FbgJODh1NTGmUnfrZZUmNq29mNjgpJ0H/nNfgD5k2Rryw6tuN+W0dVrdMhEX8W!kg==
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: 4001
 by: olcott - Sat, 1 Jan 2022 01:17 UTC

On 12/31/2021 7:11 PM, André G. Isaak wrote:
> On 2021-12-31 17:05, 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.
>>
>> (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.
>
> It would appear that you ignored (and cut) all the actual points in my
> post.
>
> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does Ĥ
> determine that its input describes itself? You claim this is done by
> string comparisons, but which strings are being compared? The only
> string Ĥ has access to its input string. What does it compare this
> string with?
>
> André
>

So far I have not gotten to any point of closure on anything that I have
said. I must insist on points of closure for continued dialogue.

Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
never 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

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

<sqob91$nom$1@dont-email.me>

 copy mid

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

 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 [computer
scientist]
Date: Fri, 31 Dec 2021 18:37:37 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 57
Message-ID: <sqob91$nom$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> <sqo3vg$lun$1@dont-email.me>
<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 1 Jan 2022 01:37:37 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="bff1373fde05290c993069d3ef3c39a2";
logging-data="24342"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19TEiw5VzsnpKoeP59iY3Dq"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:Ox6QNsqALGHtyPPjlkDq3kfTtcM=
In-Reply-To: <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Sat, 1 Jan 2022 01:37 UTC

On 2021-12-31 18:17, olcott wrote:
> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>> On 2021-12-31 17:05, 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.
>>>
>>> (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.
>>
>> It would appear that you ignored (and cut) all the actual points in my
>> post.
>>
>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does Ĥ
>> determine that its input describes itself? You claim this is done by
>> string comparisons, but which strings are being compared? The only
>> string Ĥ has access to its input string. What does it compare this
>> string with?
>>
>> André
>>
>
> So far I have not gotten to any point of closure on anything that I have
> said. I must insist on points of closure for continued dialogue.
>
> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
> never halt?

Of course I don't, since that claim is simply false.

Now why don't you actually answer the question I asked?

André

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

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

<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>

 copy mid

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

 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 19:50:12 -0600
Date: Fri, 31 Dec 2021 19:50:11 -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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqob91$nom$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
Lines: 65
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3kRtbUhGFXdvbSBjenM48mPdeNpkLopUN7KOJOHn49DnW1RTibm/1mIQtCpxicESphRedKWI05CTRSE!zWdPRRWIhtLGvvsUu0x5eaZu+fnCX679SzCuShzLIls3+CFCvfAQh1xqlQd6y3y38dPEo55JGgNn!Sg==
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: 4502
 by: olcott - Sat, 1 Jan 2022 01:50 UTC

On 12/31/2021 7:37 PM, André G. Isaak wrote:
> On 2021-12-31 18:17, olcott wrote:
>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>> On 2021-12-31 17:05, 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.
>>>>
>>>> (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.
>>>
>>> It would appear that you ignored (and cut) all the actual points in
>>> my post.
>>>
>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does Ĥ
>>> determine that its input describes itself? You claim this is done by
>>> string comparisons, but which strings are being compared? The only
>>> string Ĥ has access to its input string. What does it compare this
>>> string with?
>>>
>>> André
>>>
>>
>> So far I have not gotten to any point of closure on anything that I
>> have said. I must insist on points of closure for continued dialogue.
>>
>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>> never halt?
>
> Of course I don't, since that claim is simply false.
>
> Now why don't you actually answer the question I asked?
>
> André
>

We must stay on this point until we have mutual agreement.
Why do you say it is 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 [computer scientist]

<E%OzJ.68361$cW6.62267@fx08.iad>

 copy mid

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

 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!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx08.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>
<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>
<PLGdnc9lidz8A1L8nZ2dnUU7-a3NnZ2d@giganews.com>
<PtNzJ.229017$AJ2.59482@fx33.iad>
<0f2dndcyDo9pOFL8nZ2dnUU7-S3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <0f2dndcyDo9pOFL8nZ2dnUU7-S3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 81
Message-ID: <E%OzJ.68361$cW6.62267@fx08.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 21:28:55 -0500
X-Received-Bytes: 4558
X-Original-Bytes: 4425
 by: Richard Damon - Sat, 1 Jan 2022 02:28 UTC

On 12/31/21 7:53 PM, olcott wrote:
> On 12/31/2021 6:44 PM, Richard Damon wrote:
>>
>> On 12/31/21 7:20 PM, olcott wrote:
>>> 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.
>>>
>>
>> WRONG.
>>
>> First, you are using a incorrect term. The 'input' doesn't halt or
>> not. It is just a 'string'
>>
>> Machines Halt when performing computation.
>>
>> The input does REPRESENT a computation, and that is what halts or not.
>>
>
> In computability theory, the halting problem is the problem of
> determining, from a description of an arbitrary computer program and an
> input, whether the program will finish running, or continue to run
> forever. https://en.wikipedia.org/wiki/Halting_problem
>
> When embedded_H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn on the basis the the pure
> simulation of its input would never halt it is necessarily correct.
>

HOW?

IF H maps <H^> <H^> to Qn, then a simple examinate of H^ shows that the
folowing trtace:

H^.q0 <H^>
H^.qx <H^> <H^>
then goes into copy of H, the goes to H.qn so we end up at
H^.qn

HALTS.

Thus, BY THE DEFINITION YOU JUST STATED, The program which H was given a
description of Halted, but H gave the answer Non-Halting

How is that correct?

Unless you embedded_H is different than H, at which point you have lied
that you have set up H^ correctly, this is the only possible outcome if
you claim H did go to H.qn.

FAIL.

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

<69PzJ.214781$3q9.35099@fx47.iad>

 copy mid

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

 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!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 103
Message-ID: <69PzJ.214781$3q9.35099@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 21:39:00 -0500
X-Received-Bytes: 6045
 by: Richard Damon - Sat, 1 Jan 2022 02:39 UTC

On 12/31/21 8:50 PM, olcott wrote:
> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>> On 2021-12-31 18:17, olcott wrote:
>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>> On 2021-12-31 17:05, 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.
>>>>>
>>>>> (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.
>>>>
>>>> It would appear that you ignored (and cut) all the actual points in
>>>> my post.
>>>>
>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does Ĥ
>>>> determine that its input describes itself? You claim this is done by
>>>> string comparisons, but which strings are being compared? The only
>>>> string Ĥ has access to its input string. What does it compare this
>>>> string with?
>>>>
>>>> André
>>>>
>>>
>>> So far I have not gotten to any point of closure on anything that I
>>> have said. I must insist on points of closure for continued dialogue.
>>>
>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>> never halt?
>>
>> Of course I don't, since that claim is simply false.
>>
>> Now why don't you actually answer the question I asked?
>>
>> André
>>
>
> We must stay on this point until we have mutual agreement.
> Why do you say it is false?
>

BIG QUESTION.

Is it even a proper question?

Is it a fact that embedded_H just does a pure simulation?

Or. is there an abort condition?

Remember, any time you change any of the properties of the H that you
built H^ from, any analysis from previous H^s need to be thrown out, or
at least reconfirmed with the new H.

Yes, if H/embedded_H is JUST a pure simulator, aka UTM, that NEVER abort
the simulation, then the H^ built from that 'decider' will not halt, but
H never gives that correct answer.

If H/embedded_H include the option to abort, then if they will only
abort on actually PROVABLE non-halting configurations, then the same
thing will happen becauas H/embedded_H will never see a finite provably
non-halting configuation to abort on. THis was previously proven.

If H/embedded_H include the opotin to abort, an abort on something you
just CLIAM is a non-halting configuration, the we can see that since H
goes to H.qn, that H^ will go to H^.qn and Halt, and thus show that the
claimed non-halting configuration was incorrectly described, and H is wrong.

I don't care what 'proof' you have, all the ones you have shown before
had errors that you have not fixed, bringing them up again just shows
you don't understand what you are doing.

PLEASE show exactly which statement of mine you claim is logically
incorrect.

I am only using the basic definition of Halting, and the fact that all
copies of a given machine act the same, and a simple tracing of the
compuation defined as H^.

If you what to disagree witht the fact that all copies of a given achine
act the same, please provide an ACTUAL example of an ACTUAL Turing
Machine that can give two different answers for the same input with
different exact copies.

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

<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

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

 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 20:50:49 -0600
Date: Fri, 31 Dec 2021 20:50:47 -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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <69PzJ.214781$3q9.35099@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 83
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-dbHbuJYHHmonRkM11jidDMl0gUU1pjbc8b0/p/EJvqhM2j/9k5tPp+J/SVAqtSATyWesVxj6RJu4l+0!HRV9zM4sUGgIRtoMVsAo6WvpnOMejkDUGSArDLgzj6jS3f7qIxGgVmsxlNlnqBQXIgJ2oNydbupH!Tg==
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: 5182
 by: olcott - Sat, 1 Jan 2022 02:50 UTC

On 12/31/2021 8:39 PM, Richard Damon wrote:
> On 12/31/21 8:50 PM, olcott wrote:
>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>> On 2021-12-31 18:17, olcott wrote:
>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>> On 2021-12-31 17:05, 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.
>>>>>>
>>>>>> (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.
>>>>>
>>>>> It would appear that you ignored (and cut) all the actual points in
>>>>> my post.
>>>>>
>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does
>>>>> Ĥ determine that its input describes itself? You claim this is done
>>>>> by string comparisons, but which strings are being compared? The
>>>>> only string Ĥ has access to its input string. What does it compare
>>>>> this string with?
>>>>>
>>>>> André
>>>>>
>>>>
>>>> So far I have not gotten to any point of closure on anything that I
>>>> have said. I must insist on points of closure for continued dialogue.
>>>>
>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>>>> never halt?
>>>
>>> Of course I don't, since that claim is simply false.
>>>
>>> Now why don't you actually answer the question I asked?
>>>
>>> André
>>>
>>
>> We must stay on this point until we have mutual agreement.
>> Why do you say it is false?
>>
>
> BIG QUESTION.
>
> Is it even a proper question?
>
> Is it a fact that embedded_H just does a pure simulation?
>
> Or. is there an abort condition?
>
> Remember, any time you change any of the properties of the H that you
> built H^ from, any analysis from previous H^s need to be thrown out, or
> at least reconfirmed with the new H.

It is the case that when embedded_H simulates 0 to ∞ steps of its input
that its input never halts.

--
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]

<zCPzJ.214782$3q9.38321@fx47.iad>

 copy mid

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

 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!fx47.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 108
Message-ID: <zCPzJ.214782$3q9.38321@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 22:10:25 -0500
X-Received-Bytes: 5980
X-Original-Bytes: 5847
 by: Richard Damon - Sat, 1 Jan 2022 03:10 UTC

On 12/31/21 9:50 PM, olcott wrote:
> On 12/31/2021 8:39 PM, Richard Damon wrote:
>> On 12/31/21 8:50 PM, olcott wrote:
>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>> On 2021-12-31 18:17, olcott wrote:
>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>
>>>>>>> (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.
>>>>>>
>>>>>> It would appear that you ignored (and cut) all the actual points
>>>>>> in my post.
>>>>>>
>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does
>>>>>> Ĥ determine that its input describes itself? You claim this is
>>>>>> done by string comparisons, but which strings are being compared?
>>>>>> The only string Ĥ has access to its input string. What does it
>>>>>> compare this string with?
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> So far I have not gotten to any point of closure on anything that I
>>>>> have said. I must insist on points of closure for continued dialogue.
>>>>>
>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>> would never halt?
>>>>
>>>> Of course I don't, since that claim is simply false.
>>>>
>>>> Now why don't you actually answer the question I asked?
>>>>
>>>> André
>>>>
>>>
>>> We must stay on this point until we have mutual agreement.
>>> Why do you say it is false?
>>>
>>
>> BIG QUESTION.
>>
>> Is it even a proper question?
>>
>> Is it a fact that embedded_H just does a pure simulation?
>>
>> Or. is there an abort condition?
>>
>> Remember, any time you change any of the properties of the H that you
>> built H^ from, any analysis from previous H^s need to be thrown out,
>> or at least reconfirmed with the new H.
>
> It is the case that when embedded_H simulates 0 to ∞ steps of its input
> that its input never halts.
>

Yes, but then it doesn't answer and fails.

If you CHANGE H, so that it doesn't do that, you have a DIFFERENT H^,
and that H^ will halt if you changed H to go to H.qn because it thinks
that H^ is non-halting.

This is you old trick that still doesn't work.

H needs to do what it is programmed to do, and you can't change that
programming in the middle of an analysis.

H will either abort its simulation and be wrong, or not abort its
simulation and just fail by not giveing an answer.

There is no behavior that H can have that meets its requirements,
because it has been proved that such an H just doesn't exist.

It doesn't matter how many flawed arguements you make, they still will
not be right.

Remember, you need to find a flaw in the arguments of the proof you are
trying to 'disprove;, not just present a case you claim to be right, as
all that does is show the system of logic is inconsistent, and the error
will certainly be in the stuff you added.

You just don't seem to understand this. You are just proving that you
logic is incorrecdt by showing something that appears to generate a
contradiction.

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

<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>

 copy mid

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

 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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 21:39:08 -0600
Date: Fri, 31 Dec 2021 21:39:07 -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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <zCPzJ.214782$3q9.38321@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rcT1I0jYqssJkbirHDiZM/gstJaRjjFGULtY5jnLo78UT1/9V5Vje+2K9+uy5wjPQ3nfT//G19i0ZNs!yOeAk4YyZh7hb0xxzswWnCdPdv1bJXAPROYxBNZjqyTdDfkxqHQPQm9iGoAz2BUTQtv8rKWQQ6bS!/g==
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: 5668
 by: olcott - Sat, 1 Jan 2022 03:39 UTC

On 12/31/2021 9:10 PM, Richard Damon wrote:
>
> On 12/31/21 9:50 PM, olcott wrote:
>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>> On 12/31/21 8:50 PM, olcott wrote:
>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>
>>>>>>>> (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.
>>>>>>>
>>>>>>> It would appear that you ignored (and cut) all the actual points
>>>>>>> in my post.
>>>>>>>
>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how
>>>>>>> does Ĥ determine that its input describes itself? You claim this
>>>>>>> is done by string comparisons, but which strings are being
>>>>>>> compared? The only string Ĥ has access to its input string. What
>>>>>>> does it compare this string with?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> So far I have not gotten to any point of closure on anything that
>>>>>> I have said. I must insist on points of closure for continued
>>>>>> dialogue.
>>>>>>
>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>> would never halt?
>>>>>
>>>>> Of course I don't, since that claim is simply false.
>>>>>
>>>>> Now why don't you actually answer the question I asked?
>>>>>
>>>>> André
>>>>>
>>>>
>>>> We must stay on this point until we have mutual agreement.
>>>> Why do you say it is false?
>>>>
>>>
>>> BIG QUESTION.
>>>
>>> Is it even a proper question?
>>>
>>> Is it a fact that embedded_H just does a pure simulation?
>>>
>>> Or. is there an abort condition?
>>>
>>> Remember, any time you change any of the properties of the H that you
>>> built H^ from, any analysis from previous H^s need to be thrown out,
>>> or at least reconfirmed with the new H.
>>
>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>> input that its input never halts.
>>
>
> Yes, but then it doesn't answer and fails.
>

It is the case that when embedded_H simulates 0 to ∞ steps of its input
that its input never halts

CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS ABORTED

--
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]

<5cQzJ.254762$IW4.19763@fx48.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer02.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 [computer
scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 113
Message-ID: <5cQzJ.254762$IW4.19763@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: Fri, 31 Dec 2021 22:50:28 -0500
X-Received-Bytes: 6075
 by: Richard Damon - Sat, 1 Jan 2022 03:50 UTC

On 12/31/21 10:39 PM, olcott wrote:
> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>
>> On 12/31/21 9:50 PM, olcott wrote:
>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>
>>>>>>>>> (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.
>>>>>>>>
>>>>>>>> It would appear that you ignored (and cut) all the actual points
>>>>>>>> in my post.
>>>>>>>>
>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how
>>>>>>>> does Ĥ determine that its input describes itself? You claim this
>>>>>>>> is done by string comparisons, but which strings are being
>>>>>>>> compared? The only string Ĥ has access to its input string. What
>>>>>>>> does it compare this string with?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> So far I have not gotten to any point of closure on anything that
>>>>>>> I have said. I must insist on points of closure for continued
>>>>>>> dialogue.
>>>>>>>
>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>> would never halt?
>>>>>>
>>>>>> Of course I don't, since that claim is simply false.
>>>>>>
>>>>>> Now why don't you actually answer the question I asked?
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> We must stay on this point until we have mutual agreement.
>>>>> Why do you say it is false?
>>>>>
>>>>
>>>> BIG QUESTION.
>>>>
>>>> Is it even a proper question?
>>>>
>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>
>>>> Or. is there an abort condition?
>>>>
>>>> Remember, any time you change any of the properties of the H that
>>>> you built H^ from, any analysis from previous H^s need to be thrown
>>>> out, or at least reconfirmed with the new H.
>>>
>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>> input that its input never halts.
>>>
>>
>> Yes, but then it doesn't answer and fails.
>>
>
> It is the case that when embedded_H simulates 0 to ∞ steps of its input
> that its input never halts
>
> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS ABORTED
>
>

Yes, But H can't do that aborting, because you just said that embedded_H
didn't abort it.

MAKE UP YOU MIND.

H/embedded_H can only do ONE thing with a given input. PERIOD.

If you disagree with that statement, PROVE YOUR POINT.

Please show an ACTUAL TURING MACHINE, you know, with states and inputs,
and an input tape, and show how it can give two different results.

FAIR WARNING:

IF NOT, ANY TIME you make a comment that implies a given algorithm doing
two diferent thing, it will just be pointed out that you are violating a
property of Computations and Turing Machine and are not working on the
Halting Problem.

FAIL!

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

<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>

 copy mid

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

 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 21:57:05 -0600
Date: Fri, 31 Dec 2021 21:57:01 -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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <5cQzJ.254762$IW4.19763@fx48.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
Lines: 143
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-qWRF1h6cFpg179CHbn+ZMjLE/slwHqzkyI3KKhnThYBSKK0zYzdNB/ns9qQ9awdSxq7QAaxMtf4wxRh!VYx6ZIpQCYQGeTrUTgOW45ePUKTUYA6GjhnTJsq+658oya/kWZgDrl0+//yTmT8f7ekow297CPDc!JQ==
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: 7116
 by: olcott - Sat, 1 Jan 2022 03:57 UTC

On 12/31/2021 9:50 PM, Richard Damon wrote:
> On 12/31/21 10:39 PM, olcott wrote:
>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>
>>> On 12/31/21 9:50 PM, olcott wrote:
>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>
>>>>>>>>>> (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.
>>>>>>>>>
>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>> points in my post.
>>>>>>>>>
>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how
>>>>>>>>> does Ĥ determine that its input describes itself? You claim
>>>>>>>>> this is done by string comparisons, but which strings are being
>>>>>>>>> compared? The only string Ĥ has access to its input string.
>>>>>>>>> What does it compare this string with?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> So far I have not gotten to any point of closure on anything
>>>>>>>> that I have said. I must insist on points of closure for
>>>>>>>> continued dialogue.
>>>>>>>>
>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>> would never halt?
>>>>>>>
>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>
>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> We must stay on this point until we have mutual agreement.
>>>>>> Why do you say it is false?
>>>>>>
>>>>>
>>>>> BIG QUESTION.
>>>>>
>>>>> Is it even a proper question?
>>>>>
>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>
>>>>> Or. is there an abort condition?
>>>>>
>>>>> Remember, any time you change any of the properties of the H that
>>>>> you built H^ from, any analysis from previous H^s need to be thrown
>>>>> out, or at least reconfirmed with the new H.
>>>>
>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>> input that its input never halts.
>>>>
>>>
>>> Yes, but then it doesn't answer and fails.
>>>
>>
>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>> input that its input never halts
>>
>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS ABORTED
>>
>>
>
> Yes, But H can't do that aborting, because you just said that embedded_H
> didn't abort it.
>

Do you think that it is possible to tell that an infinite loop will
never stop running without actually having to wait forever?

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]

> MAKE UP YOU MIND.
>
> H/embedded_H can only do ONE thing with a given input. PERIOD.
>
> If you disagree with that statement, PROVE YOUR POINT.
>
> Please show an ACTUAL TURING MACHINE, you know, with states and inputs,
> and an input tape, and show how it can give two different results.
>
> FAIR WARNING:
>
> IF NOT, ANY TIME you make a comment that implies a given algorithm doing
> two diferent thing, it will just be pointed out that you are violating a
> property of Computations and Turing Machine and are not working on the
> Halting Problem.
>
> FAIL!

--
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]

<mnQzJ.181779$6a3.8310@fx41.iad>

 copy mid

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

 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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx41.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 158
Message-ID: <mnQzJ.181779$6a3.8310@fx41.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 23:02:29 -0500
X-Received-Bytes: 7375
X-Original-Bytes: 7242
 by: Richard Damon - Sat, 1 Jan 2022 04:02 UTC

On 12/31/21 10:57 PM, olcott wrote:
> On 12/31/2021 9:50 PM, Richard Damon wrote:
>> On 12/31/21 10:39 PM, olcott wrote:
>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>
>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>
>>>>>>>>>>> (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.
>>>>>>>>>>
>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>> points in my post.
>>>>>>>>>>
>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how
>>>>>>>>>> does Ĥ determine that its input describes itself? You claim
>>>>>>>>>> this is done by string comparisons, but which strings are
>>>>>>>>>> being compared? The only string Ĥ has access to its input
>>>>>>>>>> string. What does it compare this string with?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So far I have not gotten to any point of closure on anything
>>>>>>>>> that I have said. I must insist on points of closure for
>>>>>>>>> continued dialogue.
>>>>>>>>>
>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>> would never halt?
>>>>>>>>
>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>
>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>> Why do you say it is false?
>>>>>>>
>>>>>>
>>>>>> BIG QUESTION.
>>>>>>
>>>>>> Is it even a proper question?
>>>>>>
>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>
>>>>>> Or. is there an abort condition?
>>>>>>
>>>>>> Remember, any time you change any of the properties of the H that
>>>>>> you built H^ from, any analysis from previous H^s need to be
>>>>>> thrown out, or at least reconfirmed with the new H.
>>>>>
>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>>> input that its input never halts.
>>>>>
>>>>
>>>> Yes, but then it doesn't answer and fails.
>>>>
>>>
>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>> input that its input never halts
>>>
>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS ABORTED
>>>
>>>
>>
>> Yes, But H can't do that aborting, because you just said that
>> embedded_H didn't abort it.
>>
>
> Do you think that it is possible to tell that an infinite loop will
> never stop running without actually having to wait forever?
>
> 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]
>
>

In some cases, yes.

You seem to like your Herring Red.

The question is not is it possible to answer some other halting
questions, but if H can answer a particular one.

I will take this Red Herring as an admission that you can not provide
any reason that two copies of a given algorithm can possible give two
different answers for the same input.

Any such reference will be marked as conceeded to be incorrect by
failure to show evidence.

FAIL.

>
>
>> MAKE UP YOU MIND.
>>
>> H/embedded_H can only do ONE thing with a given input. PERIOD.
>>
>> If you disagree with that statement, PROVE YOUR POINT.
>>
>> Please show an ACTUAL TURING MACHINE, you know, with states and
>> inputs, and an input tape, and show how it can give two different
>> results.
>>
>> FAIR WARNING:
>>
>> IF NOT, ANY TIME you make a comment that implies a given algorithm
>> doing two diferent thing, it will just be pointed out that you are
>> violating a property of Computations and Turing Machine and are not
>> working on the Halting Problem.
>>
>> FAIL!
>
>

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

<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>

 copy mid

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

 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 22:19:17 -0600
Date: Fri, 31 Dec 2021 22:19: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 [computer
scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <mnQzJ.181779$6a3.8310@fx41.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
Lines: 201
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gl1D+cuvsAb+Hrv1lBwZZj5Z51U1s8Ik0GzS5vtnvl0d7thdG3pLkN7V0jC03ryCoOLx0Xh6SiqRpmF!VJ+MdcuuDn4o5cRZsIrpyGToMH6Qwa0C3+YA1xFEu9cQZyTNqx15/79K0g17I8FxkClIKSppmpwQ!9g==
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: 9120
 by: olcott - Sat, 1 Jan 2022 04:19 UTC

On 12/31/2021 10:02 PM, Richard Damon wrote:
> On 12/31/21 10:57 PM, olcott wrote:
>> On 12/31/2021 9:50 PM, Richard Damon wrote:
>>> On 12/31/21 10:39 PM, olcott wrote:
>>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>>
>>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>>
>>>>>>>>>>>> (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.
>>>>>>>>>>>
>>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>>> points in my post.
>>>>>>>>>>>
>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how
>>>>>>>>>>> does Ĥ determine that its input describes itself? You claim
>>>>>>>>>>> this is done by string comparisons, but which strings are
>>>>>>>>>>> being compared? The only string Ĥ has access to its input
>>>>>>>>>>> string. What does it compare this string with?
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So far I have not gotten to any point of closure on anything
>>>>>>>>>> that I have said. I must insist on points of closure for
>>>>>>>>>> continued dialogue.
>>>>>>>>>>
>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>>>>>> would never halt?
>>>>>>>>>
>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>
>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>>> Why do you say it is false?
>>>>>>>>
>>>>>>>
>>>>>>> BIG QUESTION.
>>>>>>>
>>>>>>> Is it even a proper question?
>>>>>>>
>>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>>
>>>>>>> Or. is there an abort condition?
>>>>>>>
>>>>>>> Remember, any time you change any of the properties of the H that
>>>>>>> you built H^ from, any analysis from previous H^s need to be
>>>>>>> thrown out, or at least reconfirmed with the new H.
>>>>>>
>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>>>> input that its input never halts.
>>>>>>
>>>>>
>>>>> Yes, but then it doesn't answer and fails.
>>>>>
>>>>
>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>> input that its input never halts
>>>>
>>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS ABORTED
>>>>
>>>>
>>>
>>> Yes, But H can't do that aborting, because you just said that
>>> embedded_H didn't abort it.
>>>
>>
>> Do you think that it is possible to tell that an infinite loop will
>> never stop running without actually having to wait forever?
>>
>> 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]
>>
>>
>
> In some cases, yes.
>
> You seem to like your Herring Red.
>
> The question is not is it possible to answer some other halting
> questions, but if H can answer a particular one.

If it is the case that embedded_H does correctly determine its input
would never halt if it simulates 0 to ∞ steps of this input

and it makes this determination in a finite number of steps
and it aborts the simulation of this input

this does not cause the input to halt because an input must reach its
final state to halt

then embedded_H is correct when it transitions to Ĥ.qn because it is

ALWAYS CORRECT
ALWAYS CORRECT
ALWAYS CORRECT
ALWAYS CORRECT
ALWAYS CORRECT
ALWAYS CORRECT

For a halt decider to report that its input never
halts when it is the case that its input never halts.

For a halt decider to report that its input never
halts when it is the case that its input never halts.

For a halt decider to report that its input never
halts when it is the case that its input never halts.

For a halt decider to report that its input never
halts when it is the case that its input never halts.

For a halt decider to report that its input never
halts when it is the case that its input never halts.

>
> I will take this Red Herring as an admission that you can not provide
> any reason that two copies of a given algorithm can possible give two
> different answers for the same input.
>
> Any such reference will be marked as conceeded to be incorrect by
> failure to show evidence.
>
>
> FAIL.
>
>>
>>
>>> MAKE UP YOU MIND.
>>>
>>> H/embedded_H can only do ONE thing with a given input. PERIOD.
>>>
>>> If you disagree with that statement, PROVE YOUR POINT.
>>>
>>> Please show an ACTUAL TURING MACHINE, you know, with states and
>>> inputs, and an input tape, and show how it can give two different
>>> results.
>>>
>>> FAIR WARNING:
>>>
>>> IF NOT, ANY TIME you make a comment that implies a given algorithm
>>> doing two diferent thing, it will just be pointed out that you are
>>> violating a property of Computations and Turing Machine and are not
>>> working on the Halting Problem.
>>>
>>> FAIL!
>>
>>
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [computer scientist]

<FMQzJ.121927$IB7.65216@fx02.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.uzoreto.com!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!fx02.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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 247
Message-ID: <FMQzJ.121927$IB7.65216@fx02.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 23:29:28 -0500
X-Received-Bytes: 10296
 by: Richard Damon - Sat, 1 Jan 2022 04:29 UTC

On 12/31/21 11:19 PM, olcott wrote:
> On 12/31/2021 10:02 PM, Richard Damon wrote:
>> On 12/31/21 10:57 PM, olcott wrote:
>>> On 12/31/2021 9:50 PM, Richard Damon wrote:
>>>> On 12/31/21 10:39 PM, olcott wrote:
>>>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (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.
>>>>>>>>>>>>
>>>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>>>> points in my post.
>>>>>>>>>>>>
>>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called,
>>>>>>>>>>>> how does Ĥ determine that its input describes itself? You
>>>>>>>>>>>> claim this is done by string comparisons, but which strings
>>>>>>>>>>>> are being compared? The only string Ĥ has access to its
>>>>>>>>>>>> input string. What does it compare this string with?
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> So far I have not gotten to any point of closure on anything
>>>>>>>>>>> that I have said. I must insist on points of closure for
>>>>>>>>>>> continued dialogue.
>>>>>>>>>>>
>>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>> embedded_H would never halt?
>>>>>>>>>>
>>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>>
>>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>>>> Why do you say it is false?
>>>>>>>>>
>>>>>>>>
>>>>>>>> BIG QUESTION.
>>>>>>>>
>>>>>>>> Is it even a proper question?
>>>>>>>>
>>>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>>>
>>>>>>>> Or. is there an abort condition?
>>>>>>>>
>>>>>>>> Remember, any time you change any of the properties of the H
>>>>>>>> that you built H^ from, any analysis from previous H^s need to
>>>>>>>> be thrown out, or at least reconfirmed with the new H.
>>>>>>>
>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>>>>> input that its input never halts.
>>>>>>>
>>>>>>
>>>>>> Yes, but then it doesn't answer and fails.
>>>>>>
>>>>>
>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>>> input that its input never halts
>>>>>
>>>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS ABORTED
>>>>>
>>>>>
>>>>
>>>> Yes, But H can't do that aborting, because you just said that
>>>> embedded_H didn't abort it.
>>>>
>>>
>>> Do you think that it is possible to tell that an infinite loop will
>>> never stop running without actually having to wait forever?
>>>
>>> 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]
>>>
>>>
>>
>> In some cases, yes.
>>
>> You seem to like your Herring Red.
>>
>> The question is not is it possible to answer some other halting
>> questions, but if H can answer a particular one.
>
> If it is the case that embedded_H does correctly determine its input
> would never halt if it simulates 0 to ∞ steps of this input
>
> and it makes this determination in a finite number of steps
> and it aborts the simulation of this input
>

Which it can't as proven at:

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]

FAIL.

> this does not cause the input to halt because an input must reach its
> final state to halt

i.e that ACTUAL Machine must not reach a halting state, not an aborted
simulation, but H& does reach that state.

>
> then embedded_H is correct when it transitions to Ĥ.qn because it is
>
> ALWAYS CORRECT
> ALWAYS CORRECT
> ALWAYS CORRECT
> ALWAYS CORRECT
> ALWAYS CORRECT
> ALWAYS CORRECT

No. Because if embedded_H goes to H.qn then H^ goes to H^.qn and HALTS.

Thus H^ <H^> is a Halting Computaiton

>
> For a halt decider to report that its input never
> halts when it is the case that its input never halts.

But the input will halt (or at least the computation it represents).
Your decider made an error.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [computer scientist]

<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>

 copy mid

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

 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 22:48:32 -0600
Date: Fri, 31 Dec 2021 22:48:31 -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>
<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>
<sqo9o5$hh6$1@dont-email.me> <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
<sqob91$nom$1@dont-email.me> <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <FMQzJ.121927$IB7.65216@fx02.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
Lines: 175
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ShV1WSrSXc4dCtxVDmuMgyaQiViuwYy2Kpdtm3qcXW3UnpbEtC/dpLy946Vm++u3bXgzkJpoQfW/5Zv!btWT1n/PaG02+IeA9BSYqszddNs5SJ6MACFxQO6P0OgtigkwYdnd2nCU0nSImu3wLmCS+lGZlwC4!QQ==
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: 8629
 by: olcott - Sat, 1 Jan 2022 04:48 UTC

On 12/31/2021 10:29 PM, Richard Damon wrote:
> On 12/31/21 11:19 PM, olcott wrote:
>> On 12/31/2021 10:02 PM, Richard Damon wrote:
>>> On 12/31/21 10:57 PM, olcott wrote:
>>>> On 12/31/2021 9:50 PM, Richard Damon wrote:
>>>>> On 12/31/21 10:39 PM, olcott wrote:
>>>>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>>>>> points in my post.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called,
>>>>>>>>>>>>> how does Ĥ determine that its input describes itself? You
>>>>>>>>>>>>> claim this is done by string comparisons, but which strings
>>>>>>>>>>>>> are being compared? The only string Ĥ has access to its
>>>>>>>>>>>>> input string. What does it compare this string with?
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> So far I have not gotten to any point of closure on anything
>>>>>>>>>>>> that I have said. I must insist on points of closure for
>>>>>>>>>>>> continued dialogue.
>>>>>>>>>>>>
>>>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>> embedded_H would never halt?
>>>>>>>>>>>
>>>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>>>
>>>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>>>
>>>>>>>>>>> André
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>>>>> Why do you say it is false?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> BIG QUESTION.
>>>>>>>>>
>>>>>>>>> Is it even a proper question?
>>>>>>>>>
>>>>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>>>>
>>>>>>>>> Or. is there an abort condition?
>>>>>>>>>
>>>>>>>>> Remember, any time you change any of the properties of the H
>>>>>>>>> that you built H^ from, any analysis from previous H^s need to
>>>>>>>>> be thrown out, or at least reconfirmed with the new H.
>>>>>>>>
>>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of
>>>>>>>> its input that its input never halts.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, but then it doesn't answer and fails.
>>>>>>>
>>>>>>
>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>>>> input that its input never halts
>>>>>>
>>>>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS
>>>>>> ABORTED
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, But H can't do that aborting, because you just said that
>>>>> embedded_H didn't abort it.
>>>>>
>>>>
>>>> Do you think that it is possible to tell that an infinite loop will
>>>> never stop running without actually having to wait forever?
>>>>
>>>> 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]
>>>>
>>>>
>>>
>>> In some cases, yes.
>>>
>>> You seem to like your Herring Red.
>>>
>>> The question is not is it possible to answer some other halting
>>> questions, but if H can answer a particular one.
>>
>> If it is the case that embedded_H does correctly determine its input
>> would never halt if it simulates 0 to ∞ steps of this input
>>
>> and it makes this determination in a finite number of steps
>> and it aborts the simulation of this input
>>
>
> Which it can't as proven at:
>
> 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]
>
> FAIL.

That is irrelevant at this point in the dialogue.

>
>
>> this does not cause the input to halt because an input must reach its
>> final state to halt
>
> i.e that ACTUAL Machine must not reach a halting state, not an aborted
> simulation, but H& does reach that state.
>


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [computer scientist]

<H7RzJ.135613$QB1.48735@fx42.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 191
Message-ID: <H7RzJ.135613$QB1.48735@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 31 Dec 2021 23:54:02 -0500
X-Received-Bytes: 8838
 by: Richard Damon - Sat, 1 Jan 2022 04:54 UTC

On 12/31/21 11:48 PM, olcott wrote:
> On 12/31/2021 10:29 PM, Richard Damon wrote:
>> On 12/31/21 11:19 PM, olcott wrote:
>>> On 12/31/2021 10:02 PM, Richard Damon wrote:
>>>> On 12/31/21 10:57 PM, olcott wrote:
>>>>> On 12/31/2021 9:50 PM, Richard Damon wrote:
>>>>>> On 12/31/21 10:39 PM, olcott wrote:
>>>>>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>>>>>> points in my post.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called,
>>>>>>>>>>>>>> how does Ĥ determine that its input describes itself? You
>>>>>>>>>>>>>> claim this is done by string comparisons, but which
>>>>>>>>>>>>>> strings are being compared? The only string Ĥ has access
>>>>>>>>>>>>>> to its input string. What does it compare this string with?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> So far I have not gotten to any point of closure on
>>>>>>>>>>>>> anything that I have said. I must insist on points of
>>>>>>>>>>>>> closure for continued dialogue.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>> embedded_H would never halt?
>>>>>>>>>>>>
>>>>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>>>>
>>>>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>>>>
>>>>>>>>>>>> André
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>>>>>> Why do you say it is false?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> BIG QUESTION.
>>>>>>>>>>
>>>>>>>>>> Is it even a proper question?
>>>>>>>>>>
>>>>>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>>>>>
>>>>>>>>>> Or. is there an abort condition?
>>>>>>>>>>
>>>>>>>>>> Remember, any time you change any of the properties of the H
>>>>>>>>>> that you built H^ from, any analysis from previous H^s need to
>>>>>>>>>> be thrown out, or at least reconfirmed with the new H.
>>>>>>>>>
>>>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of
>>>>>>>>> its input that its input never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, but then it doesn't answer and fails.
>>>>>>>>
>>>>>>>
>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of its
>>>>>>> input that its input never halts
>>>>>>>
>>>>>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS
>>>>>>> ABORTED
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, But H can't do that aborting, because you just said that
>>>>>> embedded_H didn't abort it.
>>>>>>
>>>>>
>>>>> Do you think that it is possible to tell that an infinite loop will
>>>>> never stop running without actually having to wait forever?
>>>>>
>>>>> 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]
>>>>>
>>>>>
>>>>
>>>> In some cases, yes.
>>>>
>>>> You seem to like your Herring Red.
>>>>
>>>> The question is not is it possible to answer some other halting
>>>> questions, but if H can answer a particular one.
>>>
>>> If it is the case that embedded_H does correctly determine its input
>>> would never halt if it simulates 0 to ∞ steps of this input
>>>
>>> and it makes this determination in a finite number of steps
>>> and it aborts the simulation of this input
>>>
>>
>> Which it can't as proven at:
>>
>> 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]
>>
>> FAIL.
>
> That is irrelevant at this point in the dialogue.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [computer scientist]

<2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 31 Dec 2021 23:08:49 -0600
Date: Fri, 31 Dec 2021 23:08:47 -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,comp.ai.philosophy,sci.logic,sci.math
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@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>
<sqo9o5$hh6$1@dont-email.me> <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
<sqob91$nom$1@dont-email.me> <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
<H7RzJ.135613$QB1.48735@fx42.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <H7RzJ.135613$QB1.48735@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>
Lines: 190
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NwiDWxc2HZI1apGoGBmGgkaoTR/2JjDDuk3rfblqQHD1Ps+J5b0FQ6ynRwKqij9OeH7voLton7cfQHL!YcTXK8+SQcfboFqqb6IOJiV8PRHD0nSM1LILgSMsIIognILl1bT/AtCD/Vie1D4Sgx8R5W/3gtuY!Rg==
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: 9455
 by: olcott - Sat, 1 Jan 2022 05:08 UTC

On 12/31/2021 10:54 PM, Richard Damon wrote:
>
> On 12/31/21 11:48 PM, olcott wrote:
>> On 12/31/2021 10:29 PM, Richard Damon wrote:
>>> On 12/31/21 11:19 PM, olcott wrote:
>>>> On 12/31/2021 10:02 PM, Richard Damon wrote:
>>>>> On 12/31/21 10:57 PM, olcott wrote:
>>>>>> On 12/31/2021 9:50 PM, Richard Damon wrote:
>>>>>>> On 12/31/21 10:39 PM, olcott wrote:
>>>>>>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>>>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It would appear that you ignored (and cut) all the actual
>>>>>>>>>>>>>>> points in my post.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called,
>>>>>>>>>>>>>>> how does Ĥ determine that its input describes itself? You
>>>>>>>>>>>>>>> claim this is done by string comparisons, but which
>>>>>>>>>>>>>>> strings are being compared? The only string Ĥ has access
>>>>>>>>>>>>>>> to its input string. What does it compare this string with?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So far I have not gotten to any point of closure on
>>>>>>>>>>>>>> anything that I have said. I must insist on points of
>>>>>>>>>>>>>> closure for continued dialogue.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>> embedded_H would never halt?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>>>>>
>>>>>>>>>>>>> André
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>>>>>>> Why do you say it is false?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> BIG QUESTION.
>>>>>>>>>>>
>>>>>>>>>>> Is it even a proper question?
>>>>>>>>>>>
>>>>>>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>>>>>>
>>>>>>>>>>> Or. is there an abort condition?
>>>>>>>>>>>
>>>>>>>>>>> Remember, any time you change any of the properties of the H
>>>>>>>>>>> that you built H^ from, any analysis from previous H^s need
>>>>>>>>>>> to be thrown out, or at least reconfirmed with the new H.
>>>>>>>>>>
>>>>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of
>>>>>>>>>> its input that its input never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, but then it doesn't answer and fails.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of
>>>>>>>> its input that its input never halts
>>>>>>>>
>>>>>>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS
>>>>>>>> ABORTED
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yes, But H can't do that aborting, because you just said that
>>>>>>> embedded_H didn't abort it.
>>>>>>>
>>>>>>
>>>>>> Do you think that it is possible to tell that an infinite loop
>>>>>> will never stop running without actually having to wait forever?
>>>>>>
>>>>>> 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]
>>>>>>
>>>>>>
>>>>>
>>>>> In some cases, yes.
>>>>>
>>>>> You seem to like your Herring Red.
>>>>>
>>>>> The question is not is it possible to answer some other halting
>>>>> questions, but if H can answer a particular one.
>>>>
>>>> If it is the case that embedded_H does correctly determine its input
>>>> would never halt if it simulates 0 to ∞ steps of this input
>>>>
>>>> and it makes this determination in a finite number of steps
>>>> and it aborts the simulation of this input
>>>>
>>>
>>> Which it can't as proven at:
>>>
>>> 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]
>>>
>>> FAIL.
>>
>> That is irrelevant at this point in the dialogue.
>
>
> WHY?
>
> The fact that you just claim, with NO proof to have the Unicorn Halt
> Decider to do your bidding.
>
> You logic is UNSOUND, as are you.
>>
>>>
>>>
>>>> this does not cause the input to halt because an input must reach
>>>> its final state to halt
>>>
>>> i.e that ACTUAL Machine must not reach a halting state, not an
>>> aborted simulation, but H& does reach that state.
>>>
>>
>> Your words are incoherent.
>>
>> When we hypothesize that embedded_H can determine that input to
>> embedded_H never reaches its final state in 0 to ∞ steps of simulation
>> and it can do this in a finite number of steps
>
> You Hypothesize the impossible.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [computer scientist]

<gURzJ.127184$lz3.69252@fx34.iad>

 copy mid

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

 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!fx34.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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>
<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> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
<H7RzJ.135613$QB1.48735@fx42.iad>
<2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 217
Message-ID: <gURzJ.127184$lz3.69252@fx34.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 1 Jan 2022 00:45:50 -0500
X-Received-Bytes: 10045
X-Original-Bytes: 9912
 by: Richard Damon - Sat, 1 Jan 2022 05:45 UTC

On 1/1/22 12:08 AM, olcott wrote:
> On 12/31/2021 10:54 PM, Richard Damon wrote:
>>
>> On 12/31/21 11:48 PM, olcott wrote:
>>> On 12/31/2021 10:29 PM, Richard Damon wrote:
>>>> On 12/31/21 11:19 PM, olcott wrote:
>>>>> On 12/31/2021 10:02 PM, Richard Damon wrote:
>>>>>> On 12/31/21 10:57 PM, olcott wrote:
>>>>>>> On 12/31/2021 9:50 PM, Richard Damon wrote:
>>>>>>>> On 12/31/21 10:39 PM, olcott wrote:
>>>>>>>>> On 12/31/2021 9:10 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 12/31/21 9:50 PM, olcott wrote:
>>>>>>>>>>> On 12/31/2021 8:39 PM, Richard Damon wrote:
>>>>>>>>>>>> On 12/31/21 8:50 PM, olcott wrote:
>>>>>>>>>>>>> On 12/31/2021 7:37 PM, André G. Isaak wrote:
>>>>>>>>>>>>>> On 2021-12-31 18:17, olcott wrote:
>>>>>>>>>>>>>>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>> On 2021-12-31 17:05, 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.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (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.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It would appear that you ignored (and cut) all the
>>>>>>>>>>>>>>>> actual points in my post.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>> called, how does Ĥ determine that its input describes
>>>>>>>>>>>>>>>> itself? You claim this is done by string comparisons,
>>>>>>>>>>>>>>>> but which strings are being compared? The only string Ĥ
>>>>>>>>>>>>>>>> has access to its input string. What does it compare
>>>>>>>>>>>>>>>> this string with?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> So far I have not gotten to any point of closure on
>>>>>>>>>>>>>>> anything that I have said. I must insist on points of
>>>>>>>>>>>>>>> closure for continued dialogue.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>>>>>>>>> embedded_H would never halt?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Of course I don't, since that claim is simply false.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Now why don't you actually answer the question I asked?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> André
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> We must stay on this point until we have mutual agreement.
>>>>>>>>>>>>> Why do you say it is false?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> BIG QUESTION.
>>>>>>>>>>>>
>>>>>>>>>>>> Is it even a proper question?
>>>>>>>>>>>>
>>>>>>>>>>>> Is it a fact that embedded_H just does a pure simulation?
>>>>>>>>>>>>
>>>>>>>>>>>> Or. is there an abort condition?
>>>>>>>>>>>>
>>>>>>>>>>>> Remember, any time you change any of the properties of the H
>>>>>>>>>>>> that you built H^ from, any analysis from previous H^s need
>>>>>>>>>>>> to be thrown out, or at least reconfirmed with the new H.
>>>>>>>>>>>
>>>>>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of
>>>>>>>>>>> its input that its input never halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, but then it doesn't answer and fails.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is the case that when embedded_H simulates 0 to ∞ steps of
>>>>>>>>> its input that its input never halts
>>>>>>>>>
>>>>>>>>> CONCLUSIVELY PROVING THAT THIS INPUT NEVER HALTS EVEN IF IT IS
>>>>>>>>> ABORTED
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, But H can't do that aborting, because you just said that
>>>>>>>> embedded_H didn't abort it.
>>>>>>>>
>>>>>>>
>>>>>>> Do you think that it is possible to tell that an infinite loop
>>>>>>> will never stop running without actually having to wait forever?
>>>>>>>
>>>>>>> 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]
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> In some cases, yes.
>>>>>>
>>>>>> You seem to like your Herring Red.
>>>>>>
>>>>>> The question is not is it possible to answer some other halting
>>>>>> questions, but if H can answer a particular one.
>>>>>
>>>>> If it is the case that embedded_H does correctly determine its
>>>>> input would never halt if it simulates 0 to ∞ steps of this input
>>>>>
>>>>> and it makes this determination in a finite number of steps
>>>>> and it aborts the simulation of this input
>>>>>
>>>>
>>>> Which it can't as proven at:
>>>>
>>>> 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]
>>>>
>>>> FAIL.
>>>
>>> That is irrelevant at this point in the dialogue.
>>
>>
>> WHY?
>>
>> The fact that you just claim, with NO proof to have the Unicorn Halt
>> Decider to do your bidding.
>>
>> You logic is UNSOUND, as are you.
>>>
>>>>
>>>>
>>>>> this does not cause the input to halt because an input must reach
>>>>> its final state to halt
>>>>
>>>> i.e that ACTUAL Machine must not reach a halting state, not an
>>>> aborted simulation, but H& does reach that state.
>>>>
>>>
>>> Your words are incoherent.
>>>
>>> When we hypothesize that embedded_H can determine that input to
>>> embedded_H never reaches its final state in 0 to ∞ steps of
>>> simulation and it can do this in a finite number of steps
>>
>> You Hypothesize the impossible.
>
>
> This is the only point that I am willing to discuss with anyone until
> mutual agreement is achieved.


Click here to read the complete article
Re: Concise refutation of halting problem proofs V42 [computer scientist]

<fKudnQVO8PdOcVL8nZ2dnUU7-Y3NnZ2d@giganews.com>

 copy mid

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

 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 23:55:31 -0600
Date: Fri, 31 Dec 2021 23:55: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 [computer
scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@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>
<sqo9o5$hh6$1@dont-email.me> <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
<sqob91$nom$1@dont-email.me> <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
<H7RzJ.135613$QB1.48735@fx42.iad>
<2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>
<gURzJ.127184$lz3.69252@fx34.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <gURzJ.127184$lz3.69252@fx34.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fKudnQVO8PdOcVL8nZ2dnUU7-Y3NnZ2d@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-3Hw5wNj2xQ7csWz2tKtWPlDE/bjSOzxGzt67yE6+1eSasBmqmNy9oMOyXjbYvI7spB06/dz7BEcfApT!Cq7A/GFABnHhJaZ4stSyIH/XN47QuBLSXqJK2N9jP+/eNkeOJCphvSC8r/V0xN/+0twp2fIFrouj!ZQ==
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: 3691
 by: olcott - Sat, 1 Jan 2022 05:55 UTC

On 12/31/2021 11:45 PM, Richard Damon wrote:
> On 1/1/22 12:08 AM, olcott wrote:
>> On 12/31/2021 10:54 PM, Richard Damon wrote:
>>>
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>

I am only willing to discuss point (b) until after we achieve mutual
agreement.

(b) The pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never halt.
and embedded_H detects this in a finite number of steps then it is
correct for embedded_H to abort its simulation and transition to Ĥ.qn

As soon as we have perfect mutual agreement then we can move on to
another point.

I will keep going over this point however many times until mutual
agreement is achieved.

If you change the subject I will erase that change and come back to this
point over and over and over.

--
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]

<qlYzJ.152358$Ql5.84177@fx39.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.uzoreto.com!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.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 [computer scientist]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com> <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> <sqo9o5$hh6$1@dont-email.me> <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me> <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com> <69PzJ.214781$3q9.35099@fx47.iad> <FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com> <zCPzJ.214782$3q9.38321@fx47.iad> <DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com> <5cQzJ.254762$IW4.19763@fx48.iad> <MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com> <mnQzJ.181779$6a3.8310@fx41.iad> <Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com> <FMQzJ.121927$IB7.65216@fx02.iad> <raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com> <H7RzJ.135613$QB1.48735@fx42.iad> <2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com> <gURzJ.127184$lz3.69252@fx34.iad> <fKudnQVO8PdOcVL8nZ2dnUU7-Y3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <fKudnQVO8PdOcVL8nZ2dnUU7-Y3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 59
Message-ID: <qlYzJ.152358$Ql5.84177@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: Sat, 1 Jan 2022 08:06:32 -0500
X-Received-Bytes: 4055
 by: Richard Damon - Sat, 1 Jan 2022 13:06 UTC

On 1/1/22 12:55 AM, olcott wrote:
> On 12/31/2021 11:45 PM, Richard Damon wrote:
>> On 1/1/22 12:08 AM, olcott wrote:
>>> On 12/31/2021 10:54 PM, Richard Damon wrote:
>>>>
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>
> I am only willing to discuss point (b) until after we achieve mutual
> agreement.

Because you don't have an answer for the rest of the problem, so you
insist that you won't go farther until you get people to agree to a
FALSEHOOD?

>
> (b) The pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never halt.
> and embedded_H detects this in a finite number of steps then it is
> correct for embedded_H to abort its simulation and transition to Ĥ.qn

Impossible, as previously proven:

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]

>
> As soon as we have perfect mutual agreement then we can move on to
> another point.
>

Then you have a long wait, as you are stating a FALSEHOOD. The thing you
say is possible is NOT>

> I will keep going over this point however many times until mutual
> agreement is achieved.

Then you will die being known as a LIAR.

>
> If you change the subject I will erase that change and come back to this
> point over and over and over.
>

I Have answered you claim. If proving it is impossible is not something
you consider 'on topic', then you are just being dishonest.

FAIL.

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

<tNmdnQsIfsMVBU38nZ2dnUU7-RfNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 01 Jan 2022 12:08:08 -0600
Date: Sat, 1 Jan 2022 12:08:08 -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>
<sqnutn$lbd$1@dont-email.me> <s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com>
<sqo3vg$lun$1@dont-email.me> <FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com>
<sqo9o5$hh6$1@dont-email.me> <coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com>
<sqob91$nom$1@dont-email.me> <vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
<H7RzJ.135613$QB1.48735@fx42.iad>
<2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>
<gURzJ.127184$lz3.69252@fx34.iad>
<fKudnQVO8PdOcVL8nZ2dnUU7-Y3NnZ2d@giganews.com>
<qlYzJ.152358$Ql5.84177@fx39.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <qlYzJ.152358$Ql5.84177@fx39.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <tNmdnQsIfsMVBU38nZ2dnUU7-RfNnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-GBQNyHQdw1wrUKQUbVUnJBEZc9j3/PpYycT1vZBOQPaWpxTIbfsXyu6IyWxmiDfhYHe2/oNBO9jRvl4!E8vVsGNqWIC47N7CLaDQxTRGfY6dMXs4H1Ab4OhS7qXhZEskzfGeokUR1WcsmV0cq6BGnubPio3s!4w==
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: 3983
 by: olcott - Sat, 1 Jan 2022 18:08 UTC

On 1/1/2022 7:06 AM, Richard Damon wrote:
> On 1/1/22 12:55 AM, olcott wrote:
>> On 12/31/2021 11:45 PM, Richard Damon wrote:
>>> On 1/1/22 12:08 AM, olcott wrote:
>>>> On 12/31/2021 10:54 PM, Richard Damon wrote:
>>>>>
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>
>> I am only willing to discuss point (b) until after we achieve mutual
>> agreement.
>
> Because you don't have an answer for the rest of the problem, so you
> insist that you won't go farther until you get people to agree to a
> FALSEHOOD?
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

You already agreed with that if a UTM is at Ĥ.qx such that the
simulation of the input is never aborted that Ĥ applied to ⟨Ĥ⟩ never
stops running.

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

Linz says that if a machine stops running yet does not reach its final
state that this machine did not 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

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

<jF1AJ.179188$Wkjc.129846@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx35.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.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>
<s_2dnY4DMJt2FlL8nZ2dnUU7-eednZ2d@giganews.com> <sqo3vg$lun$1@dont-email.me>
<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
<vfCdndIh1NrILlL8nZ2dnUU7-RudnZ2d@giganews.com>
<69PzJ.214781$3q9.35099@fx47.iad>
<FJ6dnZA9pawUXFL8nZ2dnUU7-bHNnZ2d@giganews.com>
<zCPzJ.214782$3q9.38321@fx47.iad>
<DoSdnYuLArBBUVL8nZ2dnUU7-WfNnZ2d@giganews.com>
<5cQzJ.254762$IW4.19763@fx48.iad>
<MOednVnaAIyMTFL8nZ2dnUU7-IHNnZ2d@giganews.com>
<mnQzJ.181779$6a3.8310@fx41.iad>
<Irqdnbiiy4TbS1L8nZ2dnUU7-Q_NnZ2d@giganews.com>
<FMQzJ.121927$IB7.65216@fx02.iad>
<raWdnZqY8Lu9QFL8nZ2dnUU7-QPNnZ2d@giganews.com>
<H7RzJ.135613$QB1.48735@fx42.iad>
<2P-dnaG0FJN8fFL8nZ2dnUU7-avNnZ2d@giganews.com>
<gURzJ.127184$lz3.69252@fx34.iad>
<fKudnQVO8PdOcVL8nZ2dnUU7-Y3NnZ2d@giganews.com>
<qlYzJ.152358$Ql5.84177@fx39.iad>
<tNmdnQsIfsMVBU38nZ2dnUU7-RfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tNmdnQsIfsMVBU38nZ2dnUU7-RfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 68
Message-ID: <jF1AJ.179188$Wkjc.129846@fx35.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 1 Jan 2022 14:09:06 -0500
X-Received-Bytes: 4490
 by: Richard Damon - Sat, 1 Jan 2022 19:09 UTC

On 1/1/22 1:08 PM, olcott wrote:
> On 1/1/2022 7:06 AM, Richard Damon wrote:
>> On 1/1/22 12:55 AM, olcott wrote:
>>> On 12/31/2021 11:45 PM, Richard Damon wrote:
>>>> On 1/1/22 12:08 AM, olcott wrote:
>>>>> On 12/31/2021 10:54 PM, Richard Damon wrote:
>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>>
>>>
>>> I am only willing to discuss point (b) until after we achieve mutual
>>> agreement.
>>
>> Because you don't have an answer for the rest of the problem, so you
>> insist that you won't go farther until you get people to agree to a
>> FALSEHOOD?
>>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> You already agreed with that if a UTM is at Ĥ.qx such that the
> simulation of the input is never aborted that Ĥ applied to ⟨Ĥ⟩ never
> stops running.
>

Yes, if H IS a UTM, then H^ <H^> will never halt, so is wrong.

But ONLY if H is a UTM, as this only applies to an H^ built on an H that
is a UTM, if H^ is built on an H that acts differently, that H^ can act
differently.

> computation that halts
>  … the Turing machine will halt whenever it enters a final state
> (Linz:1990:234)
>
> Linz says that if a machine stops running yet does not reach its final
> state that this machine did not halt.
>

A Machine NEVER stops running except by reaching its final state, so you
statement doesn't make sense.

If you mean that a simulation of a machine is aborted, that shows nothing.

You still haven't answered about why you are insisting on us accepting
your falsehood.

You 'proof' seems to be that if and only if we accept your false premise
can you 'prove' your claim about your Halt Decider, as if you had a
better arguement you would go to it.

Since that premise IS false, that means you claim of your Halt Decider
is also false.

QED.

Re: Concise refutation of halting problem proofs V42 [honest dialogue]

<sqsikv$6f8$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Concise refutation of halting problem proofs V42 [honest
dialogue]
Followup-To: comp.theory
Date: Sun, 2 Jan 2022 10:07:58 -0600
Organization: A noiseless patient Spider
Lines: 80
Message-ID: <sqsikv$6f8$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> <sqo3vg$lun$1@dont-email.me>
<FeydnXVBhLMqB1L8nZ2dnUU7-cvNnZ2d@giganews.com> <sqo9o5$hh6$1@dont-email.me>
<coadnR-r2Yc4NlL8nZ2dnUU7-S2dnZ2d@giganews.com> <sqob91$nom$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 2 Jan 2022 16:07:59 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="fa97d2963b3ba2faa0884a4dba2ac18f";
logging-data="6632"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/4cJklh43APF5VuJ6Q2Xuu"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Cancel-Lock: sha1:lEWAiC+bJJ98sNyToa9I2Mgf3m4=
In-Reply-To: <sqob91$nom$1@dont-email.me>
Content-Language: en-US
 by: olcott - Sun, 2 Jan 2022 16:07 UTC

On 12/31/2021 7:37 PM, André G. Isaak wrote:
> On 2021-12-31 18:17, olcott wrote:
>> On 12/31/2021 7:11 PM, André G. Isaak wrote:
>>> On 2021-12-31 17:05, 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.
>>>>
>>>> (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.
>>>
>>> It would appear that you ignored (and cut) all the actual points in
>>> my post.
>>>
>>> Why don't we simplify things a bit. When Ĥ ⟨Ĥ⟩ is called, how does Ĥ
>>> determine that its input describes itself? You claim this is done by
>>> string comparisons, but which strings are being compared? The only
>>> string Ĥ has access to its input string. What does it compare this
>>> string with?
>>>
>>> André
>>>
>>
>> So far I have not gotten to any point of closure on anything that I
>> have said. I must insist on points of closure for continued dialogue.
>>
>> Do you agree that the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would
>> never halt?
>
> Of course I don't, since that claim is simply false.
>
> Now why don't you actually answer the question I asked?
>
> André
>

For simplicity we will refer to the copy of Linz H at Ĥ.qx embedded_H.

Simplified syntax adapted from bottom of page 319:
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

If embedded_H would never stop simulating its input ⟨Ĥ⟩ ⟨Ĥ⟩
this input would never reach a final state and stop running.

These steps would keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

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

That you disagree with self-evident truth proves that you do not want
any honest dialogue.

--
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