Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Vulcans believe peace should not depend on force. -- Amanda, "Journey to Babel", stardate 3842.3


devel / comp.theory / Re: Concise refutation of halting problem proofs V42 [compute the mapping]

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 [where people get stuck]

<EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 29 Dec 2021 18:43:51 -0600
Date: Wed, 29 Dec 2021 18:43:50 -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 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<sqi88u$ai9$1@dont-email.me> <lYWdnVzlccb6XFH8nZ2dnUU7-ePNnZ2d@giganews.com>
<sqihk3$e5u$1@dont-email.me> <qpSdneigrPdXQFH8nZ2dnUU7-TGdnZ2d@giganews.com>
<sqio4l$m2k$1@dont-email.me> <hLydnR3Op_pEe1H8nZ2dnUU7-YfNnZ2d@giganews.com>
<sqiqc6$4n5$1@dont-email.me> <sqirr2$brd$1@dont-email.me>
<z5OdneTRlcI4alH8nZ2dnUU7-IfNnZ2d@giganews.com> <sqitub$mqc$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqitub$mqc$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com>
Lines: 113
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VFRWlYGi+sCNrZz1x7mAyvvaMZOlXkL2yw2tTUKkK0Sx/XQPSpzHAu+o4kOfR1sNsnpEF28B8fRLN94!L0ENFm7nhMYW93V4Of3xSZ43j9oyQY/MeDTKS9AOxEC3OdWVm9NmK5owN/ve5VPDvjaiEr4iNA7M!FA==
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: 6032
 by: olcott - Thu, 30 Dec 2021 00:43 UTC

On 12/29/2021 6:19 PM, André G. Isaak wrote:
> On 2021-12-29 17:04, olcott wrote:
>> On 12/29/2021 5:43 PM, André G. Isaak wrote:
>>> On 2021-12-29 16:18, André G. Isaak wrote:
>>>> On 2021-12-29 15:53, olcott wrote:
>>>>> On 12/29/2021 4:40 PM, André G. Isaak wrote:
>>>>>> On 2021-12-29 15:14, olcott wrote:
>>>
>>>>>>> When Linz says
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>> He is wrong.
>>>>>>
>>>>>> No, he is not.
>>>>>>
>>>>>
>>>>> There is only one computation above that is actually Ĥ and that
>>>>> computation includes embedded_H at Ĥ.qx.
>>>>>
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is is not Ĥ itself.
>>>>
>>>> Where does Linz claim that ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ itself? He doesn't. Nothing
>>>> in the above even remotely implies that, so I have no clue what your
>>>> objection here actually is. You need to learn what this notation
>>>> actually *means*.
>>>
>>> Just to clarify this, you need to understand what a condition
>>> actually *means*.
>>>
>>> When we say:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff Ĥ applied to ⟨Ĥ⟩ halts
>>>
>>> the 'iff Ĥ applied to ⟨Ĥ⟩ halts' simply specifies what condition must
>>> be met for Ĥ.q0 ⟨Ĥ⟩ to transition to Ĥ.qy ∞. It says nothing about
>>> how the underlying algorithm works. In particular, it doesn't require
>>> that Ĥ ever gets applied to ⟨Ĥ⟩ at some point in the computation.
>>>
>>> Consider the following simple TM:
>>>
>>> M.q0 w ⊢* M.qy iff 2 + 3 = 5.
>>>
>>> That describes a TM which accepts *every* input string it is given
>>> because the condition which has been given is always true.
>>>
>>> This condition does *not* mean that an implementation of M has to
>>> actually add numbers or compare two numbers. Said machine can simply
>>> transition directly from its initial state to its final accepting
>>> state without doing anything at all.
>>>
>>> The condition simply states some fact which must be true for the
>>> machine to transition to a particular state. The TM may or may not
>>> directly reference the condition in its algorithm. The design just
>>> needs to ensure that where it gets to is *consistent* with that
>>> condition.
>>>
>>> André
>>>
>>
>> That pulls the focus of attention away from the point where is needs
>> to be thus making what I am saying impossible to understand.
>>
>> The actual criterion measure is that embedded_H correctly transitions
>> to Ĥ.qn iff any recursive instance of the simulating halt decider of
>> embedded_H ever needs abort the simulation of its input to prevent the
>> infinite execution of Ĥ applied to ⟨Ĥ⟩
>>
>> This is the same thing as saying embedded_H correctly transitions to
>> Ĥ.qn iff replacing embedded_H at Ĥ.qx with a UTM would cause Ĥ applied
>> to ⟨Ĥ⟩ to never halt.
>
> The conditions which Ben supplied don't even remotely resemble anything
> you've written above.
>

I am only using Ben's notational conventions. When H bases its halt
status decision on the UTM simulation of its input then embedded_H
necessarily must do the same because it is only a copy of H.

Do don't seem to be able to understand this.

> His conditions makes no mention of 'replacing' embedded_H with a UTM. It
> makes no mention of embedded_H needing to abort a simulation, let alone
> 'any recursive instance of embedded_H'.
>
> You've invented an entirely new condition which bears no resemblance
> whatsoever to the condition which defines a halt decider, and which is
> too incoherently stated to even evaluate.
>

THIS IS REALLY NOT THAT DIFFICULT:
Because it is known that the UTM simulation of a machine is
computationally equivalent to the direct execution of this same machine
H can always form its halt status decision on the basis of behavior of
the UTM simulation of its inputs.

> Linz's conditions are valid.
> Ben's conditions are valid (though the addition of a UTM is pointless).
> Your conditions are completely invalid.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [where people get stuck]

<sqj0g6$33a$1@dont-email.me>

 copy mid

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

 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 [where people
get stuck]
Date: Wed, 29 Dec 2021 18:03:01 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 120
Message-ID: <sqj0g6$33a$1@dont-email.me>
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<sqi88u$ai9$1@dont-email.me> <lYWdnVzlccb6XFH8nZ2dnUU7-ePNnZ2d@giganews.com>
<sqihk3$e5u$1@dont-email.me> <qpSdneigrPdXQFH8nZ2dnUU7-TGdnZ2d@giganews.com>
<sqio4l$m2k$1@dont-email.me> <hLydnR3Op_pEe1H8nZ2dnUU7-YfNnZ2d@giganews.com>
<sqiqc6$4n5$1@dont-email.me> <sqirr2$brd$1@dont-email.me>
<z5OdneTRlcI4alH8nZ2dnUU7-IfNnZ2d@giganews.com> <sqitub$mqc$1@dont-email.me>
<EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 30 Dec 2021 01:03:03 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="281e34967abc652e32513cf7d24af717";
logging-data="3178"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18KpGe+c2l6opyA+fCfdIiP"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:abDILk6Q/QhPEJrPVF+lnhe9LCA=
In-Reply-To: <EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 30 Dec 2021 01:03 UTC

On 2021-12-29 17:43, olcott wrote:
> On 12/29/2021 6:19 PM, André G. Isaak wrote:
>> On 2021-12-29 17:04, olcott wrote:
>>> On 12/29/2021 5:43 PM, André G. Isaak wrote:
>>>> On 2021-12-29 16:18, André G. Isaak wrote:
>>>>> On 2021-12-29 15:53, olcott wrote:
>>>>>> On 12/29/2021 4:40 PM, André G. Isaak wrote:
>>>>>>> On 2021-12-29 15:14, olcott wrote:
>>>>
>>>>>>>> When Linz says
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>> He is wrong.
>>>>>>>
>>>>>>> No, he is not.
>>>>>>>
>>>>>>
>>>>>> There is only one computation above that is actually Ĥ and that
>>>>>> computation includes embedded_H at Ĥ.qx.
>>>>>>
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is is not Ĥ itself.
>>>>>
>>>>> Where does Linz claim that ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ itself? He doesn't. Nothing
>>>>> in the above even remotely implies that, so I have no clue what
>>>>> your objection here actually is. You need to learn what this
>>>>> notation actually *means*.
>>>>
>>>> Just to clarify this, you need to understand what a condition
>>>> actually *means*.
>>>>
>>>> When we say:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff Ĥ applied to ⟨Ĥ⟩ halts
>>>>
>>>> the 'iff Ĥ applied to ⟨Ĥ⟩ halts' simply specifies what condition
>>>> must be met for Ĥ.q0 ⟨Ĥ⟩ to transition to Ĥ.qy ∞. It says nothing
>>>> about how the underlying algorithm works. In particular, it doesn't
>>>> require that Ĥ ever gets applied to ⟨Ĥ⟩ at some point in the
>>>> computation.
>>>>
>>>> Consider the following simple TM:
>>>>
>>>> M.q0 w ⊢* M.qy iff 2 + 3 = 5.
>>>>
>>>> That describes a TM which accepts *every* input string it is given
>>>> because the condition which has been given is always true.
>>>>
>>>> This condition does *not* mean that an implementation of M has to
>>>> actually add numbers or compare two numbers. Said machine can simply
>>>> transition directly from its initial state to its final accepting
>>>> state without doing anything at all.
>>>>
>>>> The condition simply states some fact which must be true for the
>>>> machine to transition to a particular state. The TM may or may not
>>>> directly reference the condition in its algorithm. The design just
>>>> needs to ensure that where it gets to is *consistent* with that
>>>> condition.
>>>>
>>>> André
>>>>
>>>
>>> That pulls the focus of attention away from the point where is needs
>>> to be thus making what I am saying impossible to understand.
>>>
>>> The actual criterion measure is that embedded_H correctly transitions
>>> to Ĥ.qn iff any recursive instance of the simulating halt decider of
>>> embedded_H ever needs abort the simulation of its input to prevent
>>> the infinite execution of Ĥ applied to ⟨Ĥ⟩
>>>
>>> This is the same thing as saying embedded_H correctly transitions to
>>> Ĥ.qn iff replacing embedded_H at Ĥ.qx with a UTM would cause Ĥ
>>> applied to ⟨Ĥ⟩ to never halt.
>>
>> The conditions which Ben supplied don't even remotely resemble
>> anything you've written above.
>>
>
> I am only using Ben's notational conventions. When H bases its halt
> status decision on the UTM simulation of its input then embedded_H
> necessarily must do the same because it is only a copy of H.
>
> Do don't seem to be able to understand this.
>
>> His conditions makes no mention of 'replacing' embedded_H with a UTM.
>> It makes no mention of embedded_H needing to abort a simulation, let
>> alone 'any recursive instance of embedded_H'.
>>
>> You've invented an entirely new condition which bears no resemblance
>> whatsoever to the condition which defines a halt decider, and which is
>> too incoherently stated to even evaluate.
>>
>
> THIS IS REALLY NOT THAT DIFFICULT:
> Because it is known that the UTM simulation of a machine is
> computationally equivalent to the direct execution of this same machine
> H can always form its halt status decision on the basis of behavior of
> the UTM simulation of its inputs.

Basing a decision on the behaviour of a UTM simulation is not the same
thing as *replacing* your embedded_H with a UTM. Not even remotely. A
UTM does *not* report on whether its input halts.

Consider Ben's example of a Parity Decider (PD).

If your Ĥ works by 'replacing' the embedded_H with a UTM, and I run the
computation Ĥ wPD 3 it would transition to a final rejecting state, not
because PD applied to 3 doesn't halt but because 3 is not an even number.

A UTM returns an answer corresponding to the answer to the computation
which is passed to it as an input (assuming that it halts at all).
That's not the answer you want.

André

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

Re: Concise refutation of halting problem proofs V42 [where people get stuck]

<HqadnT5safjQmlD8nZ2dnUU7-SmdnZ2d@giganews.com>

 copy mid

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

 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: Wed, 29 Dec 2021 19:11:41 -0600
Date: Wed, 29 Dec 2021 19:11:41 -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 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<sqi88u$ai9$1@dont-email.me> <lYWdnVzlccb6XFH8nZ2dnUU7-ePNnZ2d@giganews.com>
<sqihk3$e5u$1@dont-email.me> <qpSdneigrPdXQFH8nZ2dnUU7-TGdnZ2d@giganews.com>
<sqio4l$m2k$1@dont-email.me> <hLydnR3Op_pEe1H8nZ2dnUU7-YfNnZ2d@giganews.com>
<sqiqc6$4n5$1@dont-email.me> <sqirr2$brd$1@dont-email.me>
<z5OdneTRlcI4alH8nZ2dnUU7-IfNnZ2d@giganews.com> <sqitub$mqc$1@dont-email.me>
<EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com> <sqj0g6$33a$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sqj0g6$33a$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <HqadnT5safjQmlD8nZ2dnUU7-SmdnZ2d@giganews.com>
Lines: 131
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fWZNDhSeEzr7PcV56ZTedQLJ4QA7QQtIB4fyjQo3vJnqGAe+Fmk5hjHsMaWPG/KkKqDuCuBQ8qEhj0w!t9slAOE9l8n8jneYBrWX20mCGH4WoGgvVL3YbaAthQ6FAc4PadE5xth/c6GYOT6ogV84I3fCq2U7!aw==
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: 7082
 by: olcott - Thu, 30 Dec 2021 01:11 UTC

On 12/29/2021 7:03 PM, André G. Isaak wrote:
> On 2021-12-29 17:43, olcott wrote:
>> On 12/29/2021 6:19 PM, André G. Isaak wrote:
>>> On 2021-12-29 17:04, olcott wrote:
>>>> On 12/29/2021 5:43 PM, André G. Isaak wrote:
>>>>> On 2021-12-29 16:18, André G. Isaak wrote:
>>>>>> On 2021-12-29 15:53, olcott wrote:
>>>>>>> On 12/29/2021 4:40 PM, André G. Isaak wrote:
>>>>>>>> On 2021-12-29 15:14, olcott wrote:
>>>>>
>>>>>>>>> When Linz says
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>>> He is wrong.
>>>>>>>>
>>>>>>>> No, he is not.
>>>>>>>>
>>>>>>>
>>>>>>> There is only one computation above that is actually Ĥ and that
>>>>>>> computation includes embedded_H at Ĥ.qx.
>>>>>>>
>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is is not Ĥ itself.
>>>>>>
>>>>>> Where does Linz claim that ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ itself? He doesn't.
>>>>>> Nothing in the above even remotely implies that, so I have no clue
>>>>>> what your objection here actually is. You need to learn what this
>>>>>> notation actually *means*.
>>>>>
>>>>> Just to clarify this, you need to understand what a condition
>>>>> actually *means*.
>>>>>
>>>>> When we say:
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff Ĥ applied to ⟨Ĥ⟩ halts
>>>>>
>>>>> the 'iff Ĥ applied to ⟨Ĥ⟩ halts' simply specifies what condition
>>>>> must be met for Ĥ.q0 ⟨Ĥ⟩ to transition to Ĥ.qy ∞. It says nothing
>>>>> about how the underlying algorithm works. In particular, it doesn't
>>>>> require that Ĥ ever gets applied to ⟨Ĥ⟩ at some point in the
>>>>> computation.
>>>>>
>>>>> Consider the following simple TM:
>>>>>
>>>>> M.q0 w ⊢* M.qy iff 2 + 3 = 5.
>>>>>
>>>>> That describes a TM which accepts *every* input string it is given
>>>>> because the condition which has been given is always true.
>>>>>
>>>>> This condition does *not* mean that an implementation of M has to
>>>>> actually add numbers or compare two numbers. Said machine can
>>>>> simply transition directly from its initial state to its final
>>>>> accepting state without doing anything at all.
>>>>>
>>>>> The condition simply states some fact which must be true for the
>>>>> machine to transition to a particular state. The TM may or may not
>>>>> directly reference the condition in its algorithm. The design just
>>>>> needs to ensure that where it gets to is *consistent* with that
>>>>> condition.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> That pulls the focus of attention away from the point where is needs
>>>> to be thus making what I am saying impossible to understand.
>>>>
>>>> The actual criterion measure is that embedded_H correctly
>>>> transitions to Ĥ.qn iff any recursive instance of the simulating
>>>> halt decider of embedded_H ever needs abort the simulation of its
>>>> input to prevent the infinite execution of Ĥ applied to ⟨Ĥ⟩
>>>>
>>>> This is the same thing as saying embedded_H correctly transitions to
>>>> Ĥ.qn iff replacing embedded_H at Ĥ.qx with a UTM would cause Ĥ
>>>> applied to ⟨Ĥ⟩ to never halt.
>>>
>>> The conditions which Ben supplied don't even remotely resemble
>>> anything you've written above.
>>>
>>
>> I am only using Ben's notational conventions. When H bases its halt
>> status decision on the UTM simulation of its input then embedded_H
>> necessarily must do the same because it is only a copy of H.
>>
>> Do don't seem to be able to understand this.
>>
>>> His conditions makes no mention of 'replacing' embedded_H with a UTM.
>>> It makes no mention of embedded_H needing to abort a simulation, let
>>> alone 'any recursive instance of embedded_H'.
>>>
>>> You've invented an entirely new condition which bears no resemblance
>>> whatsoever to the condition which defines a halt decider, and which
>>> is too incoherently stated to even evaluate.
>>>
>>
>> THIS IS REALLY NOT THAT DIFFICULT:
>> Because it is known that the UTM simulation of a machine is
>> computationally equivalent to the direct execution of this same
>> machine H can always form its halt status decision on the basis of
>> behavior of the UTM simulation of its inputs.
>
> Basing a decision on the behaviour of a UTM simulation is not the same
> thing as *replacing* your embedded_H with a UTM. Not even remotely. A
> UTM does *not* report on whether its input halts.
>

None-the-less the behavior of the machine as if embedded_H was replaced
by a UTM is the actual criterion measure required by embedded_H.

> Consider Ben's example of a Parity Decider (PD).
>
> If your Ĥ works by 'replacing' the embedded_H with a UTM, and I run the
> computation Ĥ wPD 3 it would transition to a final rejecting state, not
> because PD applied to 3 doesn't halt but because 3 is not an even number.
>
> A UTM returns an answer corresponding to the answer to the computation
> which is passed to it as an input (assuming that it halts at all).
> That's not the answer you want.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V42 [where people get stuck]

<OU8zJ.50263$g81.40792@fx19.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx19.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 [where people get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com> <sqi88u$ai9$1@dont-email.me> <lYWdnVzlccb6XFH8nZ2dnUU7-ePNnZ2d@giganews.com> <sqihk3$e5u$1@dont-email.me> <qpSdneigrPdXQFH8nZ2dnUU7-TGdnZ2d@giganews.com> <sqio4l$m2k$1@dont-email.me> <hLydnR3Op_pEe1H8nZ2dnUU7-YfNnZ2d@giganews.com> <sqiqc6$4n5$1@dont-email.me> <sqirr2$brd$1@dont-email.me> <z5OdneTRlcI4alH8nZ2dnUU7-IfNnZ2d@giganews.com> <sqitub$mqc$1@dont-email.me> <EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com> <sqj0g6$33a$1@dont-email.me> <HqadnT5safjQmlD8nZ2dnUU7-SmdnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <HqadnT5safjQmlD8nZ2dnUU7-SmdnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 142
Message-ID: <OU8zJ.50263$g81.40792@fx19.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 29 Dec 2021 21:34:22 -0500
X-Received-Bytes: 7248
 by: Richard Damon - Thu, 30 Dec 2021 02:34 UTC

On 12/29/21 8:11 PM, olcott wrote:
> On 12/29/2021 7:03 PM, André G. Isaak wrote:
>> On 2021-12-29 17:43, olcott wrote:
>>> On 12/29/2021 6:19 PM, André G. Isaak wrote:
>>>> On 2021-12-29 17:04, olcott wrote:
>>>>> On 12/29/2021 5:43 PM, André G. Isaak wrote:
>>>>>> On 2021-12-29 16:18, André G. Isaak wrote:
>>>>>>> On 2021-12-29 15:53, olcott wrote:
>>>>>>>> On 12/29/2021 4:40 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-12-29 15:14, olcott wrote:
>>>>>>
>>>>>>>>>> When Linz says
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>>>> He is wrong.
>>>>>>>>>
>>>>>>>>> No, he is not.
>>>>>>>>>
>>>>>>>>
>>>>>>>> There is only one computation above that is actually Ĥ and that
>>>>>>>> computation includes embedded_H at Ĥ.qx.
>>>>>>>>
>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is is not Ĥ itself.
>>>>>>>
>>>>>>> Where does Linz claim that ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ itself? He doesn't.
>>>>>>> Nothing in the above even remotely implies that, so I have no
>>>>>>> clue what your objection here actually is. You need to learn what
>>>>>>> this notation actually *means*.
>>>>>>
>>>>>> Just to clarify this, you need to understand what a condition
>>>>>> actually *means*.
>>>>>>
>>>>>> When we say:
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>
>>>>>> the 'iff Ĥ applied to ⟨Ĥ⟩ halts' simply specifies what condition
>>>>>> must be met for Ĥ.q0 ⟨Ĥ⟩ to transition to Ĥ.qy ∞. It says nothing
>>>>>> about how the underlying algorithm works. In particular, it
>>>>>> doesn't require that Ĥ ever gets applied to ⟨Ĥ⟩ at some point in
>>>>>> the computation.
>>>>>>
>>>>>> Consider the following simple TM:
>>>>>>
>>>>>> M.q0 w ⊢* M.qy iff 2 + 3 = 5.
>>>>>>
>>>>>> That describes a TM which accepts *every* input string it is given
>>>>>> because the condition which has been given is always true.
>>>>>>
>>>>>> This condition does *not* mean that an implementation of M has to
>>>>>> actually add numbers or compare two numbers. Said machine can
>>>>>> simply transition directly from its initial state to its final
>>>>>> accepting state without doing anything at all.
>>>>>>
>>>>>> The condition simply states some fact which must be true for the
>>>>>> machine to transition to a particular state. The TM may or may not
>>>>>> directly reference the condition in its algorithm. The design just
>>>>>> needs to ensure that where it gets to is *consistent* with that
>>>>>> condition.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> That pulls the focus of attention away from the point where is
>>>>> needs to be thus making what I am saying impossible to understand.
>>>>>
>>>>> The actual criterion measure is that embedded_H correctly
>>>>> transitions to Ĥ.qn iff any recursive instance of the simulating
>>>>> halt decider of embedded_H ever needs abort the simulation of its
>>>>> input to prevent the infinite execution of Ĥ applied to ⟨Ĥ⟩
>>>>>
>>>>> This is the same thing as saying embedded_H correctly transitions
>>>>> to Ĥ.qn iff replacing embedded_H at Ĥ.qx with a UTM would cause Ĥ
>>>>> applied to ⟨Ĥ⟩ to never halt.
>>>>
>>>> The conditions which Ben supplied don't even remotely resemble
>>>> anything you've written above.
>>>>
>>>
>>> I am only using Ben's notational conventions. When H bases its halt
>>> status decision on the UTM simulation of its input then embedded_H
>>> necessarily must do the same because it is only a copy of H.
>>>
>>> Do don't seem to be able to understand this.
>>>
>>>> His conditions makes no mention of 'replacing' embedded_H with a
>>>> UTM. It makes no mention of embedded_H needing to abort a
>>>> simulation, let alone 'any recursive instance of embedded_H'.
>>>>
>>>> You've invented an entirely new condition which bears no resemblance
>>>> whatsoever to the condition which defines a halt decider, and which
>>>> is too incoherently stated to even evaluate.
>>>>
>>>
>>> THIS IS REALLY NOT THAT DIFFICULT:
>>> Because it is known that the UTM simulation of a machine is
>>> computationally equivalent to the direct execution of this same
>>> machine H can always form its halt status decision on the basis of
>>> behavior of the UTM simulation of its inputs.
>>
>> Basing a decision on the behaviour of a UTM simulation is not the same
>> thing as *replacing* your embedded_H with a UTM. Not even remotely. A
>> UTM does *not* report on whether its input halts.
>>
>
> None-the-less the behavior of the machine as if embedded_H was replaced
> by a UTM is the actual criterion measure required by embedded_H.
>

Where do you get that from?

Actual Reference!

The definition in Linz is the correct answer to H wM w matches tge
behavior of M w (where Halting means go to Qy and Non-Halting means got
to Qn in finite time)

I don't think you actually know what this means, and THAT is your problem.

That is just your definition of POOP.

>
>> Consider Ben's example of a Parity Decider (PD).
>>
>> If your Ĥ works by 'replacing' the embedded_H with a UTM, and I run
>> the computation Ĥ wPD 3 it would transition to a final rejecting
>> state, not because PD applied to 3 doesn't halt but because 3 is not
>> an even number.
>>
>> A UTM returns an answer corresponding to the answer to the computation
>> which is passed to it as an input (assuming that it halts at all).
>> That's not the answer you want.
>>
>> André
>>
>
>

Re: Concise refutation of halting problem proofs V42 [where people get stuck]

<PY8zJ.50264$g81.47088@fx19.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx19.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 [where people
get stuck]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<sqi88u$ai9$1@dont-email.me> <lYWdnVzlccb6XFH8nZ2dnUU7-ePNnZ2d@giganews.com>
<sqihk3$e5u$1@dont-email.me> <qpSdneigrPdXQFH8nZ2dnUU7-TGdnZ2d@giganews.com>
<sqio4l$m2k$1@dont-email.me> <hLydnR3Op_pEe1H8nZ2dnUU7-YfNnZ2d@giganews.com>
<sqiqc6$4n5$1@dont-email.me> <sqirr2$brd$1@dont-email.me>
<z5OdneTRlcI4alH8nZ2dnUU7-IfNnZ2d@giganews.com> <sqitub$mqc$1@dont-email.me>
<EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <EZ6dnZe9rodanVD8nZ2dnUU7-a3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 129
Message-ID: <PY8zJ.50264$g81.47088@fx19.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 29 Dec 2021 21:38:39 -0500
X-Received-Bytes: 6558
 by: Richard Damon - Thu, 30 Dec 2021 02:38 UTC

On 12/29/21 7:43 PM, olcott wrote:
> On 12/29/2021 6:19 PM, André G. Isaak wrote:
>> On 2021-12-29 17:04, olcott wrote:
>>> On 12/29/2021 5:43 PM, André G. Isaak wrote:
>>>> On 2021-12-29 16:18, André G. Isaak wrote:
>>>>> On 2021-12-29 15:53, olcott wrote:
>>>>>> On 12/29/2021 4:40 PM, André G. Isaak wrote:
>>>>>>> On 2021-12-29 15:14, olcott wrote:
>>>>
>>>>>>>> When Linz says
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>>>>>> He is wrong.
>>>>>>>
>>>>>>> No, he is not.
>>>>>>>
>>>>>>
>>>>>> There is only one computation above that is actually Ĥ and that
>>>>>> computation includes embedded_H at Ĥ.qx.
>>>>>>
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is is not Ĥ itself.
>>>>>
>>>>> Where does Linz claim that ⟨Ĥ⟩ ⟨Ĥ⟩ is Ĥ itself? He doesn't. Nothing
>>>>> in the above even remotely implies that, so I have no clue what
>>>>> your objection here actually is. You need to learn what this
>>>>> notation actually *means*.
>>>>
>>>> Just to clarify this, you need to understand what a condition
>>>> actually *means*.
>>>>
>>>> When we say:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞ iff Ĥ applied to ⟨Ĥ⟩ halts
>>>>
>>>> the 'iff Ĥ applied to ⟨Ĥ⟩ halts' simply specifies what condition
>>>> must be met for Ĥ.q0 ⟨Ĥ⟩ to transition to Ĥ.qy ∞. It says nothing
>>>> about how the underlying algorithm works. In particular, it doesn't
>>>> require that Ĥ ever gets applied to ⟨Ĥ⟩ at some point in the
>>>> computation.
>>>>
>>>> Consider the following simple TM:
>>>>
>>>> M.q0 w ⊢* M.qy iff 2 + 3 = 5.
>>>>
>>>> That describes a TM which accepts *every* input string it is given
>>>> because the condition which has been given is always true.
>>>>
>>>> This condition does *not* mean that an implementation of M has to
>>>> actually add numbers or compare two numbers. Said machine can simply
>>>> transition directly from its initial state to its final accepting
>>>> state without doing anything at all.
>>>>
>>>> The condition simply states some fact which must be true for the
>>>> machine to transition to a particular state. The TM may or may not
>>>> directly reference the condition in its algorithm. The design just
>>>> needs to ensure that where it gets to is *consistent* with that
>>>> condition.
>>>>
>>>> André
>>>>
>>>
>>> That pulls the focus of attention away from the point where is needs
>>> to be thus making what I am saying impossible to understand.
>>>
>>> The actual criterion measure is that embedded_H correctly transitions
>>> to Ĥ.qn iff any recursive instance of the simulating halt decider of
>>> embedded_H ever needs abort the simulation of its input to prevent
>>> the infinite execution of Ĥ applied to ⟨Ĥ⟩
>>>
>>> This is the same thing as saying embedded_H correctly transitions to
>>> Ĥ.qn iff replacing embedded_H at Ĥ.qx with a UTM would cause Ĥ
>>> applied to ⟨Ĥ⟩ to never halt.
>>
>> The conditions which Ben supplied don't even remotely resemble
>> anything you've written above.
>>
>
> I am only using Ben's notational conventions. When H bases its halt
> status decision on the UTM simulation of its input then embedded_H
> necessarily must do the same because it is only a copy of H.
>
> Do don't seem to be able to understand this.
>
>> His conditions makes no mention of 'replacing' embedded_H with a UTM.
>> It makes no mention of embedded_H needing to abort a simulation, let
>> alone 'any recursive instance of embedded_H'.
>>
>> You've invented an entirely new condition which bears no resemblance
>> whatsoever to the condition which defines a halt decider, and which is
>> too incoherently stated to even evaluate.
>>
>
> THIS IS REALLY NOT THAT DIFFICULT:
> Because it is known that the UTM simulation of a machine is
> computationally equivalent to the direct execution of this same machine
> H can always form its halt status decision on the basis of behavior of
> the UTM simulation of its inputs.

The Right answer matches the behavior of giving the input to the Halt
Decider to a REAL UTM and observing the behavior. Halting means go to Qy
and non-halting means go to Qn.

Remember, the behavior of the UTM is IDENTICAL (in the aspects of the
final output, and finitness of the operation) to running the actual
machine with that input. DEFINIITION.

That is DIFFERENT then H just being a UTM, or just using the UTM, as
then H still needs to figure out if the UTM is going to Halt or Not.

You have just kicked the can down the road, and if you keep doing that
you just end up not answering, and for H^, if you do stop and answer,
you will just be wrong, by construction.

FAIL.

>
>> Linz's conditions are valid.
>> Ben's conditions are valid (though the addition of a UTM is pointless).
>> Your conditions are completely invalid.
>>
>> André
>>
>
>

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

<0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 29 Dec 2021 22:02:45 -0600
Date: Wed, 29 Dec 2021 22:02:44 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <87ee5v5ihm.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
Lines: 35
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-2kZwXUD+75t82esTM624gfMJflCkW2mOlflRYJTqiWnoBfNox+exBe3gW8+CIX0Wa0qOJvP8V479faI!9UoUg5WHpKJz/5iFW7WTuTiOgo/iuJlTXiz1fQResSJbMZNIRc8G6GHrx+QVM8K/95AfyG/ulzo6!8g==
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: 2588
 by: olcott - Thu, 30 Dec 2021 04:02 UTC

On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> *My criterion measure with Ben's notational conventions*
>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
>
> It's not your criterion, it's mine. It's also Linz's. If yours is not
> the same as his (and mine), it should be different in some way. (And we
> can safely ignore it, since no one cares about your alternative
> criteria.)
>

It has always been my criterion measure that halt deciders base their
halt status decision on the pure simulation of their inputs.

That your notational conventions very cleanly express this idea as
applied to the Linz H is a good breakthrough.

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

As soon as people understand that this same criterion measure applies
recursively to every embedded_H at Ĥ.qx, then they will see how this
criterion measure provides the means for embedded_H to correctly compute
the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.

--
Copyright 2021 Pete Olcott

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

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

<VOazJ.207450$1d1.49719@fx99.iad>

 copy mid

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

 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!fx99.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 47
Message-ID: <VOazJ.207450$1d1.49719@fx99.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Wed, 29 Dec 2021 23:44:36 -0500
X-Received-Bytes: 2846
X-Original-Bytes: 2713
 by: Richard Damon - Thu, 30 Dec 2021 04:44 UTC

On 12/29/21 11:02 PM, olcott wrote:
> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> *My criterion measure with Ben's notational conventions*
>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>
>> It's not your criterion, it's mine.  It's also Linz's.  If yours is not
>> the same as his (and mine), it should be different in some way.  (And we
>> can safely ignore it, since no one cares about your alternative
>> criteria.)
>>
>
> It has always been my criterion measure that halt deciders base their
> halt status decision on the pure simulation of their inputs.
>
> That your notational conventions very cleanly express this idea as
> applied to the Linz H is a good breakthrough.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> As soon as people understand that this same criterion measure applies
> recursively to every embedded_H at Ĥ.qx, then they will see how this
> criterion measure provides the means for embedded_H to correctly compute
> the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>

Yes each level can use the test to determine if the halt decider at that
level got the right answer or not.

The issue is that when we are doing this check, you check JUST that
level, and not lower levels.

UTM(<H^?,<H^>) means simulate H^ EXACTLY as written, with the H that
was actually written, not changed to something else.

By construction, this means that every H(<H^>,<H^>) that goes to H.qn
makes the H^(<H^>) that uses it to be Halting, and since ALL H^(<H^>)
behave the same, they ALL are wrong.

FAIL.

How does the UTM know WHAT to change when simulating its input? A UTM is
a very general machine, so doesn't know anything about your H.

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

<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>

 copy mid

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

 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: Wed, 29 Dec 2021 22:51:32 -0600
Date: Wed, 29 Dec 2021 22:51: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 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <VOazJ.207450$1d1.49719@fx99.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
Lines: 45
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-VLf78ObengGKLrlsSmEnIyWUjc5kV1b9ArPjlSKFDbFbvD5XE1m7vfYemisw2wAxb9YAlKTEsUecoog!QGPEhExTL5B67Rj5Sniwwp+nzfCuMClbWBQsGn3JEuLKWdKIUeGyr1sHQQRDO14fmCETUkSaX6El!/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: 3015
 by: olcott - Thu, 30 Dec 2021 04:51 UTC

On 12/29/2021 10:44 PM, Richard Damon wrote:
> On 12/29/21 11:02 PM, olcott wrote:
>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> *My criterion measure with Ben's notational conventions*
>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>
>>> It's not your criterion, it's mine.  It's also Linz's.  If yours is not
>>> the same as his (and mine), it should be different in some way.  (And we
>>> can safely ignore it, since no one cares about your alternative
>>> criteria.)
>>>
>>
>> It has always been my criterion measure that halt deciders base their
>> halt status decision on the pure simulation of their inputs.
>>
>> That your notational conventions very cleanly express this idea as
>> applied to the Linz H is a good breakthrough.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> As soon as people understand that this same criterion measure applies
>> recursively to every embedded_H at Ĥ.qx, then they will see how this
>> criterion measure provides the means for embedded_H to correctly
>> compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>
>
> Yes each level can use the test to determine if the halt decider at that
> level got the right answer or not.
>
> The issue is that when we are doing this check, you check JUST that
> level, and not lower levels.

No you are wrong.

--
Copyright 2021 Pete Olcott

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

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

<sqjfea$2pu$1@dont-email.me>

 copy mid

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

 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 [compute the
mapping]
Date: Wed, 29 Dec 2021 22:18:01 -0700
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 64
Message-ID: <sqjfea$2pu$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>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Thu, 30 Dec 2021 05:18:02 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="281e34967abc652e32513cf7d24af717";
logging-data="2878"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/YajRGUp8xGV8Q4Q7pzWII"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:hbqN01ZiurMcZI8apO9HC5fZx48=
In-Reply-To: <8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Thu, 30 Dec 2021 05:18 UTC

On 2021-12-29 21:51, olcott wrote:
> On 12/29/2021 10:44 PM, Richard Damon wrote:
>> On 12/29/21 11:02 PM, olcott wrote:
>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> *My criterion measure with Ben's notational conventions*
>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>
>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours is not
>>>> the same as his (and mine), it should be different in some way.
>>>> (And we
>>>> can safely ignore it, since no one cares about your alternative
>>>> criteria.)
>>>>
>>>
>>> It has always been my criterion measure that halt deciders base their
>>> halt status decision on the pure simulation of their inputs.
>>>
>>> That your notational conventions very cleanly express this idea as
>>> applied to the Linz H is a good breakthrough.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> As soon as people understand that this same criterion measure applies
>>> recursively to every embedded_H at Ĥ.qx, then they will see how this
>>> criterion measure provides the means for embedded_H to correctly
>>> compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>
>>
>> Yes each level can use the test to determine if the halt decider at
>> that level got the right answer or not.
>>
>> The issue is that when we are doing this check, you check JUST that
>> level, and not lower levels.
>
> No you are wrong.

No, he isn't.

The specification you give above (where YET AGAIN you omit the
conditions) is for a case where the input to Ĥ is a description of
itself, but the actual specification of the machine can't make that
assumption. So really we should be using:

Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qy ∞ iff UTM(wM, wM) halts
Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qn iff UTM(wM, wM) does not halt

Ĥ has absolutely no knowledge of what it will be given as an input. In
the case we considered above wM was ⟨Ĥ⟩, but wM could have been a
description of any machine. Ĥ has no way of knowing if wM is a
description of itself, or a description of some TM which simply prints
its input string to the tape in reverse order (which wouldn't involve
simulating its input at all). So the conditions given above cannot
possibly apply to any 'lower level' since Ĥ knows nothing about any of
those 'lower levels'.

André

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

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

<27bb569d-8453-40d3-bd68-965bcf4e3107n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:1477:: with SMTP id j23mr21693013qkl.152.1640861463870;
Thu, 30 Dec 2021 02:51:03 -0800 (PST)
X-Received: by 2002:a5b:881:: with SMTP id e1mr23129399ybq.15.1640861453428;
Thu, 30 Dec 2021 02:50:53 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!news.szaf.org!news.uzoreto.com!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Thu, 30 Dec 2021 02:50:53 -0800 (PST)
In-Reply-To: <sqjfea$2pu$1@dont-email.me>
Injection-Info: google-groups.googlegroups.com; posting-host=93.41.98.118; posting-account=F3H0JAgAAADcYVukktnHx7hFG5stjWse
NNTP-Posting-Host: 93.41.98.118
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>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <27bb569d-8453-40d3-bd68-965bcf4e3107n@googlegroups.com>
Subject: Re: Concise refutation of halting problem proofs V42 [compute the mapping]
From: jul...@diegidio.name (Julio Di Egidio)
Injection-Date: Thu, 30 Dec 2021 10:51:03 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 4933
 by: Julio Di Egidio - Thu, 30 Dec 2021 10:50 UTC

On Thursday, 30 December 2021 at 06:18:05 UTC+1, André G. Isaak wrote:
> On 2021-12-29 21:51, olcott wrote:
> > On 12/29/2021 10:44 PM, Richard Damon wrote:
> >> On 12/29/21 11:02 PM, olcott wrote:
> >>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
> >>>> olcott <No...@NoWhere.com> writes:
> >>>>
> >>>>> *My criterion measure with Ben's notational conventions*
> >>>>> H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
> >>>>> H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt
> >>>>
> >>>> It's not your criterion, it's mine. It's also Linz's. If yours is not
> >>>> the same as his (and mine), it should be different in some way.
> >>>> (And we
> >>>> can safely ignore it, since no one cares about your alternative
> >>>> criteria.)
> >>>>
> >>>
> >>> It has always been my criterion measure that halt deciders base their
> >>> halt status decision on the pure simulation of their inputs.
> >>>
> >>> That your notational conventions very cleanly express this idea as
> >>> applied to the Linz H is a good breakthrough.
> >>>
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>
> >>> As soon as people understand that this same criterion measure applies
> >>> recursively to every embedded_H at Ĥ.qx, then they will see how this
> >>> criterion measure provides the means for embedded_H to correctly
> >>> compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
> >>>
> >>
> >> Yes each level can use the test to determine if the halt decider at
> >> that level got the right answer or not.
> >>
> >> The issue is that when we are doing this check, you check JUST that
> >> level, and not lower levels.
> >
> > No you are wrong.
> No, he isn't.
>
> The specification you give above (where YET AGAIN you omit the
> conditions) is for a case where the input to Ĥ is a description of
> itself, but the actual specification of the machine can't make that
> assumption. So really we should be using:
>
> Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qy ∞ iff UTM(wM, wM) halts
> Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qn iff UTM(wM, wM) does not halt
>
> Ĥ has absolutely no knowledge of what it will be given as an input. In
> the case we considered above wM was ⟨Ĥ⟩, but wM could have been a
> description of any machine. Ĥ has no way of knowing if wM is a
> description of itself, or a description of some TM which simply prints
> its input string to the tape in reverse order (which wouldn't involve
> simulating its input at all). So the conditions given above cannot
> possibly apply to any 'lower level' since Ĥ knows nothing about any of
> those 'lower levels'.
> André
>
> --
> To email remove 'invalid' & replace 'gm' with well known Google mail
> service.

You fucking retards re still feeding that moron??

You polluting retarded pieces of spamming shit: you are the problem, not him...

ESAD, you stupid fucks and retarded agents of the enemy.

*Plonk*

Julio

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

<gejzJ.91885$Gco3.21338@fx01.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx01.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 52
Message-ID: <gejzJ.91885$Gco3.21338@fx01.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 09:19:57 -0500
X-Received-Bytes: 3062
 by: Richard Damon - Thu, 30 Dec 2021 14:19 UTC

On 12/29/21 11:51 PM, olcott wrote:
> On 12/29/2021 10:44 PM, Richard Damon wrote:
>> On 12/29/21 11:02 PM, olcott wrote:
>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> *My criterion measure with Ben's notational conventions*
>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>
>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours is not
>>>> the same as his (and mine), it should be different in some way.
>>>> (And we
>>>> can safely ignore it, since no one cares about your alternative
>>>> criteria.)
>>>>
>>>
>>> It has always been my criterion measure that halt deciders base their
>>> halt status decision on the pure simulation of their inputs.
>>>
>>> That your notational conventions very cleanly express this idea as
>>> applied to the Linz H is a good breakthrough.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> As soon as people understand that this same criterion measure applies
>>> recursively to every embedded_H at Ĥ.qx, then they will see how this
>>> criterion measure provides the means for embedded_H to correctly
>>> compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>
>>
>> Yes each level can use the test to determine if the halt decider at
>> that level got the right answer or not.
>>
>> The issue is that when we are doing this check, you check JUST that
>> level, and not lower levels.
>
> No you are wrong.
>
>

Source? (Some REAL reference)

Or is this just another of your "it must be this way or my proof does't
work".

You are confusing HOW your decider works, which must answer in finite
time or it fails to meet the requirement, with the check for a right
answer, which might take unbounded time.

FAIL.

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

<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 09:15:06 -0600
Date: Thu, 30 Dec 2021 09:15:05 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <sqjfea$2pu$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
Lines: 130
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-iZgBUZhzT0G5s03WqDucWBkryHQltVxnDrJ8taCiKx4nkDsdgnFzMikWfyG/CdoamHeQNVIblSDgQWK!QuK+Z6uphBq2N+3kEbayKZ4PKYyI16WFi1oU5b7qwWsCMvarRlQ0GhbaW+9W6XXi/ItFq/7zPwnM!Ow==
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: 6650
 by: olcott - Thu, 30 Dec 2021 15:15 UTC

On 12/29/2021 11:18 PM, André G. Isaak wrote:
> On 2021-12-29 21:51, olcott wrote:
>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>> On 12/29/21 11:02 PM, olcott wrote:
>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>
>>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours is
>>>>> not
>>>>> the same as his (and mine), it should be different in some way.
>>>>> (And we
>>>>> can safely ignore it, since no one cares about your alternative
>>>>> criteria.)
>>>>>
>>>>
>>>> It has always been my criterion measure that halt deciders base
>>>> their halt status decision on the pure simulation of their inputs.
>>>>
>>>> That your notational conventions very cleanly express this idea as
>>>> applied to the Linz H is a good breakthrough.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> As soon as people understand that this same criterion measure
>>>> applies recursively to every embedded_H at Ĥ.qx, then they will see
>>>> how this criterion measure provides the means for embedded_H to
>>>> correctly compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>
>>>
>>> Yes each level can use the test to determine if the halt decider at
>>> that level got the right answer or not.
>>>
>>> The issue is that when we are doing this check, you check JUST that
>>> level, and not lower levels.
>>
>> No you are wrong.
>
> No, he isn't.
>
> The specification you give above (where YET AGAIN you omit the
> conditions)

The conditions are provided by H, because H is copied to Ĥ.qx we need
not state them again.

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

To make things simple we name the copy of H at Ĥ.qx embedded_H.

Because the criterion measure is applied as if the embedded_H at Ĥ.qx
was replaced by a UTM and the TM description of Ĥ would include a TM
description of this UTM the execution of Ĥ applied to ⟨Ĥ⟩ would

endlessly repeat:
copy its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then simulate this input with the UTM...

In order for embedded_H to see what this machine would do it must
actually perform a pure simulation of N steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩. This
may or may not include simulating embedded_H.

As soon as embedded_H sees that these steps would otherwise endlessly
repeat it aborts its simulation and transitions to Ĥ.qn.

Because it is applying a criterion measure that we know is correct:
A halt decider is always correct when it bases its halt status decision
on the behavior of the UTM simulation of its inputs.
We know that this transition to Ĥ.qn is correct.

> is for a case where the input to Ĥ is a description of
> itself, but the actual specification of the machine can't make that
> assumption. So really we should be using:
>

The criterion measure is merely provided to humans so that humans can
understand that the basis of the halt status decision of embedded_H is
sound.

Because it is obvious that the basis is sound when applied to H then
this same sound basis carries over to embedded_H.

> Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qy ∞ iff UTM(wM, wM) halts
> Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qn   iff UTM(wM, wM) does not halt
>
> Ĥ has absolutely no knowledge of what it will be given as an input. In

For purposes of discussion we are simply ignoring every other input and
only focusing on the one input.

It is simpler for the human mind to see all the relevant details in one
place and not have to imagine all of the changes to see the case-at-hand.

The way that you specify the criterion measure is vague. When I define
the criterion measure for H this applies the criterion measure at the
point where H is copied Ĥ.qx.

> the case we considered above wM was ⟨Ĥ⟩, but wM could have been a
> description of any machine. Ĥ has no way of knowing if wM is a
> description of itself, or a description of some TM which simply prints
> its input string to the tape in reverse order (which wouldn't involve
> simulating its input at all).

H thus embedded_H only makes its halt status decision on the basis of
the simulation of its input. H can only see what its input does by
simulating its input.

> So the conditions given above cannot
> possibly apply to any 'lower level' since Ĥ knows nothing about any of
> those 'lower levels'.
>
> André
>

It only applies to lower levels when there is actual pathological
self-reference(Olcott 2004) as there is with the definition of Ĥ. Ĥ is
asking itself whether or not it stops running and then looping if it
says yes.

--
Copyright 2021 Pete Olcott

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

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

<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 09:20:10 -0600
Date: Thu, 30 Dec 2021 09:20: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 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <gejzJ.91885$Gco3.21338@fx01.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
Lines: 72
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Kq4NKPSma4sTPr9px22YL7mHCeICuVfZ0otRWp3rZAdSljaSihnx53qG6IUs3S5UkxmbDVMBcDtkG5U!0SqrDwXOWG9x1pK7J137fBKboJR7nxNXaIbjAxg+61cCErgvCEhfxzsA0uyDvmMMUOqr3AFmdjLh!fQ==
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: 3944
 by: olcott - Thu, 30 Dec 2021 15:20 UTC

On 12/30/2021 8:19 AM, Richard Damon wrote:
> On 12/29/21 11:51 PM, olcott wrote:
>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>> On 12/29/21 11:02 PM, olcott wrote:
>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>
>>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours is
>>>>> not
>>>>> the same as his (and mine), it should be different in some way.
>>>>> (And we
>>>>> can safely ignore it, since no one cares about your alternative
>>>>> criteria.)
>>>>>
>>>>
>>>> It has always been my criterion measure that halt deciders base
>>>> their halt status decision on the pure simulation of their inputs.
>>>>
>>>> That your notational conventions very cleanly express this idea as
>>>> applied to the Linz H is a good breakthrough.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> As soon as people understand that this same criterion measure
>>>> applies recursively to every embedded_H at Ĥ.qx, then they will see
>>>> how this criterion measure provides the means for embedded_H to
>>>> correctly compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>
>>>
>>> Yes each level can use the test to determine if the halt decider at
>>> that level got the right answer or not.
>>>
>>> The issue is that when we are doing this check, you check JUST that
>>> level, and not lower levels.
>>
>> No you are wrong.
>>
>>
>
> Source? (Some REAL reference)
>

H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

The source is the correct reasoning of how the above criterion measure
would be applied when H is copied to Ĥ.qx.

You keep thinking that a subsequent level UTM magically turns into
embedded_H and aborts its simulation.

> Or is this just another of your "it must be this way or my proof does't
> work".
>
> You are confusing HOW your decider works, which must answer in finite
> time or it fails to meet the requirement, with the check for a right
> answer, which might take unbounded time.
>
> 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 [compute the mapping]

<AxkzJ.176966$Wkjc.130511@fx35.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!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!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 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 222
Message-ID: <AxkzJ.176966$Wkjc.130511@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: Thu, 30 Dec 2021 10:48:48 -0500
X-Received-Bytes: 9067
 by: Richard Damon - Thu, 30 Dec 2021 15:48 UTC

On 12/30/21 10:15 AM, olcott wrote:
> On 12/29/2021 11:18 PM, André G. Isaak wrote:
>> On 2021-12-29 21:51, olcott wrote:
>>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>>> On 12/29/21 11:02 PM, olcott wrote:
>>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>
>>>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours
>>>>>> is not
>>>>>> the same as his (and mine), it should be different in some way.
>>>>>> (And we
>>>>>> can safely ignore it, since no one cares about your alternative
>>>>>> criteria.)
>>>>>>
>>>>>
>>>>> It has always been my criterion measure that halt deciders base
>>>>> their halt status decision on the pure simulation of their inputs.
>>>>>
>>>>> That your notational conventions very cleanly express this idea as
>>>>> applied to the Linz H is a good breakthrough.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> As soon as people understand that this same criterion measure
>>>>> applies recursively to every embedded_H at Ĥ.qx, then they will see
>>>>> how this criterion measure provides the means for embedded_H to
>>>>> correctly compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>>
>>>>
>>>> Yes each level can use the test to determine if the halt decider at
>>>> that level got the right answer or not.
>>>>
>>>> The issue is that when we are doing this check, you check JUST that
>>>> level, and not lower levels.
>>>
>>> No you are wrong.
>>
>> No, he isn't.
>>
>> The specification you give above (where YET AGAIN you omit the
>> conditions)
>
> The conditions are provided by H, because H is copied to Ĥ.qx we need
> not state them again.

So a line Determine by H might be appropriate.
Dropping the requirements is seen as one of your 'tricks' to allow allow
your 'emdedded_H to deviate from H.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> To make things simple we name the copy of H at Ĥ.qx embedded_H.

Why does it need a new name?

>
> Because the criterion measure is applied as if the embedded_H at Ĥ.qx
> was replaced by a UTM and the TM description of Ĥ would include a TM
> description of this UTM the execution of Ĥ applied to ⟨Ĥ⟩ would
>

No, it is NOT.

Where do you get that from?

We don't care if embedded_H is 'Correct', we care that it give the same
answer as H.

> endlessly repeat:
> copy its input ⟨Ĥ⟩ to ⟨Ĥ⟩ and then simulate this input with the UTM...

Which is caused by putting in the wrong code where H should be.

>
> In order for embedded_H to see what this machine would do it must
> actually perform a pure simulation of N steps of its input ⟨Ĥ⟩ ⟨Ĥ⟩. This
> may or may not include simulating embedded_H.

And the way you do it, it gets the wrong answer BECAUSE you have
replaced H with UTM, and then don't actually look at what it does.

>
> As soon as embedded_H sees that these steps would otherwise endlessly
> repeat it aborts its simulation and transitions to Ĥ.qn.

Except that they DON'T Endlessly repeat if you did it right.

H MISTAKENLY thinks there is an endless recursion, because it doesn't
treat the H in the computation as H but as a UTM.

Unless H actually IS a UTM (at which point it can't abort) this change
is invalid.

>
> Because it is applying a criterion measure that we know is correct:
> A halt decider is always correct when it bases its halt status decision
> on the behavior of the UTM simulation of its inputs.
> We know that this transition to Ĥ.qn is correct.

Where was that criteria shown to be correct?

You have created your own LIE of a critera which fails to look at the
computation as written, but something else entirely.

You are looking at Dogs to determine if Cats Bark.

>
>> is for a case where the input to Ĥ is a description of itself, but the
>> actual specification of the machine can't make that assumption. So
>> really we should be using:
>>
>
> The criterion measure is merely provided to humans so that humans can
> understand that the basis of the halt status decision of embedded_H is
> sound.

No, the actual criterion is the actual criterion.

H wM w needs to go to H.Qy if M w Halts.

Given that your H <H^> <^H> goes to H.Qn, we can show that

H^ <H^> Halts, so H <H^> <H^> needed to have gone to H.Qy to be correct,
so it is incorrect.

>
> Because it is obvious that the basis is sound when applied to H then
> this same sound basis carries over to embedded_H.

Nothing you do is 'obvious' except that you use bad logic.

You use that word to make claims that you don't know how to even attempt
to prove or know are false and thus unprovable with valid logic.

>
>> Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qy ∞ iff UTM(wM, wM) halts
>> Ĥ.q0 ⟨wM⟩ ⊢* Ĥ.qx wM wM⟩ ⊢* Ĥ.qn   iff UTM(wM, wM) does not halt
>>
>> Ĥ has absolutely no knowledge of what it will be given as an input. In
>
> For purposes of discussion we are simply ignoring every other input and
> only focusing on the one input.

Ok.

If H(<H^>,<H^>) goes to H.qn and says non-halting, then by construction
H^(<H^>) will go to H^.qn and Halt, and thus H was wrongs.

That is a very simple statement of the problem.

WHICH STATEMENT DID I MAKE THAT WAS AN ERROR.

You can't deny the conclusion without pointing out an error in the
logic, unless you are saying you don't beleive in logic at all.

>
> It is simpler for the human mind to see all the relevant details in one
> place and not have to imagine all of the changes to see the case-at-hand.
>
> The way that you specify the criterion measure is vague. When I define
> the criterion measure for H this applies the criterion measure at the
> point where H is copied Ĥ.qx.

What is Vague about it?

Or do you still not believe that ALL copies of M w do exactly the same
thing?

It doensn't matter which copy we look at as all behave the same.

If you don't beleive that, please show ANY example of something that
meets the actual requirements of a computation that breaks the property.

>
>> the case we considered above wM was ⟨Ĥ⟩, but wM could have been a
>> description of any machine. Ĥ has no way of knowing if wM is a
>> description of itself, or a description of some TM which simply prints
>> its input string to the tape in reverse order (which wouldn't involve
>> simulating its input at all).
>
> H thus embedded_H only makes its halt status decision on the basis of
> the simulation of its input. H can only see what its input does by
> simulating its input.

And the answer is it either never makes its decision or it makes a wrong
decision. For H^, those are the only two options.

You just use smoke, mirrors, and Lies to try to claim otherwise.

>
>> So the conditions given above cannot possibly apply to any 'lower
>> level' since Ĥ knows nothing about any of those 'lower levels'.
>>
>> André
>>
>
> It only applies to lower levels when there is actual pathological
> self-reference(Olcott 2004) as there is with the definition of Ĥ. Ĥ is
> asking itself whether or not it stops running and then looping if it
> says yes.
>
>

The definition of Halting has NO special case for 'pathological
self-reference'

If you add that you aren't talking Halting Problem, you are just talking
POOP.

FAIL

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

<8GkzJ.67666$cW6.42695@fx08.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 101
Message-ID: <8GkzJ.67666$cW6.42695@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: Thu, 30 Dec 2021 10:57:56 -0500
X-Received-Bytes: 4732
 by: Richard Damon - Thu, 30 Dec 2021 15:57 UTC

On 12/30/21 10:20 AM, olcott wrote:
> On 12/30/2021 8:19 AM, Richard Damon wrote:
>> On 12/29/21 11:51 PM, olcott wrote:
>>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>>> On 12/29/21 11:02 PM, olcott wrote:
>>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>
>>>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours
>>>>>> is not
>>>>>> the same as his (and mine), it should be different in some way.
>>>>>> (And we
>>>>>> can safely ignore it, since no one cares about your alternative
>>>>>> criteria.)
>>>>>>
>>>>>
>>>>> It has always been my criterion measure that halt deciders base
>>>>> their halt status decision on the pure simulation of their inputs.
>>>>>
>>>>> That your notational conventions very cleanly express this idea as
>>>>> applied to the Linz H is a good breakthrough.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> As soon as people understand that this same criterion measure
>>>>> applies recursively to every embedded_H at Ĥ.qx, then they will see
>>>>> how this criterion measure provides the means for embedded_H to
>>>>> correctly compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>>
>>>>
>>>> Yes each level can use the test to determine if the halt decider at
>>>> that level got the right answer or not.
>>>>
>>>> The issue is that when we are doing this check, you check JUST that
>>>> level, and not lower levels.
>>>
>>> No you are wrong.
>>>
>>>
>>
>> Source? (Some REAL reference)
>>
>
> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>
> The source is the correct reasoning of how the above criterion measure
> would be applied when H is copied to Ĥ.qx.

We copy the ALGORITHM of H, the detailed step by step instructions

>
> You keep thinking that a subsequent level UTM magically turns into
> embedded_H and aborts its simulation.

There IS no UTM in the machine. PERIOD. (unless H IS a UTM)

You are just showing how much of an idiot you are.

The condition to the right of the iff is the TEST that can be used to
verify that the code on the left did what was required.

EXAMPLE:
y = sqrt(x) iff Y*Y == x

sqrt does NOT somehow compute the square of its output.

The requirements statement on the behavior of H are NOT part of the
execution code, unless your implementation of H just copied them in, at
which point, your H FAILS as the UTM of a non-halting computation is
non-halting which makes H not answer in the required finite time.

FAIL.

It looks like your answer on how to make a valid halt decider is to just
assume you start with a valid halt decider and them add a bunch of crap
to it to hide the fact that you just assumed your answer.

The problem is, you are assuming the existence of something that just
doesn't exist.

FAIL.

>
>> Or is this just another of your "it must be this way or my proof
>> does't work".
>>
>> You are confusing HOW your decider works, which must answer in finite
>> time or it fails to meet the requirement, with the check for a right
>> answer, which might take unbounded time.
>>
>> FAIL.
>
>

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

<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 09:58:28 -0600
Date: Thu, 30 Dec 2021 09:58:26 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <AxkzJ.176966$Wkjc.130511@fx35.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
Lines: 88
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-V0X+E7a7oyIqTawELVqb8SSNFvXLCIKhH+m+WSqKrRcF1D1fe4jznTAvuThPkDS7k88grthbjdzPr4f!0fKS5l5xaDylVTQ/Jzm6K2Xqol8jPHxLFwOAHa7s20D1NxsEfsf/a57ououtEspkfL4qbQhNwepZ!0w==
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: 4678
 by: olcott - Thu, 30 Dec 2021 15:58 UTC

On 12/30/2021 9:48 AM, Richard Damon wrote:
>
> On 12/30/21 10:15 AM, olcott wrote:
>> On 12/29/2021 11:18 PM, André G. Isaak wrote:
>>> On 2021-12-29 21:51, olcott wrote:
>>>> On 12/29/2021 10:44 PM, Richard Damon wrote:
>>>>> On 12/29/21 11:02 PM, olcott wrote:
>>>>>> On 12/29/2021 1:16 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> *My criterion measure with Ben's notational conventions*
>>>>>>>> H.q0 wM w ⊢* H.qy  iff UTM(wM, w) halts
>>>>>>>> H.q0 wM w ⊢* H.qn  iff UTM(wM, w) does not halt
>>>>>>>
>>>>>>> It's not your criterion, it's mine.  It's also Linz's.  If yours
>>>>>>> is not
>>>>>>> the same as his (and mine), it should be different in some way.
>>>>>>> (And we
>>>>>>> can safely ignore it, since no one cares about your alternative
>>>>>>> criteria.)
>>>>>>>
>>>>>>
>>>>>> It has always been my criterion measure that halt deciders base
>>>>>> their halt status decision on the pure simulation of their inputs.
>>>>>>
>>>>>> That your notational conventions very cleanly express this idea as
>>>>>> applied to the Linz H is a good breakthrough.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> As soon as people understand that this same criterion measure
>>>>>> applies recursively to every embedded_H at Ĥ.qx, then they will
>>>>>> see how this criterion measure provides the means for embedded_H
>>>>>> to correctly compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn.
>>>>>>
>>>>>
>>>>> Yes each level can use the test to determine if the halt decider at
>>>>> that level got the right answer or not.
>>>>>
>>>>> The issue is that when we are doing this check, you check JUST that
>>>>> level, and not lower levels.
>>>>
>>>> No you are wrong.
>>>
>>> No, he isn't.
>>>
>>> The specification you give above (where YET AGAIN you omit the
>>> conditions)
>>
>> The conditions are provided by H, because H is copied to Ĥ.qx we need
>> not state them again.
>
> So a line Determine by H might be appropriate.
> Dropping the requirements is seen as one of your 'tricks' to allow allow
> your 'emdedded_H to deviate from H.
>
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> To make things simple we name the copy of H at Ĥ.qx embedded_H.
>
> Why does it need a new name?
>
>>
>> Because the criterion measure is applied as if the embedded_H at Ĥ.qx
>> was replaced by a UTM and the TM description of Ĥ would include a TM
>> description of this UTM the execution of Ĥ applied to ⟨Ĥ⟩ would
>>
>
> No, it is NOT.
>
> Where do you get that from?
>
> We don't care if embedded_H is 'Correct', we care that it give the same
> answer as H.
>

If it is correct and gives a different answer than H then it remains
correct even if it gives a different answer than H.

--
Copyright 2021 Pete Olcott

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

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

<Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>

 copy mid

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

 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: Thu, 30 Dec 2021 10:11:07 -0600
Date: Thu, 30 Dec 2021 10:11:06 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
<8GkzJ.67666$cW6.42695@fx08.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <8GkzJ.67666$cW6.42695@fx08.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-X74IHMn03GxXGpJx/TbKRs3Lgo3fPB5NRYt+0YKC4J7/LfW0dSEvpCoQXWBfDZXIPpegO1T7aXqlvlz!LfLZLDCgAgadbT9+hTk4HMya4PFXFDW13lEjmB9zAAiqu57v/uD1xseeA+pMYANZ8JBhwVuHxlED!ww==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4950
 by: olcott - Thu, 30 Dec 2021 16:11 UTC

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

Since it is obvious to humans that replacing embedded_H at Ĥ.qx with a
UTM would cause Ĥ applied to ⟨Ĥ⟩ to never stop running humans can see
that the pure simulation of N steps of the input to embedded_H would
never halt on their own for every N from 0 to ∞.

Thus correctly applying the criterion measure of H to the input to
embedded_H results in the "does not halt" criterion measure being met.

--
Copyright 2021 Pete Olcott

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

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

<1TkzJ.169794$SW5.45468@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 40
Message-ID: <1TkzJ.169794$SW5.45468@fx45.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 11:11:41 -0500
X-Received-Bytes: 2830
 by: Richard Damon - Thu, 30 Dec 2021 16:11 UTC

On 12/30/21 10:58 AM, olcott wrote:
> On 12/30/2021 9:48 AM, Richard Damon wrote:

>> We don't care if embedded_H is 'Correct', we care that it give the
>> same answer as H.
>>
>
> If it is correct and gives a different answer than H then it remains
> correct even if it gives a different answer than H.
>

But since it IS a copy of H, then if it gives a different answer than
'H' does, it shows that H fails to be a Computation, and thus Can't be a
Decider, and thus can't be a Halt Decider.

Your claim, is thus, PROOF, that your 'Proof' is a lie.

H and embedded_H can NOT give different answers (or H give an answer and
embedded_H get stuck in a loop) if H meets the requirements that are the
prerequisite for it to be the needed Halt Decider.

If you want to try to make that claim, you are going to first need to
prove that you can build an actual Turing machine that an exact copy of
which, when embedded in another calculation can give a different answer
to the exact same input.

Go ahead, try to do that. Use REAL Turing code as in a list of
current_state/current_input pairs to
next_state/new_tape_value/tape_motion mapping and some input that gives
this result.

Doesn't need to be a complicated machine, just one that gives two
different answers for the same algorithm and input tape.

You are claiming you can do this, so it should be simple to make a small
example that does this, right?

Or do you admit that you don't know a thing about what you are doing.

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

<J7lzJ.133156$7D4.56836@fx37.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr1.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx37.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com> <87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com> <VOazJ.207450$1d1.49719@fx99.iad> <8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <gejzJ.91885$Gco3.21338@fx01.iad> <aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com> <8GkzJ.67666$cW6.42695@fx08.iad> <Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 107
Message-ID: <J7lzJ.133156$7D4.56836@fx37.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Thu, 30 Dec 2021 11:29:29 -0500
X-Received-Bytes: 5609
 by: Richard Damon - Thu, 30 Dec 2021 16:29 UTC

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

And that means that H must NEVER halt its simulation of H^, and thus
fail to be a decider that gives an answer in finite time.

The problem is that H or embedded_H can NEVER see a pattern that
demonstrates an infitinte behavior pattern.

Any pattern they see that they think might be an infinite behavior
pattern is proved otherwise by seeing that if embedded_H (and thus H)
DID consider it to be an infinite behavior pattern and aborted its
simulation and returned non-halting, that then by construction H^ will
Halt and show that the pattern was NOT an infinite behavior pattern.

Thus there does NOT exist a finite pattern that H can see in its
simulation of H^ that actually proves that the behavior is infinite.

If you want to claim otherwise, produce the pattern.

>
> Since it is obvious to humans that replacing embedded_H at Ĥ.qx with a
> UTM would cause Ĥ applied to ⟨Ĥ⟩ to never stop running humans can see
> that the pure simulation of N steps of the input to embedded_H would
> never halt on their own for every N from 0 to ∞.

But since replacing embedded_H with a UTM is CHANGING the behavior of
H^, it is a non-sense thing to do.

Maybe why you suggest it.

>
> Thus correctly applying the criterion measure of H to the input to
> embedded_H results in the "does not halt" criterion measure being met.
>
>

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

<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 10:54:34 -0600
Date: Thu, 30 Dec 2021 10:54:32 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <1TkzJ.169794$SW5.45468@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com>
Lines: 33
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PDa7Xkh5Og9H40vKvMehiIKqHGlhqnqgfqKoCephqOUTVDiv+zusRdaF2a+/f63TFB+LGmW086qtL9O!ls1PS4+UmYet7uKTYFNAw/Ie1HrYhb3AiYcfe1M6Dyp/o9qp3xZQfD5rOBAQ+T9DIVK0ks/lIRJt!5w==
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: 2849
X-Received-Bytes: 3028
 by: olcott - Thu, 30 Dec 2021 16:54 UTC

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

This means that a finite string comparison performed by H will determine
that embedded_H is not identical to H.

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

--
Copyright 2021 Pete Olcott

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

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

<C-CdnTqrLLFIeVD8nZ2dnUU7-RWdnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 10:56:53 -0600
Date: Thu, 30 Dec 2021 10:56:52 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
<8GkzJ.67666$cW6.42695@fx08.iad>
<Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
<J7lzJ.133156$7D4.56836@fx37.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <J7lzJ.133156$7D4.56836@fx37.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <C-CdnTqrLLFIeVD8nZ2dnUU7-RWdnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YIuk0eHMuXq0iRhd0aBNFhCIcxzUb33HZAC8WyMC8oCfaA4vh5DHL6T61s9+IeEsB9Q29yTy+VsubV5!14Y3Fskj+zisbffs+++3aGRpVCwCxkFl6dbkRUpuHwa4/sEnEuN3c/ILBwtWkp22Usd3SN1z5lf4!lQ==
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: 4961
 by: olcott - Thu, 30 Dec 2021 16:56 UTC

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

The reason why I ignore most of your posts is that I stop at the very
first very stupid mistake.

--
Copyright 2021 Pete Olcott

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

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

<PTlzJ.235027$aF1.87891@fx98.iad>

 copy mid

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

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

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

Which is AFTER all the code that matters. embedded_H must still get to
H.qy or H.qn exactly like H does.

FAIL.

>
> This means that a finite string comparison performed by H will determine
> that embedded_H is not identical to H.
>

So. H doesn't know if it has that modification after it, and neither
will the embedded_H that that H is looking at, so both will act the same.

You just gave a reason that H gets the wrong behavior for embedded_H,
because embedded_H will end up doing exactly like H did, and thus H's
'Guess' that it could be different is wrong.

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

But since embedded_H does this, it was incorrect about the embedded_H
that it would simulate, and thus gets the wrong answer.

If embeded_H does this, then H must too, since H can't tell if it is an
unmodified H or an embeded_H, and that is why it gets the wrong answer.

FAIL.

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

<uWlzJ.235028$aF1.204961@fx98.iad>

 copy mid

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

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

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

You mean you stop at the first thing you can't answer.

I have PROVED this fact several times, and you haven't ever shown an error.

In fact, you almost NEVER show 'errors', just claim that people are wrong.

Your whole 'Proof' is riddled with errors, which have been pointed out
to you manytimes, but you just keep your head in the sand and ignore them.

You have proved yourself to be an ignorant man, ignorant apparently by
choice.

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

<nJ-dnXnUS_4mb1D8nZ2dnUU7-I_NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 11:56:11 -0600
Date: Thu, 30 Dec 2021 11:56:09 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.4.1
Subject: Re: Concise refutation of halting problem proofs V42 [ultimate
criterion measure]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com> <sqjfea$2pu$1@dont-email.me>
<KvudnfMTD4tnUVD8nZ2dnUU7-cnNnZ2d@giganews.com>
<AxkzJ.176966$Wkjc.130511@fx35.iad>
<84CdnTM0Q4S5SlD8nZ2dnUU7-dudnZ2d@giganews.com>
<1TkzJ.169794$SW5.45468@fx45.iad>
<C-CdnTurLLHXeVD8nZ2dnUU7-RXNnZ2d@giganews.com>
<PTlzJ.235027$aF1.87891@fx98.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <PTlzJ.235027$aF1.87891@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <nJ-dnXnUS_4mb1D8nZ2dnUU7-I_NnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-YMRST3KKlKwMq4gdI7irI97wlQAEW59OcXoFg2zE+Hm3s10qaMJpjlgj2bbKbqyDNdnwomm3zo/uMkC!eiyEYGMTqsyjOba1IMqJR6wkLgjszqpCJdAyjpJ/pGbCBXSnGGge1ShWbXUAZXjKA9STJ38dmO1n!bg==
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: 3427
 by: olcott - Thu, 30 Dec 2021 17:56 UTC

On 12/30/2021 11:20 AM, Richard Damon wrote:
>
> On 12/30/21 11:54 AM, olcott wrote:
>> On 12/30/2021 10:11 AM, Richard Damon wrote:
>>> On 12/30/21 10:58 AM, olcott wrote:
>>>> On 12/30/2021 9:48 AM, Richard Damon wrote:
>>>
>>>>> We don't care if embedded_H is 'Correct', we care that it give the
>>>>> same answer as H.
>>>>>
>>>>
>>>> If it is correct and gives a different answer than H then it remains
>>>> correct even if it gives a different answer than H.
>>>>
>>>
>>> But since it IS a copy of H, then if it gives a different answer than
>>> 'H' does, it shows that H fails to be a Computation, and thus Can't
>>> be a Decider, and thus can't be a Halt Decider.
>> H and embedded_H are able to give a different halt status
>> determinations on the basis that embedded_H had its copy of H
>> corrupted by the appended infinite loop.
>
> Which is AFTER all the code that matters. embedded_H must still get to
> H.qy or H.qn exactly like H does.
>
> FAIL.

*My criterion measure with Ben's notational conventions*
H.q0 wM w ⊢* H.qy iff UTM(wM, w) halts
H.q0 wM w ⊢* H.qn iff UTM(wM, w) does not halt

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

As soon as embedded_H sees that its simulated input Turing machine
description is about to invoke an identical copy of itself with
identical inputs to its own inputs it aborts its simulation of this
input and transitions to Ĥ.qn. When H performs this same process it does
not see any identical copy of itself.

--
Copyright 2021 Pete Olcott

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

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

<X8qdnaH5EPMZaVD8nZ2dnUU7-LXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 30 Dec 2021 12:03:48 -0600
Date: Thu, 30 Dec 2021 12:03: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 [compute the
mapping]
Content-Language: en-US
Newsgroups: comp.theory
References: <rvGdnaE3EuksDFH8nZ2dnUU7-UvNnZ2d@giganews.com>
<87ee5v5ihm.fsf@bsb.me.uk> <0MudnQ3m5Jb4slD8nZ2dnUU7-ePNnZ2d@giganews.com>
<VOazJ.207450$1d1.49719@fx99.iad>
<8_udnWa8pdFJp1D8nZ2dnUU7-T3NnZ2d@giganews.com>
<gejzJ.91885$Gco3.21338@fx01.iad>
<aZ6dnSrgLd23U1D8nZ2dnUU7-L3NnZ2d@giganews.com>
<8GkzJ.67666$cW6.42695@fx08.iad>
<Rp-dnSAmg8aGR1D8nZ2dnUU7-TPNnZ2d@giganews.com>
<J7lzJ.133156$7D4.56836@fx37.iad>
<C-CdnTqrLLFIeVD8nZ2dnUU7-RWdnZ2d@giganews.com>
<uWlzJ.235028$aF1.204961@fx98.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <uWlzJ.235028$aF1.204961@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <X8qdnaH5EPMZaVD8nZ2dnUU7-LXNnZ2d@giganews.com>
Lines: 105
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PyXIz8TifdQWAE+EPANI+vGWm9lSmpf15scfQbgOMKAWNySdUwtWKjJZEWI8jMXXTJfZ78wB8GydNeh!LEUTn/8hPNkickqt5oFZzizKUdAoq/FeTVUkWRpQnHbONIJbxC3VdYFk9AcnTxe60EpQ3qcZNVk8!tw==
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: 5910
 by: olcott - Thu, 30 Dec 2021 18:03 UTC

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

It is very stupid to say that
"H must NEVER halt its simulation of H^"

When I just said exactly how and when H does correctly halt its
simulation of Ĥ:

>>>> H and embedded_H continue a pure simulation of N steps of
>>>> their input until their input halts on its own or this input
>>>> demonstrates an infinite behavior pattern.

In the future I will simply ignore these stupid mistakes so that other
respondents only need to pay attention to my responses and can equally
ignore the clutter of your stupid mistakes.

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