Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Don't talk to me about disclaimers! I invented disclaimers!" -- The Censored Hacker


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

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

Pages:123456789101112
Concise refutation of halting problem proofs V52 [ Linz Proof ]

<ssh8vu$4c0$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: polco...@gmail.com (olcott)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Concise refutation of halting problem proofs V52 [ Linz Proof ]
Followup-To: comp.theory
Date: Sat, 22 Jan 2022 09:48:11 -0600
Organization: A noiseless patient Spider
Lines: 55
Message-ID: <ssh8vu$4c0$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 22 Jan 2022 15:48:14 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="dc1cf4ef75100646f2ff207bba193441";
logging-data="4480"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/MNMyz96aDbSNX+MGL0Baq"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Cancel-Lock: sha1:9N+ULtp5COFGrJ7ilm0EMn10TpY=
Content-Language: en-US
 by: olcott - Sat, 22 Jan 2022 15:48 UTC

Halting problem undecidability and infinitely nested simulation (V3)

We define Linz H to base its halt status decision on the behavior of its
pure simulation of N steps of its input. N is either the number of steps
that it takes for its simulated input to reach its final state or the
number of steps required for H to match an infinite behavior pattern
proving that the simulated input would never reach its own final state.
In this case H aborts the simulation of this input and transitions to H.qn.

The following simplifies the syntax for the definition of the Linz
Turing machine Ĥ, it is now a single machine with a single start state.
A copy of Linz H is embedded at Ĥ.qx.

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

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 what the
behavior of the UTM simulation of its inputs would be.

When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
keep repeating:
Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

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

This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
reach its final state conclusively proving that this simulated input
never halts. This enables embedded_H to abort the simulation of its
input and correctly transition to Ĥ.qn.

if embedded_H does correctly recognize an infinitely repeating behavior
pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied to ⟨Ĥ⟩ then
embedded_H is necessarily correct to abort the simulation of its input
and transition to Ĥ.qn.

Because a halt decider is a decider embedded_H is only accountable for
computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
behavior specified by these inputs. embedded_H is not accountable for
the behavior of the computation that it is contained within: Ĥ applied
to ⟨Ĥ⟩ because this is not an actual input to embedded_H.

Halting problem undecidability and infinitely nested simulation (V3)

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

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

Re: Concise refutation of halting problem proofs V52 [ Linz Proof ]

<7cWGJ.53033$Y01.48629@fx45.iad>

 copy mid

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

 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!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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Linz Proof ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ssh8vu$4c0$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 100
Message-ID: <7cWGJ.53033$Y01.48629@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: Sat, 22 Jan 2022 11:23:31 -0500
X-Received-Bytes: 4959
 by: Richard Damon - Sat, 22 Jan 2022 16:23 UTC

On 1/22/22 10:48 AM, olcott wrote:
> Halting problem undecidability and infinitely nested simulation (V3)

Take FIFTY TWO, I think you are stuck in an apparent infinite loop.

You keep on repeating the same basic mistakes.

>
> We define Linz H to base its halt status decision on the behavior of its
> pure simulation of N steps of its input. N is either the number of steps
> that it takes for its simulated input to reach its final state or the
> number of steps required for H to match an infinite behavior pattern
> proving that the simulated input would never reach its own final state.
> In this case H aborts the simulation of this input and transitions to H.qn.

Such a pattern NOT existing for the <H^> <H^> pattern, thus your H can't
correctly abort and becomes non-answering and thus FAILS to be a decider.

The non-existance has been proven and you have ignored that proof,
showing you have no counter for the proof.

If you want to claim such a pattern exists, you MUST provide it or
accept that your logic is just plain flawed as you are claiming the
existance of something that is impossible.

In effect, you are saying that if you have a halt decider for you halt
decider to use, you can write a halt decider.

FAIL.

>
> The following simplifies the syntax for the definition of the Linz
> Turing machine Ĥ, it is now a single machine with a single start state.
> A copy of Linz H is embedded at Ĥ.qx.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> 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 what the
> behavior of the UTM simulation of its inputs would be.
>
> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps would
> keep repeating:
> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...

But only if H never aborts, if H does abort, then the pattern is broken.

>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
> reach its final state conclusively proving that this simulated input
> never halts. This enables embedded_H to abort the simulation of its
> input and correctly transition to Ĥ.qn.

No, it doesn't, it shows that the H^ built on an H that doesn't abort
will not halt, but that H doesn't answer. If H does abort, and thus can
give the answer, the logic is incorrect.

FAIL.

>
> if embedded_H does correctly recognize an infinitely repeating behavior
> pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied to ⟨Ĥ⟩ then
> embedded_H is necessarily correct to abort the simulation of its input
> and transition to Ĥ.qn.

Which it can not do, as shown to be impossible.

>
> Because a halt decider is a decider embedded_H is only accountable for
> computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
> behavior specified by these inputs. embedded_H is not accountable for
> the behavior of the computation that it is contained within: Ĥ applied
> to ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>

As mentioned before, for the input <H^> <H^> when H^ is based on the H
that claims to correctly go to H.Qn, then UTM(<H^>,<H^>) is shown to
also go to H^.Qn and Halt, so the input that H IS accountable for
doesn't match the behavior that H assigns to it.

FAIL.

>
>
>
> Halting problem undecidability and infinitely nested simulation (V3)
>
> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>

You are still using Fairy Dust powered Unicorns as the basis of your proof.

FAIL.

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 10:29:33 -0600
Date: Sat, 22 Jan 2022 10:29:33 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7cWGJ.53033$Y01.48629@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
Lines: 118
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fPcbiFoicv+s/rEBbgmL9kR1HjGeChgka+IU8pn1VluHqSuKWT9jVFLiKcbNfr+QsBnohL2UmEsCjp2!8Wf96c2E5rO7cZ5IndFZ/cED3ySNXJernULF6IUQ3Jl6TK3CirokjhR9F4LO/oGQS/ycJRW114dZ
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: 5991
 by: olcott - Sat, 22 Jan 2022 16:29 UTC

On 1/22/2022 10:23 AM, Richard Damon wrote:
>
> On 1/22/22 10:48 AM, olcott wrote:
>> Halting problem undecidability and infinitely nested simulation (V3)
>
> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>
> You keep on repeating the same basic mistakes.
>
>>
>> We define Linz H to base its halt status decision on the behavior of
>> its pure simulation of N steps of its input. N is either the number of
>> steps that it takes for its simulated input to reach its final state
>> or the number of steps required for H to match an infinite behavior
>> pattern proving that the simulated input would never reach its own
>> final state. In this case H aborts the simulation of this input and
>> transitions to H.qn.
>
> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H can't
> correctly abort and becomes non-answering and thus FAILS to be a decider.
>
> The non-existance has been proven and you have ignored that proof,
> showing you have no counter for the proof.
>
> If you want to claim such a pattern exists, you MUST provide it or
> accept that your logic is just plain flawed as you are claiming the
> existance of something that is impossible.
>
> In effect, you are saying that if you have a halt decider for you halt
> decider to use, you can write a halt decider.
>
> FAIL.
>
>>
>> The following simplifies the syntax for the definition of the Linz
>> Turing machine Ĥ, it is now a single machine with a single start
>> state. A copy of Linz H is embedded at Ĥ.qx.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> 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
>> what the behavior of the UTM simulation of its inputs would be.
>>
>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>> would keep repeating:
>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>
> But only if H never aborts, if H does abort, then the pattern is broken.
>

YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH OF THIS:

The fact that there are no finite number of steps that the simulated
input to embedded_H would ever reach its final state conclusively proves
that embedded_H is correct to abort its simulation of this input and
transition to Ĥ.qn.

>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>> reach its final state conclusively proving that this simulated input
>> never halts. This enables embedded_H to abort the simulation of its
>> input and correctly transition to Ĥ.qn.
>
> No, it doesn't, it shows that the H^ built on an H that doesn't abort
> will not halt, but that H doesn't answer. If H does abort, and thus can
> give the answer, the logic is incorrect.
>
> FAIL.
>
>>
>> if embedded_H does correctly recognize an infinitely repeating
>> behavior pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied
>> to ⟨Ĥ⟩ then embedded_H is necessarily correct to abort the simulation
>> of its input and transition to Ĥ.qn.
>
> Which it can not do, as shown to be impossible.
>
>>
>> Because a halt decider is a decider embedded_H is only accountable for
>> computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
>> behavior specified by these inputs. embedded_H is not accountable for
>> the behavior of the computation that it is contained within: Ĥ applied
>> to ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>>
>
> As mentioned before, for the input <H^> <H^> when H^ is based on the H
> that claims to correctly go to H.Qn, then UTM(<H^>,<H^>) is shown to
> also go to H^.Qn and Halt, so the input that H IS accountable for
> doesn't match the behavior that H assigns to it.
>
> FAIL.
>
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V3)
>>
>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>
>>
>
> You are still using Fairy Dust powered Unicorns as the basis of your proof.
>
> 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 V52 [ Ignorant or Dishonest ]

<YqWGJ.17235$OU.1179@fx22.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx22.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 135
Message-ID: <YqWGJ.17235$OU.1179@fx22.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 11:39:20 -0500
X-Received-Bytes: 6581
 by: Richard Damon - Sat, 22 Jan 2022 16:39 UTC

On 1/22/22 11:29 AM, olcott wrote:
> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>
>> On 1/22/22 10:48 AM, olcott wrote:
>>> Halting problem undecidability and infinitely nested simulation (V3)
>>
>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>
>> You keep on repeating the same basic mistakes.
>>
>>>
>>> We define Linz H to base its halt status decision on the behavior of
>>> its pure simulation of N steps of its input. N is either the number
>>> of steps that it takes for its simulated input to reach its final
>>> state or the number of steps required for H to match an infinite
>>> behavior pattern proving that the simulated input would never reach
>>> its own final state. In this case H aborts the simulation of this
>>> input and transitions to H.qn.
>>
>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>> can't correctly abort and becomes non-answering and thus FAILS to be a
>> decider.
>>
>> The non-existance has been proven and you have ignored that proof,
>> showing you have no counter for the proof.
>>
>> If you want to claim such a pattern exists, you MUST provide it or
>> accept that your logic is just plain flawed as you are claiming the
>> existance of something that is impossible.
>>
>> In effect, you are saying that if you have a halt decider for you halt
>> decider to use, you can write a halt decider.
>>
>> FAIL.
>>
>>>
>>> The following simplifies the syntax for the definition of the Linz
>>> Turing machine Ĥ, it is now a single machine with a single start
>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> 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
>>> what the behavior of the UTM simulation of its inputs would be.
>>>
>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>> would keep repeating:
>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>
>> But only if H never aborts, if H does abort, then the pattern is broken.
>>
>
> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH OF THIS:
>
> The fact that there are no finite number of steps that the simulated
> input to embedded_H would ever reach its final state conclusively proves
> that embedded_H is correct to abort its simulation of this input and
> transition to Ĥ.qn.
>

The problem is that any H that aborts after a finite number of steps,
gives the wrong answer because it only looked to see if the input
doesn't halt at some specific finite number. To look at a larger number
of steps, you need to change H which the way you are applying the logic,
changes the input, and thus invalidates the previous conclusions.

You have NOT proven that a GIVEN input never halts for an arbitrary
number of steps that is based on an H that actually gives that answer.

Either you prove that for the H that NEVER aborts, and thus can't give
the right answer, is non-halting, or you use unsound logic to
incorrectly show that a given H that answers non-halting was correct,
when it can actually be shown that the input will halt, just at a number
of steps bigger than THAT H looked at.

So, you FAIL.

>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would never
>>> reach its final state conclusively proving that this simulated input
>>> never halts. This enables embedded_H to abort the simulation of its
>>> input and correctly transition to Ĥ.qn.
>>
>> No, it doesn't, it shows that the H^ built on an H that doesn't abort
>> will not halt, but that H doesn't answer. If H does abort, and thus
>> can give the answer, the logic is incorrect.
>>
>> FAIL.
>>
>>>
>>> if embedded_H does correctly recognize an infinitely repeating
>>> behavior pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied
>>> to ⟨Ĥ⟩ then embedded_H is necessarily correct to abort the simulation
>>> of its input and transition to Ĥ.qn.
>>
>> Which it can not do, as shown to be impossible.
>>
>>>
>>> Because a halt decider is a decider embedded_H is only accountable
>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis
>>> of the behavior specified by these inputs. embedded_H is not
>>> accountable for the behavior of the computation that it is contained
>>> within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual input to
>>> embedded_H.
>>>
>>
>> As mentioned before, for the input <H^> <H^> when H^ is based on the H
>> that claims to correctly go to H.Qn, then UTM(<H^>,<H^>) is shown to
>> also go to H^.Qn and Halt, so the input that H IS accountable for
>> doesn't match the behavior that H assigns to it.
>>
>> FAIL.
>>
>>>
>>>
>>>
>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>
>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>
>>>
>>
>> You are still using Fairy Dust powered Unicorns as the basis of your
>> proof.
>>
>> FAIL.
>
>

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!rocksolid2!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 10:47:01 -0600
Date: Sat, 22 Jan 2022 10:47:00 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad> <O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com> <YqWGJ.17235$OU.1179@fx22.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <YqWGJ.17235$OU.1179@fx22.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com>
Lines: 151
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gbr8sWClP0IZt6Sf9bTDZqwGtdbYl34ANN/QWACWK/elvNGFQa4wZhaSfvPDj/sSmNkHMTtFWDbzTy7!AsoQDupna4mNCzSyKK1tQLoxXZOSWe9ABpyIYiT1EspigQxmB7q0zs0JtkdGAAblpW6tbBna+dMd
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: 7426
 by: olcott - Sat, 22 Jan 2022 16:47 UTC

On 1/22/2022 10:39 AM, Richard Damon wrote:
> On 1/22/22 11:29 AM, olcott wrote:
>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>
>>> On 1/22/22 10:48 AM, olcott wrote:
>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>
>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>
>>> You keep on repeating the same basic mistakes.
>>>
>>>>
>>>> We define Linz H to base its halt status decision on the behavior of
>>>> its pure simulation of N steps of its input. N is either the number
>>>> of steps that it takes for its simulated input to reach its final
>>>> state or the number of steps required for H to match an infinite
>>>> behavior pattern proving that the simulated input would never reach
>>>> its own final state. In this case H aborts the simulation of this
>>>> input and transitions to H.qn.
>>>
>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>>> can't correctly abort and becomes non-answering and thus FAILS to be
>>> a decider.
>>>
>>> The non-existance has been proven and you have ignored that proof,
>>> showing you have no counter for the proof.
>>>
>>> If you want to claim such a pattern exists, you MUST provide it or
>>> accept that your logic is just plain flawed as you are claiming the
>>> existance of something that is impossible.
>>>
>>> In effect, you are saying that if you have a halt decider for you
>>> halt decider to use, you can write a halt decider.
>>>
>>> FAIL.
>>>
>>>>
>>>> The following simplifies the syntax for the definition of the Linz
>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> 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
>>>> what the behavior of the UTM simulation of its inputs would be.
>>>>
>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>> would keep repeating:
>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>
>>> But only if H never aborts, if H does abort, then the pattern is broken.
>>>
>>
>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH OF
>> THIS:
>>
>> The fact that there are no finite number of steps that the simulated
>> input to embedded_H would ever reach its final state conclusively
>> proves that embedded_H is correct to abort its simulation of this
>> input and transition to Ĥ.qn.
>>
>
> The problem is that any H that aborts after a finite number of steps,
> gives the wrong answer because it only looked to see if the input
> doesn't halt at some specific finite number.

OK IGNORANT it is. When there exists no finite (or infinite) number of
steps such that the simulated input to embedded_H reaches its final
state then we know that this simulated input does not halt.

> To look at a larger number
> of steps, you need to change H which the way you are applying the logic,
> changes the input, and thus invalidates the previous conclusions.
>
> You have NOT proven that a GIVEN input never halts for an arbitrary
> number of steps that is based on an H that actually gives that answer.
>
> Either you prove that for the H that NEVER aborts, and thus can't give
> the right answer, is non-halting, or you use unsound logic to
> incorrectly show that a given H that answers non-halting was correct,
> when it can actually be shown that the input will halt, just at a number
> of steps bigger than THAT H looked at.
>
> So, you FAIL.
>
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>> never reach its final state conclusively proving that this simulated
>>>> input never halts. This enables embedded_H to abort the simulation
>>>> of its input and correctly transition to Ĥ.qn.
>>>
>>> No, it doesn't, it shows that the H^ built on an H that doesn't abort
>>> will not halt, but that H doesn't answer. If H does abort, and thus
>>> can give the answer, the logic is incorrect.
>>>
>>> FAIL.
>>>
>>>>
>>>> if embedded_H does correctly recognize an infinitely repeating
>>>> behavior pattern in the behavior of its simulated input: ⟨Ĥ⟩ applied
>>>> to ⟨Ĥ⟩ then embedded_H is necessarily correct to abort the
>>>> simulation of its input and transition to Ĥ.qn.
>>>
>>> Which it can not do, as shown to be impossible.
>>>
>>>>
>>>> Because a halt decider is a decider embedded_H is only accountable
>>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis
>>>> of the behavior specified by these inputs. embedded_H is not
>>>> accountable for the behavior of the computation that it is contained
>>>> within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual input to
>>>> embedded_H.
>>>>
>>>
>>> As mentioned before, for the input <H^> <H^> when H^ is based on the
>>> H that claims to correctly go to H.Qn, then UTM(<H^>,<H^>) is shown
>>> to also go to H^.Qn and Halt, so the input that H IS accountable for
>>> doesn't match the behavior that H assigns to it.
>>>
>>> FAIL.
>>>
>>>>
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>
>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>
>>>>
>>>
>>> You are still using Fairy Dust powered Unicorns as the basis of your
>>> proof.
>>>
>>> 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 V52 [ Ignorant or Dishonest ]

<7XWGJ.2501$2V.1175@fx07.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx07.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 178
Message-ID: <7XWGJ.2501$2V.1175@fx07.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 12:13:39 -0500
X-Received-Bytes: 8188
X-Original-Bytes: 8055
 by: Richard Damon - Sat, 22 Jan 2022 17:13 UTC

On 1/22/22 11:47 AM, olcott wrote:
> On 1/22/2022 10:39 AM, Richard Damon wrote:
>> On 1/22/22 11:29 AM, olcott wrote:
>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>
>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>
>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>
>>>> You keep on repeating the same basic mistakes.
>>>>
>>>>>
>>>>> We define Linz H to base its halt status decision on the behavior
>>>>> of its pure simulation of N steps of its input. N is either the
>>>>> number of steps that it takes for its simulated input to reach its
>>>>> final state or the number of steps required for H to match an
>>>>> infinite behavior pattern proving that the simulated input would
>>>>> never reach its own final state. In this case H aborts the
>>>>> simulation of this input and transitions to H.qn.
>>>>
>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>>>> can't correctly abort and becomes non-answering and thus FAILS to be
>>>> a decider.
>>>>
>>>> The non-existance has been proven and you have ignored that proof,
>>>> showing you have no counter for the proof.
>>>>
>>>> If you want to claim such a pattern exists, you MUST provide it or
>>>> accept that your logic is just plain flawed as you are claiming the
>>>> existance of something that is impossible.
>>>>
>>>> In effect, you are saying that if you have a halt decider for you
>>>> halt decider to use, you can write a halt decider.
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>>> The following simplifies the syntax for the definition of the Linz
>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> 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
>>>>> what the behavior of the UTM simulation of its inputs would be.
>>>>>
>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>> would keep repeating:
>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>
>>>> But only if H never aborts, if H does abort, then the pattern is
>>>> broken.
>>>>
>>>
>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH OF
>>> THIS:
>>>
>>> The fact that there are no finite number of steps that the simulated
>>> input to embedded_H would ever reach its final state conclusively
>>> proves that embedded_H is correct to abort its simulation of this
>>> input and transition to Ĥ.qn.
>>>
>>
>> The problem is that any H that aborts after a finite number of steps,
>> gives the wrong answer because it only looked to see if the input
>> doesn't halt at some specific finite number.
>
> OK IGNORANT it is. When there exists no finite (or infinite) number of
> steps such that the simulated input to embedded_H reaches its final
> state then we know that this simulated input does not halt.

And the only case when that happens is when H does not abort its simulation,

Since a copy of H is part of the input, you can't first look at the
input based on an H that doesn't abort and then change your H.

That just shows that for Hn that doesn't abort, and Ha that does, and
the Hn^ and Ha^ built from them repectfully that we have:

Yes Hn^(Hn^) is non-Halitng, but H(<Hn^>,<Hn^>) never can give that answer.

Yes Ha(<Hn^>,<Hn^) can correctly determine that Hn^ is non-halting, but
that isn't the case needed to disprove Linz.

Your Ha(<Ha^>,<H^>) also says this is non-halting, but if we look at the
behavior of Ha^, we see that becaue Ha when to H.Qn, that so does Ha^ go
to Ha^.Qn and thus Ha^(<Ha^>) is Halting, and thus Ha was WRONG.

You get you choise:

Hn(<Hn^>,<Hn^>) which doesn't answer, and thus fails, or

Ha(<Hn^>,<Hn^>) which answer the wrong question, or

Ha(<Ha^>,<Ha^>) which gives the wrong answer.

Which way do you chose to be wrong.

FAIL.

>
>> To look at a larger number of steps, you need to change H which the
>> way you are applying the logic, changes the input, and thus
>> invalidates the previous conclusions.
>>
>> You have NOT proven that a GIVEN input never halts for an arbitrary
>> number of steps that is based on an H that actually gives that answer.
>>
>> Either you prove that for the H that NEVER aborts, and thus can't give
>> the right answer, is non-halting, or you use unsound logic to
>> incorrectly show that a given H that answers non-halting was correct,
>> when it can actually be shown that the input will halt, just at a
>> number of steps bigger than THAT H looked at.
>>
>> So, you FAIL.
>>
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> This shows that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ would
>>>>> never reach its final state conclusively proving that this
>>>>> simulated input never halts. This enables embedded_H to abort the
>>>>> simulation of its input and correctly transition to Ĥ.qn.
>>>>
>>>> No, it doesn't, it shows that the H^ built on an H that doesn't
>>>> abort will not halt, but that H doesn't answer. If H does abort, and
>>>> thus can give the answer, the logic is incorrect.
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>>> if embedded_H does correctly recognize an infinitely repeating
>>>>> behavior pattern in the behavior of its simulated input: ⟨Ĥ⟩
>>>>> applied to ⟨Ĥ⟩ then embedded_H is necessarily correct to abort the
>>>>> simulation of its input and transition to Ĥ.qn.
>>>>
>>>> Which it can not do, as shown to be impossible.
>>>>
>>>>>
>>>>> Because a halt decider is a decider embedded_H is only accountable
>>>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis
>>>>> of the behavior specified by these inputs. embedded_H is not
>>>>> accountable for the behavior of the computation that it is
>>>>> contained within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual
>>>>> input to embedded_H.
>>>>>
>>>>
>>>> As mentioned before, for the input <H^> <H^> when H^ is based on the
>>>> H that claims to correctly go to H.Qn, then UTM(<H^>,<H^>) is shown
>>>> to also go to H^.Qn and Halt, so the input that H IS accountable for
>>>> doesn't match the behavior that H assigns to it.
>>>>
>>>> FAIL.
>>>>
>>>>>
>>>>>
>>>>>
>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>
>>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>>
>>>>>
>>>>
>>>> You are still using Fairy Dust powered Unicorns as the basis of your
>>>> proof.
>>>>
>>>> FAIL.
>>>
>>>
>>
>
>

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 11:19:23 -0600
Date: Sat, 22 Jan 2022 11:19:22 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7XWGJ.2501$2V.1175@fx07.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
Lines: 95
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Or4OCcfXX7PggWWR7iHGj1/vdJ0P6ZU75BtriIZ+DDMdQUiGg3umECr26EQtlkwDtnZWxJ/bKKiGTzb!mv/sDJi0Ayay3DPzrF5yDyY16FbNIaAWTf+9kCOq6hC1ghf8rdPmIfAEabQklVwLSH12Vpf4MYLO
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: 5491
 by: olcott - Sat, 22 Jan 2022 17:19 UTC

On 1/22/2022 11:13 AM, Richard Damon wrote:
> On 1/22/22 11:47 AM, olcott wrote:
>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>> On 1/22/22 11:29 AM, olcott wrote:
>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>
>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>
>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>>
>>>>> You keep on repeating the same basic mistakes.
>>>>>
>>>>>>
>>>>>> We define Linz H to base its halt status decision on the behavior
>>>>>> of its pure simulation of N steps of its input. N is either the
>>>>>> number of steps that it takes for its simulated input to reach its
>>>>>> final state or the number of steps required for H to match an
>>>>>> infinite behavior pattern proving that the simulated input would
>>>>>> never reach its own final state. In this case H aborts the
>>>>>> simulation of this input and transitions to H.qn.
>>>>>
>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>>>>> can't correctly abort and becomes non-answering and thus FAILS to
>>>>> be a decider.
>>>>>
>>>>> The non-existance has been proven and you have ignored that proof,
>>>>> showing you have no counter for the proof.
>>>>>
>>>>> If you want to claim such a pattern exists, you MUST provide it or
>>>>> accept that your logic is just plain flawed as you are claiming the
>>>>> existance of something that is impossible.
>>>>>
>>>>> In effect, you are saying that if you have a halt decider for you
>>>>> halt decider to use, you can write a halt decider.
>>>>>
>>>>> FAIL.
>>>>>
>>>>>>
>>>>>> The following simplifies the syntax for the definition of the Linz
>>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> 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
>>>>>> what the behavior of the UTM simulation of its inputs would be.
>>>>>>
>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>> would keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> But only if H never aborts, if H does abort, then the pattern is
>>>>> broken.
>>>>>
>>>>
>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH OF
>>>> THIS:
>>>>
>>>> The fact that there are no finite number of steps that the simulated
>>>> input to embedded_H would ever reach its final state conclusively
>>>> proves that embedded_H is correct to abort its simulation of this
>>>> input and transition to Ĥ.qn.
>>>>
>>>
>>> The problem is that any H that aborts after a finite number of steps,
>>> gives the wrong answer because it only looked to see if the input
>>> doesn't halt at some specific finite number.
>>
>> OK IGNORANT it is. When there exists no finite (or infinite) number of
>> steps such that the simulated input to embedded_H reaches its final
>> state then we know that this simulated input does not halt.
>
> And the only case when that happens is when H does not abort its
> simulation,
>
WRONG !!! That happens in every possible case. The simulated input to
embedded_H cannot possibly ever reach its final state NO MATTER WHAT !!!

Halting problem undecidability and infinitely nested simulation (V3)

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

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<MJudnaCsk81koXH8nZ2dnUU7-cNQAAAA@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.lang.prolog sci.math.symbolic sci.philosophy
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: Sat, 22 Jan 2022 11:20:56 -0600
Date: Sat, 22 Jan 2022 11:20:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.lang.prolog,sci.math.symbolic,sci.philosophy
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7XWGJ.2501$2V.1175@fx07.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <MJudnaCsk81koXH8nZ2dnUU7-cNQAAAA@giganews.com>
Lines: 95
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gKejOxRPkJ96ariMYUrGJFpbMipdVc+uoZBlwUIaFF3O7f7PyCygDGNLZGODJH78OjgPQxzeKruVRpK!dxmsinOWTj9Pd4ro0QhTJjKhdh9MOzJjLcsJHdkg54jXaPFWH1LgQ8MuQJ4gdnhp/MOB4XVQPhrG
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: 5503
 by: olcott - Sat, 22 Jan 2022 17:20 UTC

On 1/22/2022 11:13 AM, Richard Damon wrote:
> On 1/22/22 11:47 AM, olcott wrote:
>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>> On 1/22/22 11:29 AM, olcott wrote:
>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>
>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>
>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>>
>>>>> You keep on repeating the same basic mistakes.
>>>>>
>>>>>>
>>>>>> We define Linz H to base its halt status decision on the behavior
>>>>>> of its pure simulation of N steps of its input. N is either the
>>>>>> number of steps that it takes for its simulated input to reach its
>>>>>> final state or the number of steps required for H to match an
>>>>>> infinite behavior pattern proving that the simulated input would
>>>>>> never reach its own final state. In this case H aborts the
>>>>>> simulation of this input and transitions to H.qn.
>>>>>
>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>>>>> can't correctly abort and becomes non-answering and thus FAILS to
>>>>> be a decider.
>>>>>
>>>>> The non-existance has been proven and you have ignored that proof,
>>>>> showing you have no counter for the proof.
>>>>>
>>>>> If you want to claim such a pattern exists, you MUST provide it or
>>>>> accept that your logic is just plain flawed as you are claiming the
>>>>> existance of something that is impossible.
>>>>>
>>>>> In effect, you are saying that if you have a halt decider for you
>>>>> halt decider to use, you can write a halt decider.
>>>>>
>>>>> FAIL.
>>>>>
>>>>>>
>>>>>> The following simplifies the syntax for the definition of the Linz
>>>>>> Turing machine Ĥ, it is now a single machine with a single start
>>>>>> state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> 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
>>>>>> what the behavior of the UTM simulation of its inputs would be.
>>>>>>
>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>> would keep repeating:
>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>
>>>>> But only if H never aborts, if H does abort, then the pattern is
>>>>> broken.
>>>>>
>>>>
>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH OF
>>>> THIS:
>>>>
>>>> The fact that there are no finite number of steps that the simulated
>>>> input to embedded_H would ever reach its final state conclusively
>>>> proves that embedded_H is correct to abort its simulation of this
>>>> input and transition to Ĥ.qn.
>>>>
>>>
>>> The problem is that any H that aborts after a finite number of steps,
>>> gives the wrong answer because it only looked to see if the input
>>> doesn't halt at some specific finite number.
>>
>> OK IGNORANT it is. When there exists no finite (or infinite) number of
>> steps such that the simulated input to embedded_H reaches its final
>> state then we know that this simulated input does not halt.
>
> And the only case when that happens is when H does not abort its
> simulation,
>
WRONG !!! That happens in every possible case. The simulated input to
embedded_H cannot possibly ever reach its final state NO MATTER WHAT !!!

Halting problem undecidability and infinitely nested simulation (V3)

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

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<8eXGJ.53034$Y01.12453@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!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!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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 103
Message-ID: <8eXGJ.53034$Y01.12453@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: Sat, 22 Jan 2022 12:33:56 -0500
X-Received-Bytes: 5595
 by: Richard Damon - Sat, 22 Jan 2022 17:33 UTC

On 1/22/22 12:19 PM, olcott wrote:
> On 1/22/2022 11:13 AM, Richard Damon wrote:
>> On 1/22/22 11:47 AM, olcott wrote:
>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>>
>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>>>
>>>>>> You keep on repeating the same basic mistakes.
>>>>>>
>>>>>>>
>>>>>>> We define Linz H to base its halt status decision on the behavior
>>>>>>> of its pure simulation of N steps of its input. N is either the
>>>>>>> number of steps that it takes for its simulated input to reach
>>>>>>> its final state or the number of steps required for H to match an
>>>>>>> infinite behavior pattern proving that the simulated input would
>>>>>>> never reach its own final state. In this case H aborts the
>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>
>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>>>>>> can't correctly abort and becomes non-answering and thus FAILS to
>>>>>> be a decider.
>>>>>>
>>>>>> The non-existance has been proven and you have ignored that proof,
>>>>>> showing you have no counter for the proof.
>>>>>>
>>>>>> If you want to claim such a pattern exists, you MUST provide it or
>>>>>> accept that your logic is just plain flawed as you are claiming
>>>>>> the existance of something that is impossible.
>>>>>>
>>>>>> In effect, you are saying that if you have a halt decider for you
>>>>>> halt decider to use, you can write a halt decider.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>>
>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>> Linz Turing machine Ĥ, it is now a single machine with a single
>>>>>>> start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> 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 what the behavior of the UTM simulation of its inputs would be.
>>>>>>>
>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>>> would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> But only if H never aborts, if H does abort, then the pattern is
>>>>>> broken.
>>>>>>
>>>>>
>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH
>>>>> OF THIS:
>>>>>
>>>>> The fact that there are no finite number of steps that the
>>>>> simulated input to embedded_H would ever reach its final state
>>>>> conclusively proves that embedded_H is correct to abort its
>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>
>>>>
>>>> The problem is that any H that aborts after a finite number of
>>>> steps, gives the wrong answer because it only looked to see if the
>>>> input doesn't halt at some specific finite number.
>>>
>>> OK IGNORANT it is. When there exists no finite (or infinite) number
>>> of steps such that the simulated input to embedded_H reaches its
>>> final state then we know that this simulated input does not halt.
>>
>> And the only case when that happens is when H does not abort its
>> simulation,
>>
> WRONG !!!  That happens in every possible case. The simulated input to
> embedded_H cannot possibly ever reach its final state NO MATTER WHAT !!!

But if H/embedded_H aborts its simulation, it doesn't matter if IT sees
it or not, as it isn't then a UTM any longer.

If H aborts its simulation and goes to H.Qn then H^ applied to <H^> and
the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.

THAT is what matters, and shows that H was wromg.

You keep on believing a false source of 'truth'.

FAIL.
>
>
>
> Halting problem undecidability and infinitely nested simulation (V3)
>
> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<ofXGJ.53035$Y01.12920@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaCsk81koXH8nZ2dnUU7-cNQAAAA@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <MJudnaCsk81koXH8nZ2dnUU7-cNQAAAA@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 106
Message-ID: <ofXGJ.53035$Y01.12920@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: Sat, 22 Jan 2022 12:35:16 -0500
X-Received-Bytes: 5636
X-Original-Bytes: 5503
 by: Richard Damon - Sat, 22 Jan 2022 17:35 UTC

On 1/22/22 12:20 PM, olcott wrote:
> On 1/22/2022 11:13 AM, Richard Damon wrote:
>> On 1/22/22 11:47 AM, olcott wrote:
>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>>>
>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>>>
>>>>>> You keep on repeating the same basic mistakes.
>>>>>>
>>>>>>>
>>>>>>> We define Linz H to base its halt status decision on the behavior
>>>>>>> of its pure simulation of N steps of its input. N is either the
>>>>>>> number of steps that it takes for its simulated input to reach
>>>>>>> its final state or the number of steps required for H to match an
>>>>>>> infinite behavior pattern proving that the simulated input would
>>>>>>> never reach its own final state. In this case H aborts the
>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>
>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your H
>>>>>> can't correctly abort and becomes non-answering and thus FAILS to
>>>>>> be a decider.
>>>>>>
>>>>>> The non-existance has been proven and you have ignored that proof,
>>>>>> showing you have no counter for the proof.
>>>>>>
>>>>>> If you want to claim such a pattern exists, you MUST provide it or
>>>>>> accept that your logic is just plain flawed as you are claiming
>>>>>> the existance of something that is impossible.
>>>>>>
>>>>>> In effect, you are saying that if you have a halt decider for you
>>>>>> halt decider to use, you can write a halt decider.
>>>>>>
>>>>>> FAIL.
>>>>>>
>>>>>>>
>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>> Linz Turing machine Ĥ, it is now a single machine with a single
>>>>>>> start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> 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 what the behavior of the UTM simulation of its inputs would be.
>>>>>>>
>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these steps
>>>>>>> would keep repeating:
>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>
>>>>>> But only if H never aborts, if H does abort, then the pattern is
>>>>>> broken.
>>>>>>
>>>>>
>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH
>>>>> OF THIS:
>>>>>
>>>>> The fact that there are no finite number of steps that the
>>>>> simulated input to embedded_H would ever reach its final state
>>>>> conclusively proves that embedded_H is correct to abort its
>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>
>>>>
>>>> The problem is that any H that aborts after a finite number of
>>>> steps, gives the wrong answer because it only looked to see if the
>>>> input doesn't halt at some specific finite number.
>>>
>>> OK IGNORANT it is. When there exists no finite (or infinite) number
>>> of steps such that the simulated input to embedded_H reaches its
>>> final state then we know that this simulated input does not halt.
>>
>> And the only case when that happens is when H does not abort its
>> simulation,
>>
> WRONG !!!  That happens in every possible case. The simulated input to
> embedded_H cannot possibly ever reach its final state NO MATTER WHAT !!!
>
>
But if H/embedded_H aborts its simulation, it doesn't matter if IT sees
it or not, as it isn't then a UTM any longer.

If H aborts its simulation and goes to H.Qn then H^ applied to <H^> and
the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.

THAT is what matters, and shows that H was wromg.

You keep on believing a false source of 'truth'.

FAIL.

Who is the one being dishonest, the one using the ACTUAL source of
truth, or the one pushing the answer of a false prophet?
>
> Halting problem undecidability and infinitely nested simulation (V3)
>
> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 22 Jan 2022 11:53:13 -0600
Date: Sat, 22 Jan 2022 11:53:12 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <8eXGJ.53034$Y01.12453@fx45.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
Lines: 126
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-By8cKaAQZqr9U19RVWYlzzaX2tA9jwKzYRDBagzWxImJ76HOVqqpo1KblCse31NJOX+Ui+bvK92+fCU!jvH7jtcHivYPOs8YQsNdx1o4Dcu9UAt0alwzR/TQexsW8wIXhnB+u+RbayFz9mbnJ/hEGrufpLys
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: 6841
 by: olcott - Sat, 22 Jan 2022 17:53 UTC

On 1/22/2022 11:33 AM, Richard Damon wrote:
> On 1/22/22 12:19 PM, olcott wrote:
>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>> On 1/22/22 11:47 AM, olcott wrote:
>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>> (V3)
>>>>>>>
>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>>>>
>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>
>>>>>>>>
>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>> behavior of its pure simulation of N steps of its input. N is
>>>>>>>> either the number of steps that it takes for its simulated input
>>>>>>>> to reach its final state or the number of steps required for H
>>>>>>>> to match an infinite behavior pattern proving that the simulated
>>>>>>>> input would never reach its own final state. In this case H
>>>>>>>> aborts the simulation of this input and transitions to H.qn.
>>>>>>>
>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your
>>>>>>> H can't correctly abort and becomes non-answering and thus FAILS
>>>>>>> to be a decider.
>>>>>>>
>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>
>>>>>>> If you want to claim such a pattern exists, you MUST provide it
>>>>>>> or accept that your logic is just plain flawed as you are
>>>>>>> claiming the existance of something that is impossible.
>>>>>>>
>>>>>>> In effect, you are saying that if you have a halt decider for you
>>>>>>> halt decider to use, you can write a halt decider.
>>>>>>>
>>>>>>> FAIL.
>>>>>>>
>>>>>>>>
>>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>>> Linz Turing machine Ĥ, it is now a single machine with a single
>>>>>>>> start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> 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 what the behavior of the UTM simulation of its inputs would be.
>>>>>>>>
>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these
>>>>>>>> steps would keep repeating:
>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>
>>>>>>> But only if H never aborts, if H does abort, then the pattern is
>>>>>>> broken.
>>>>>>>
>>>>>>
>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH
>>>>>> OF THIS:
>>>>>>
>>>>>> The fact that there are no finite number of steps that the
>>>>>> simulated input to embedded_H would ever reach its final state
>>>>>> conclusively proves that embedded_H is correct to abort its
>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>
>>>>>
>>>>> The problem is that any H that aborts after a finite number of
>>>>> steps, gives the wrong answer because it only looked to see if the
>>>>> input doesn't halt at some specific finite number.
>>>>
>>>> OK IGNORANT it is. When there exists no finite (or infinite) number
>>>> of steps such that the simulated input to embedded_H reaches its
>>>> final state then we know that this simulated input does not halt.
>>>
>>> And the only case when that happens is when H does not abort its
>>> simulation,
>>>
>> WRONG !!!  That happens in every possible case. The simulated input to
>> embedded_H cannot possibly ever reach its final state NO MATTER WHAT !!!
>
> But if H/embedded_H aborts its simulation, it doesn't matter if IT sees
> it or not, as it isn't then a UTM any longer.
>

It remains true (invariant) that the simulated input to embedded_H
cannot possibly ever reach its final state no matter what embedded_H
does, thus conclusively proving that this input never halts.

> If H aborts its simulation and goes to H.Qn then H^ applied to <H^> and
> the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>

Because a halt decider is a decider embedded_H is only accountable for
computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
behavior specified by these inputs. embedded_H is not accountable for
the behavior of the computation that it is contained within: Ĥ applied
to ⟨Ĥ⟩ because this is not an actual input to embedded_H.

> THAT is what matters, and shows that H was wromg.
>
> You keep on believing a false source of 'truth'.
>
> FAIL.
>>
>>
>>
>> Halting problem undecidability and infinitely nested simulation (V3)
>>
>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>
>>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<pWXGJ.18523$VK4.16193@fx08.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!2.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer01.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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 137
Message-ID: <pWXGJ.18523$VK4.16193@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: Sat, 22 Jan 2022 13:21:09 -0500
X-Received-Bytes: 6989
X-Original-Bytes: 6856
 by: Richard Damon - Sat, 22 Jan 2022 18:21 UTC

On 1/22/22 12:53 PM, olcott wrote:
> On 1/22/2022 11:33 AM, Richard Damon wrote:
>> On 1/22/22 12:19 PM, olcott wrote:
>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>> Halting problem undecidability and infinitely nested simulation
>>>>>>>>> (V3)
>>>>>>>>
>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite loop.
>>>>>>>>
>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>> behavior of its pure simulation of N steps of its input. N is
>>>>>>>>> either the number of steps that it takes for its simulated
>>>>>>>>> input to reach its final state or the number of steps required
>>>>>>>>> for H to match an infinite behavior pattern proving that the
>>>>>>>>> simulated input would never reach its own final state. In this
>>>>>>>>> case H aborts the simulation of this input and transitions to
>>>>>>>>> H.qn.
>>>>>>>>
>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus your
>>>>>>>> H can't correctly abort and becomes non-answering and thus FAILS
>>>>>>>> to be a decider.
>>>>>>>>
>>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>>
>>>>>>>> If you want to claim such a pattern exists, you MUST provide it
>>>>>>>> or accept that your logic is just plain flawed as you are
>>>>>>>> claiming the existance of something that is impossible.
>>>>>>>>
>>>>>>>> In effect, you are saying that if you have a halt decider for
>>>>>>>> you halt decider to use, you can write a halt decider.
>>>>>>>>
>>>>>>>> FAIL.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>>>> Linz Turing machine Ĥ, it is now a single machine with a single
>>>>>>>>> start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> 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 what the behavior of the UTM simulation of its inputs would be.
>>>>>>>>>
>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these
>>>>>>>>> steps would keep repeating:
>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>
>>>>>>>> But only if H never aborts, if H does abort, then the pattern is
>>>>>>>> broken.
>>>>>>>>
>>>>>>>
>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE TRUTH
>>>>>>> OF THIS:
>>>>>>>
>>>>>>> The fact that there are no finite number of steps that the
>>>>>>> simulated input to embedded_H would ever reach its final state
>>>>>>> conclusively proves that embedded_H is correct to abort its
>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>
>>>>>>
>>>>>> The problem is that any H that aborts after a finite number of
>>>>>> steps, gives the wrong answer because it only looked to see if the
>>>>>> input doesn't halt at some specific finite number.
>>>>>
>>>>> OK IGNORANT it is. When there exists no finite (or infinite) number
>>>>> of steps such that the simulated input to embedded_H reaches its
>>>>> final state then we know that this simulated input does not halt.
>>>>
>>>> And the only case when that happens is when H does not abort its
>>>> simulation,
>>>>
>>> WRONG !!!  That happens in every possible case. The simulated input
>>> to embedded_H cannot possibly ever reach its final state NO MATTER
>>> WHAT !!!
>>
>> But if H/embedded_H aborts its simulation, it doesn't matter if IT
>> sees it or not, as it isn't then a UTM any longer.
>>
>
> It remains true (invariant) that the simulated input to embedded_H
> cannot possibly ever reach its final state no matter what embedded_H
> does, thus conclusively proving that this input never halts.
>
>> If H aborts its simulation and goes to H.Qn then H^ applied to <H^>
>> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>
>
> Because a halt decider is a decider embedded_H is only accountable for
> computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
> behavior specified by these inputs. embedded_H is not accountable for
> the behavior of the computation that it is contained within: Ĥ applied
> to ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>

Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by the
computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn and Halt.

THAT is the defined behavior of the actual input to H.

I don't see where you get that H^ applied to <H^> is not the computaiton
represented by the input string <H^> <H^>, if you claim is true, then
you haven't defined your decider or your representatoin correctly and
are lying that you have.

FAIL.

>> THAT is what matters, and shows that H was wromg.
>>
>> You keep on believing a false source of 'truth'.
>>
>> FAIL.
>>>
>>>
>>>
>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>
>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>
>>>
>>
>
>

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 12:26:33 -0600
Date: Sat, 22 Jan 2022 12:26:32 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <pWXGJ.18523$VK4.16193@fx08.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com>
Lines: 157
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NKu/lfmMVs1bGwTFxU+7TymcnGLpJMATPVD6HmM9RJnEBCt+xsT/+e0c/dClbIPsKbv8X3qe1wKjvad!P+MjF6nCUTgAXN8n4qpJgva2rN44g4c8UJ+0SigpBASyXNWFOGTXjPQ/4NL2KPfIYtyF3/Eo0rr7
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: 7994
 by: olcott - Sat, 22 Jan 2022 18:26 UTC

On 1/22/2022 12:21 PM, Richard Damon wrote:
> On 1/22/22 12:53 PM, olcott wrote:
>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>> On 1/22/22 12:19 PM, olcott wrote:
>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>> simulation (V3)
>>>>>>>>>
>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite
>>>>>>>>> loop.
>>>>>>>>>
>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>> behavior of its pure simulation of N steps of its input. N is
>>>>>>>>>> either the number of steps that it takes for its simulated
>>>>>>>>>> input to reach its final state or the number of steps required
>>>>>>>>>> for H to match an infinite behavior pattern proving that the
>>>>>>>>>> simulated input would never reach its own final state. In this
>>>>>>>>>> case H aborts the simulation of this input and transitions to
>>>>>>>>>> H.qn.
>>>>>>>>>
>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus
>>>>>>>>> your H can't correctly abort and becomes non-answering and thus
>>>>>>>>> FAILS to be a decider.
>>>>>>>>>
>>>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>>>
>>>>>>>>> If you want to claim such a pattern exists, you MUST provide it
>>>>>>>>> or accept that your logic is just plain flawed as you are
>>>>>>>>> claiming the existance of something that is impossible.
>>>>>>>>>
>>>>>>>>> In effect, you are saying that if you have a halt decider for
>>>>>>>>> you halt decider to use, you can write a halt decider.
>>>>>>>>>
>>>>>>>>> FAIL.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>>>>> Linz Turing machine Ĥ, it is now a single machine with a
>>>>>>>>>> single start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> 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 what the behavior of the UTM simulation of its inputs
>>>>>>>>>> would be.
>>>>>>>>>>
>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these
>>>>>>>>>> steps would keep repeating:
>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>
>>>>>>>>> But only if H never aborts, if H does abort, then the pattern
>>>>>>>>> is broken.
>>>>>>>>>
>>>>>>>>
>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE
>>>>>>>> TRUTH OF THIS:
>>>>>>>>
>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>> simulated input to embedded_H would ever reach its final state
>>>>>>>> conclusively proves that embedded_H is correct to abort its
>>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>>
>>>>>>>
>>>>>>> The problem is that any H that aborts after a finite number of
>>>>>>> steps, gives the wrong answer because it only looked to see if
>>>>>>> the input doesn't halt at some specific finite number.
>>>>>>
>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>> number of steps such that the simulated input to embedded_H
>>>>>> reaches its final state then we know that this simulated input
>>>>>> does not halt.
>>>>>
>>>>> And the only case when that happens is when H does not abort its
>>>>> simulation,
>>>>>
>>>> WRONG !!!  That happens in every possible case. The simulated input
>>>> to embedded_H cannot possibly ever reach its final state NO MATTER
>>>> WHAT !!!
>>>
>>> But if H/embedded_H aborts its simulation, it doesn't matter if IT
>>> sees it or not, as it isn't then a UTM any longer.
>>>
>>
>> It remains true (invariant) that the simulated input to embedded_H
>> cannot possibly ever reach its final state no matter what embedded_H
>> does, thus conclusively proving that this input never halts.
>>
>>> If H aborts its simulation and goes to H.Qn then H^ applied to <H^>
>>> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>>
>>
>> Because a halt decider is a decider embedded_H is only accountable for
>> computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis of the
>> behavior specified by these inputs. embedded_H is not accountable for
>> the behavior of the computation that it is contained within: Ĥ applied
>> to ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>>
>
> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by the
> computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn and Halt.
>
> THAT is the defined behavior of the actual input to H.
>

You can define that a cat is a dog, yet the actual simulated input to
embedded_H cannot possibly reach its final state NO MATTER WHAT.

I still can't tell whether this exceeds your intellectual capacity or
you are simply dishonest.

> I don't see where you get that H^ applied to <H^> is not the computaiton
> represented by the input string <H^> <H^>, if you claim is true, then
> you haven't defined your decider or your representatoin correctly and
> are lying that you have.
>
> FAIL.
>
>
>>> THAT is what matters, and shows that H was wromg.
>>>
>>> You keep on believing a false source of 'truth'.
>>>
>>> FAIL.
>>>>
>>>>
>>>>
>>>> Halting problem undecidability and infinitely nested simulation (V3)
>>>>
>>>> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>>>>
>>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]

<AeYGJ.3517$2W.1872@fx36.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx36.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 189
Message-ID: <AeYGJ.3517$2W.1872@fx36.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 13:42:39 -0500
X-Received-Bytes: 8873
 by: Richard Damon - Sat, 22 Jan 2022 18:42 UTC

On 1/22/22 1:26 PM, olcott wrote:
> On 1/22/2022 12:21 PM, Richard Damon wrote:
>> On 1/22/22 12:53 PM, olcott wrote:
>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>> simulation (V3)
>>>>>>>>>>
>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite
>>>>>>>>>> loop.
>>>>>>>>>>
>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N is
>>>>>>>>>>> either the number of steps that it takes for its simulated
>>>>>>>>>>> input to reach its final state or the number of steps
>>>>>>>>>>> required for H to match an infinite behavior pattern proving
>>>>>>>>>>> that the simulated input would never reach its own final
>>>>>>>>>>> state. In this case H aborts the simulation of this input and
>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>
>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus
>>>>>>>>>> your H can't correctly abort and becomes non-answering and
>>>>>>>>>> thus FAILS to be a decider.
>>>>>>>>>>
>>>>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>>>>
>>>>>>>>>> If you want to claim such a pattern exists, you MUST provide
>>>>>>>>>> it or accept that your logic is just plain flawed as you are
>>>>>>>>>> claiming the existance of something that is impossible.
>>>>>>>>>>
>>>>>>>>>> In effect, you are saying that if you have a halt decider for
>>>>>>>>>> you halt decider to use, you can write a halt decider.
>>>>>>>>>>
>>>>>>>>>> FAIL.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The following simplifies the syntax for the definition of the
>>>>>>>>>>> Linz Turing machine Ĥ, it is now a single machine with a
>>>>>>>>>>> single start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> 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 what the behavior of the UTM simulation of its
>>>>>>>>>>> inputs would be.
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these
>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>
>>>>>>>>>> But only if H never aborts, if H does abort, then the pattern
>>>>>>>>>> is broken.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE
>>>>>>>>> TRUTH OF THIS:
>>>>>>>>>
>>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>>> simulated input to embedded_H would ever reach its final state
>>>>>>>>> conclusively proves that embedded_H is correct to abort its
>>>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The problem is that any H that aborts after a finite number of
>>>>>>>> steps, gives the wrong answer because it only looked to see if
>>>>>>>> the input doesn't halt at some specific finite number.
>>>>>>>
>>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>>> number of steps such that the simulated input to embedded_H
>>>>>>> reaches its final state then we know that this simulated input
>>>>>>> does not halt.
>>>>>>
>>>>>> And the only case when that happens is when H does not abort its
>>>>>> simulation,
>>>>>>
>>>>> WRONG !!!  That happens in every possible case. The simulated input
>>>>> to embedded_H cannot possibly ever reach its final state NO MATTER
>>>>> WHAT !!!
>>>>
>>>> But if H/embedded_H aborts its simulation, it doesn't matter if IT
>>>> sees it or not, as it isn't then a UTM any longer.
>>>>
>>>
>>> It remains true (invariant) that the simulated input to embedded_H
>>> cannot possibly ever reach its final state no matter what embedded_H
>>> does, thus conclusively proving that this input never halts.
>>>
>>>> If H aborts its simulation and goes to H.Qn then H^ applied to <H^>
>>>> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>>>
>>>
>>> Because a halt decider is a decider embedded_H is only accountable
>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis
>>> of the behavior specified by these inputs. embedded_H is not
>>> accountable for the behavior of the computation that it is contained
>>> within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual input to
>>> embedded_H.
>>>
>>
>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by the
>> computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn and Halt.
>>
>> THAT is the defined behavior of the actual input to H.
>>
>
> You can define that a cat is a dog, yet the actual simulated input to
> embedded_H cannot possibly reach its final state NO MATTER WHAT.

But it does. embeddd_H can't simuate to that point, but if embedded_H
aborts its simulation and goes to H.Qn, then UTM(<H^>,<H^>) does.

If you disagree, then point out the error in this abbreated trace:

1) Start at H^.Q0 <H^>

2) procedded to H^.Qx <H^> <H^>

3) since H^.Qx has a copy of the code from H.Q0, and you claim that when
we run H.Q0 <H^> <H^> it goes to H.Qn, we KNOW that H^.Qx <H^> <H^> also
goes to H^.Qn

4) H^.Qn then Halt.

You are probably going to complain about step 3, but that follows from
the definition of a Computaton.

As you just said, you can't define it to be something else and get a
valid answer.

ALL copies of an specific algorithm, when given the exact same input
MUST behave exactly the same. THAT IS A FUNDAMENTAL PROPERTY OF
COMPUTATIONS.

If it doesn't hold for H, then H is NOT a computation and there is no
Turing Machine H to claim to be a Halt Decider.


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

<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 12:53:29 -0600
Date: Sat, 22 Jan 2022 12:53:20 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <AeYGJ.3517$2W.1872@fx36.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
Lines: 136
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-tgJGIRAKn7iTRcUaoAz7wGrKQiE+EAYnqYL67x2gPSWX6G1KpG7Om5KmSyZl2DPr63WCzFsp9GVtHzB!+Ehg7495w/EFg4135Qa9MDUhqkQJx0CtbjWMaGrNV8GJery97kOlHVAEpXvcI4P5rar8LaUlSjZo
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: 7898
 by: olcott - Sat, 22 Jan 2022 18:53 UTC

On 1/22/2022 12:42 PM, Richard Damon wrote:
> On 1/22/22 1:26 PM, olcott wrote:
>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>> On 1/22/22 12:53 PM, olcott wrote:
>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>
>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent infinite
>>>>>>>>>>> loop.
>>>>>>>>>>>
>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N
>>>>>>>>>>>> is either the number of steps that it takes for its
>>>>>>>>>>>> simulated input to reach its final state or the number of
>>>>>>>>>>>> steps required for H to match an infinite behavior pattern
>>>>>>>>>>>> proving that the simulated input would never reach its own
>>>>>>>>>>>> final state. In this case H aborts the simulation of this
>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>
>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus
>>>>>>>>>>> your H can't correctly abort and becomes non-answering and
>>>>>>>>>>> thus FAILS to be a decider.
>>>>>>>>>>>
>>>>>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>>>>>
>>>>>>>>>>> If you want to claim such a pattern exists, you MUST provide
>>>>>>>>>>> it or accept that your logic is just plain flawed as you are
>>>>>>>>>>> claiming the existance of something that is impossible.
>>>>>>>>>>>
>>>>>>>>>>> In effect, you are saying that if you have a halt decider for
>>>>>>>>>>> you halt decider to use, you can write a halt decider.
>>>>>>>>>>>
>>>>>>>>>>> FAIL.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The following simplifies the syntax for the definition of
>>>>>>>>>>>> the Linz Turing machine Ĥ, it is now a single machine with a
>>>>>>>>>>>> single start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> 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 what the behavior of the UTM simulation of its
>>>>>>>>>>>> inputs would be.
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these
>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>
>>>>>>>>>>> But only if H never aborts, if H does abort, then the pattern
>>>>>>>>>>> is broken.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE
>>>>>>>>>> TRUTH OF THIS:
>>>>>>>>>>
>>>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>>>> simulated input to embedded_H would ever reach its final state
>>>>>>>>>> conclusively proves that embedded_H is correct to abort its
>>>>>>>>>> simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The problem is that any H that aborts after a finite number of
>>>>>>>>> steps, gives the wrong answer because it only looked to see if
>>>>>>>>> the input doesn't halt at some specific finite number.
>>>>>>>>
>>>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>>>> number of steps such that the simulated input to embedded_H
>>>>>>>> reaches its final state then we know that this simulated input
>>>>>>>> does not halt.
>>>>>>>
>>>>>>> And the only case when that happens is when H does not abort its
>>>>>>> simulation,
>>>>>>>
>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>> input to embedded_H cannot possibly ever reach its final state NO
>>>>>> MATTER WHAT !!!
>>>>>
>>>>> But if H/embedded_H aborts its simulation, it doesn't matter if IT
>>>>> sees it or not, as it isn't then a UTM any longer.
>>>>>
>>>>
>>>> It remains true (invariant) that the simulated input to embedded_H
>>>> cannot possibly ever reach its final state no matter what embedded_H
>>>> does, thus conclusively proving that this input never halts.
>>>>
>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to <H^>
>>>>> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>>>>
>>>>
>>>> Because a halt decider is a decider embedded_H is only accountable
>>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis
>>>> of the behavior specified by these inputs. embedded_H is not
>>>> accountable for the behavior of the computation that it is contained
>>>> within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual input to
>>>> embedded_H.
>>>>
>>>
>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by the
>>> computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn and Halt.
>>>
>>> THAT is the defined behavior of the actual input to H.
>>>
>>
>> You can define that a cat is a dog, yet the actual simulated input to
>> embedded_H cannot possibly reach its final state NO MATTER WHAT.
>
> But it does. embeddd_H can't simuate to that point,

If the simulated input cannot possibly every reach its final state no
matter what embedded_H does then this simulated input is correctly
determined to meet the Linz definition of never halting.

--
Copyright 2021 Pete Olcott

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


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

<7NZGJ.253260$VS2.134222@fx44.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx44.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 152
Message-ID: <7NZGJ.253260$VS2.134222@fx44.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 15:27:45 -0500
X-Received-Bytes: 8488
X-Original-Bytes: 8355
 by: Richard Damon - Sat, 22 Jan 2022 20:27 UTC

On 1/22/22 1:53 PM, olcott wrote:
> On 1/22/2022 12:42 PM, Richard Damon wrote:
>> On 1/22/22 1:26 PM, olcott wrote:
>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>
>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>
>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N
>>>>>>>>>>>>> is either the number of steps that it takes for its
>>>>>>>>>>>>> simulated input to reach its final state or the number of
>>>>>>>>>>>>> steps required for H to match an infinite behavior pattern
>>>>>>>>>>>>> proving that the simulated input would never reach its own
>>>>>>>>>>>>> final state. In this case H aborts the simulation of this
>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>
>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus
>>>>>>>>>>>> your H can't correctly abort and becomes non-answering and
>>>>>>>>>>>> thus FAILS to be a decider.
>>>>>>>>>>>>
>>>>>>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>>>>>>
>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST provide
>>>>>>>>>>>> it or accept that your logic is just plain flawed as you are
>>>>>>>>>>>> claiming the existance of something that is impossible.
>>>>>>>>>>>>
>>>>>>>>>>>> In effect, you are saying that if you have a halt decider
>>>>>>>>>>>> for you halt decider to use, you can write a halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The following simplifies the syntax for the definition of
>>>>>>>>>>>>> the Linz Turing machine Ĥ, it is now a single machine with
>>>>>>>>>>>>> a single start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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 what the behavior of the UTM simulation of its
>>>>>>>>>>>>> inputs would be.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩ these
>>>>>>>>>>>>> steps would keep repeating:
>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE
>>>>>>>>>>> TRUTH OF THIS:
>>>>>>>>>>>
>>>>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>>>>> simulated input to embedded_H would ever reach its final
>>>>>>>>>>> state conclusively proves that embedded_H is correct to abort
>>>>>>>>>>> its simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The problem is that any H that aborts after a finite number of
>>>>>>>>>> steps, gives the wrong answer because it only looked to see if
>>>>>>>>>> the input doesn't halt at some specific finite number.
>>>>>>>>>
>>>>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>>>>> number of steps such that the simulated input to embedded_H
>>>>>>>>> reaches its final state then we know that this simulated input
>>>>>>>>> does not halt.
>>>>>>>>
>>>>>>>> And the only case when that happens is when H does not abort its
>>>>>>>> simulation,
>>>>>>>>
>>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>>> input to embedded_H cannot possibly ever reach its final state NO
>>>>>>> MATTER WHAT !!!
>>>>>>
>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter if IT
>>>>>> sees it or not, as it isn't then a UTM any longer.
>>>>>>
>>>>>
>>>>> It remains true (invariant) that the simulated input to embedded_H
>>>>> cannot possibly ever reach its final state no matter what
>>>>> embedded_H does, thus conclusively proving that this input never
>>>>> halts.
>>>>>
>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to
>>>>>> <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>>>>>
>>>>>
>>>>> Because a halt decider is a decider embedded_H is only accountable
>>>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the basis
>>>>> of the behavior specified by these inputs. embedded_H is not
>>>>> accountable for the behavior of the computation that it is
>>>>> contained within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual
>>>>> input to embedded_H.
>>>>>
>>>>
>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by the
>>>> computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn and Halt.
>>>>
>>>> THAT is the defined behavior of the actual input to H.
>>>>
>>>
>>> You can define that a cat is a dog, yet the actual simulated input to
>>> embedded_H cannot possibly reach its final state NO MATTER WHAT.
>>
>> But it does. embeddd_H can't simuate to that point,
>
> If the simulated input cannot possibly every reach its final state no
> matter what embedded_H does then this simulated input is correctly
> determined to meet the Linz definition of never halting.
>


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

<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 22 Jan 2022 14:42:49 -0600
Date: Sat, 22 Jan 2022 14:42:48 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <7NZGJ.253260$VS2.134222@fx44.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com>
Lines: 151
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NmINLlC9wjLW02mfGTCgocii/tJTOLr6oD19WoTRjWK2M8vj8hbwMskHV7xft1Tsgt4Tm339RPcwpUm!P+3oWOturh067uRDvPZ8oR/DuNKyIDASE73/RCu24Y7FxNoJDO/tcx8QXUxMvaZxBD0dx7EQa8tN
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: 8723
 by: olcott - Sat, 22 Jan 2022 20:42 UTC

On 1/22/2022 2:27 PM, Richard Damon wrote:
> On 1/22/22 1:53 PM, olcott wrote:
>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>> On 1/22/22 1:26 PM, olcott wrote:
>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input. N
>>>>>>>>>>>>>> is either the number of steps that it takes for its
>>>>>>>>>>>>>> simulated input to reach its final state or the number of
>>>>>>>>>>>>>> steps required for H to match an infinite behavior pattern
>>>>>>>>>>>>>> proving that the simulated input would never reach its own
>>>>>>>>>>>>>> final state. In this case H aborts the simulation of this
>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern, thus
>>>>>>>>>>>>> your H can't correctly abort and becomes non-answering and
>>>>>>>>>>>>> thus FAILS to be a decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The non-existance has been proven and you have ignored that
>>>>>>>>>>>>> proof, showing you have no counter for the proof.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>> provide it or accept that your logic is just plain flawed
>>>>>>>>>>>>> as you are claiming the existance of something that is
>>>>>>>>>>>>> impossible.
>>>>>>>>>>>>>
>>>>>>>>>>>>> In effect, you are saying that if you have a halt decider
>>>>>>>>>>>>> for you halt decider to use, you can write a halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The following simplifies the syntax for the definition of
>>>>>>>>>>>>>> the Linz Turing machine Ĥ, it is now a single machine with
>>>>>>>>>>>>>> a single start state. A copy of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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 what the behavior of the UTM
>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>
>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE
>>>>>>>>>>>> TRUTH OF THIS:
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>>>>>> simulated input to embedded_H would ever reach its final
>>>>>>>>>>>> state conclusively proves that embedded_H is correct to
>>>>>>>>>>>> abort its simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The problem is that any H that aborts after a finite number
>>>>>>>>>>> of steps, gives the wrong answer because it only looked to
>>>>>>>>>>> see if the input doesn't halt at some specific finite number.
>>>>>>>>>>
>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>>>>>> number of steps such that the simulated input to embedded_H
>>>>>>>>>> reaches its final state then we know that this simulated input
>>>>>>>>>> does not halt.
>>>>>>>>>
>>>>>>>>> And the only case when that happens is when H does not abort
>>>>>>>>> its simulation,
>>>>>>>>>
>>>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>>>> input to embedded_H cannot possibly ever reach its final state
>>>>>>>> NO MATTER WHAT !!!
>>>>>>>
>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter if
>>>>>>> IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>
>>>>>>
>>>>>> It remains true (invariant) that the simulated input to embedded_H
>>>>>> cannot possibly ever reach its final state no matter what
>>>>>> embedded_H does, thus conclusively proving that this input never
>>>>>> halts.
>>>>>>
>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to
>>>>>>> <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>>>>>>
>>>>>>
>>>>>> Because a halt decider is a decider embedded_H is only accountable
>>>>>> for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or Ĥ.qn on the
>>>>>> basis of the behavior specified by these inputs. embedded_H is not
>>>>>> accountable for the behavior of the computation that it is
>>>>>> contained within: Ĥ applied to ⟨Ĥ⟩ because this is not an actual
>>>>>> input to embedded_H.
>>>>>>
>>>>>
>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by
>>>>> the computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn
>>>>> and Halt.
>>>>>
>>>>> THAT is the defined behavior of the actual input to H.
>>>>>
>>>>
>>>> You can define that a cat is a dog, yet the actual simulated input
>>>> to embedded_H cannot possibly reach its final state NO MATTER WHAT.
>>>
>>> But it does. embeddd_H can't simuate to that point,
>>
>> If the simulated input cannot possibly every reach its final state no
>> matter what embedded_H does then this simulated input is correctly
>> determined to meet the Linz definition of never halting.
>>
>
> Except that the simulated input DOES reach its final state if
> H/embeded_H goes to H.Qn.


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

<8y_GJ.7767$tW.1827@fx39.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!2.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx39.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad> <O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com> <YqWGJ.17235$OU.1179@fx22.iad> <VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad> <MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com> <8eXGJ.53034$Y01.12453@fx45.iad> <rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com> <pWXGJ.18523$VK4.16193@fx08.iad> <i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad> <a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com> <7NZGJ.253260$VS2.134222@fx44.iad> <_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 171
Message-ID: <8y_GJ.7767$tW.1827@fx39.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 16:20:02 -0500
X-Received-Bytes: 9272
 by: Richard Damon - Sat, 22 Jan 2022 21:20 UTC

On 1/22/22 3:42 PM, olcott wrote:
> On 1/22/2022 2:27 PM, Richard Damon wrote:
>> On 1/22/22 1:53 PM, olcott wrote:
>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input.
>>>>>>>>>>>>>>> N is either the number of steps that it takes for its
>>>>>>>>>>>>>>> simulated input to reach its final state or the number of
>>>>>>>>>>>>>>> steps required for H to match an infinite behavior
>>>>>>>>>>>>>>> pattern proving that the simulated input would never
>>>>>>>>>>>>>>> reach its own final state. In this case H aborts the
>>>>>>>>>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern,
>>>>>>>>>>>>>> thus your H can't correctly abort and becomes
>>>>>>>>>>>>>> non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The non-existance has been proven and you have ignored
>>>>>>>>>>>>>> that proof, showing you have no counter for the proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>> provide it or accept that your logic is just plain flawed
>>>>>>>>>>>>>> as you are claiming the existance of something that is
>>>>>>>>>>>>>> impossible.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In effect, you are saying that if you have a halt decider
>>>>>>>>>>>>>> for you halt decider to use, you can write a halt decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The following simplifies the syntax for the definition of
>>>>>>>>>>>>>>> the Linz Turing machine Ĥ, it is now a single machine
>>>>>>>>>>>>>>> with a single start state. A copy of Linz H is embedded
>>>>>>>>>>>>>>> at Ĥ.qx.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 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 what the behavior of the UTM
>>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE THE
>>>>>>>>>>>>> TRUTH OF THIS:
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>>>>>>> simulated input to embedded_H would ever reach its final
>>>>>>>>>>>>> state conclusively proves that embedded_H is correct to
>>>>>>>>>>>>> abort its simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The problem is that any H that aborts after a finite number
>>>>>>>>>>>> of steps, gives the wrong answer because it only looked to
>>>>>>>>>>>> see if the input doesn't halt at some specific finite number.
>>>>>>>>>>>
>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>>>>>>> number of steps such that the simulated input to embedded_H
>>>>>>>>>>> reaches its final state then we know that this simulated
>>>>>>>>>>> input does not halt.
>>>>>>>>>>
>>>>>>>>>> And the only case when that happens is when H does not abort
>>>>>>>>>> its simulation,
>>>>>>>>>>
>>>>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>>>>> input to embedded_H cannot possibly ever reach its final state
>>>>>>>>> NO MATTER WHAT !!!
>>>>>>>>
>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter if
>>>>>>>> IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>>
>>>>>>>
>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>> embedded_H cannot possibly ever reach its final state no matter
>>>>>>> what embedded_H does, thus conclusively proving that this input
>>>>>>> never halts.
>>>>>>>
>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to
>>>>>>>> <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn and Halt.
>>>>>>>>
>>>>>>>
>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>> Ĥ.qn on the basis of the behavior specified by these inputs.
>>>>>>> embedded_H is not accountable for the behavior of the computation
>>>>>>> that it is contained within: Ĥ applied to ⟨Ĥ⟩ because this is not
>>>>>>> an actual input to embedded_H.
>>>>>>>
>>>>>>
>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by
>>>>>> the computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn
>>>>>> and Halt.
>>>>>>
>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>
>>>>>
>>>>> You can define that a cat is a dog, yet the actual simulated input
>>>>> to embedded_H cannot possibly reach its final state NO MATTER WHAT.
>>>>
>>>> But it does. embeddd_H can't simuate to that point,
>>>
>>> If the simulated input cannot possibly every reach its final state no
>>> matter what embedded_H does then this simulated input is correctly
>>> determined to meet the Linz definition of never halting.
>>>
>>
>> Except that the simulated input DOES reach its final state if
>> H/embeded_H goes to H.Qn.
>
> Before embedded_H transitions to Ĥ.qn it has already aborted its
> simulated input making it utterly impossible for any aspect of this
> simulated input to do anything at all.


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

<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>

 copy mid

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

 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: Sat, 22 Jan 2022 15:25:57 -0600
Date: Sat, 22 Jan 2022 15:25:56 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <8y_GJ.7767$tW.1827@fx39.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
Lines: 192
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jHMWingvAD6mNbhopQ1kcYVKtOlHW5Wh0/5fK47DvxJexDR3tW5fpM9PGRPOTrayjAGnUMnQ6bb1jae!R2BNln26NeC6odENE4IIMM6uVBC5fazT5T3i7WMPWBB3+EjcTJC1XfKyITLo/BZhS93nWFSGv0B1
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: 10463
 by: olcott - Sat, 22 Jan 2022 21:25 UTC

On 1/22/2022 3:20 PM, Richard Damon wrote:
>
> On 1/22/22 3:42 PM, olcott wrote:
>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>> On 1/22/22 1:53 PM, olcott wrote:
>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on the
>>>>>>>>>>>>>>>> behavior of its pure simulation of N steps of its input.
>>>>>>>>>>>>>>>> N is either the number of steps that it takes for its
>>>>>>>>>>>>>>>> simulated input to reach its final state or the number
>>>>>>>>>>>>>>>> of steps required for H to match an infinite behavior
>>>>>>>>>>>>>>>> pattern proving that the simulated input would never
>>>>>>>>>>>>>>>> reach its own final state. In this case H aborts the
>>>>>>>>>>>>>>>> simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern,
>>>>>>>>>>>>>>> thus your H can't correctly abort and becomes
>>>>>>>>>>>>>>> non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The non-existance has been proven and you have ignored
>>>>>>>>>>>>>>> that proof, showing you have no counter for the proof.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>> provide it or accept that your logic is just plain flawed
>>>>>>>>>>>>>>> as you are claiming the existance of something that is
>>>>>>>>>>>>>>> impossible.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt decider
>>>>>>>>>>>>>>> for you halt decider to use, you can write a halt decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>> of the Linz Turing machine Ĥ, it is now a single machine
>>>>>>>>>>>>>>>> with a single start state. A copy of Linz H is embedded
>>>>>>>>>>>>>>>> at Ĥ.qx.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 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 what the behavior of the UTM
>>>>>>>>>>>>>>>> simulation of its inputs would be.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE
>>>>>>>>>>>>>> THE TRUTH OF THIS:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The fact that there are no finite number of steps that the
>>>>>>>>>>>>>> simulated input to embedded_H would ever reach its final
>>>>>>>>>>>>>> state conclusively proves that embedded_H is correct to
>>>>>>>>>>>>>> abort its simulation of this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The problem is that any H that aborts after a finite number
>>>>>>>>>>>>> of steps, gives the wrong answer because it only looked to
>>>>>>>>>>>>> see if the input doesn't halt at some specific finite number.
>>>>>>>>>>>>
>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or infinite)
>>>>>>>>>>>> number of steps such that the simulated input to embedded_H
>>>>>>>>>>>> reaches its final state then we know that this simulated
>>>>>>>>>>>> input does not halt.
>>>>>>>>>>>
>>>>>>>>>>> And the only case when that happens is when H does not abort
>>>>>>>>>>> its simulation,
>>>>>>>>>>>
>>>>>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>>>>>> input to embedded_H cannot possibly ever reach its final state
>>>>>>>>>> NO MATTER WHAT !!!
>>>>>>>>>
>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter if
>>>>>>>>> IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>> embedded_H cannot possibly ever reach its final state no matter
>>>>>>>> what embedded_H does, thus conclusively proving that this input
>>>>>>>> never halts.
>>>>>>>>
>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to
>>>>>>>>> <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn and
>>>>>>>>> Halt.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>> Ĥ.qn on the basis of the behavior specified by these inputs.
>>>>>>>> embedded_H is not accountable for the behavior of the
>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩
>>>>>>>> because this is not an actual input to embedded_H.
>>>>>>>>
>>>>>>>
>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by
>>>>>>> the computation UTM(<H^>,<H^>) will show that H^ also go to H^.Qn
>>>>>>> and Halt.
>>>>>>>
>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>
>>>>>>
>>>>>> You can define that a cat is a dog, yet the actual simulated input
>>>>>> to embedded_H cannot possibly reach its final state NO MATTER WHAT.
>>>>>
>>>>> But it does. embeddd_H can't simuate to that point,
>>>>
>>>> If the simulated input cannot possibly every reach its final state
>>>> no matter what embedded_H does then this simulated input is
>>>> correctly determined to meet the Linz definition of never halting.
>>>>
>>>
>>> Except that the simulated input DOES reach its final state if
>>> H/embeded_H goes to H.Qn.
>>
>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>> simulated input making it utterly impossible for any aspect of this
>> simulated input to do anything at all.
>
> Then you are just talking POOP and not halting.
>


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

<UN_GJ.275715$1d1.2334@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer02.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.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 205
Message-ID: <UN_GJ.275715$1d1.2334@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: Sat, 22 Jan 2022 16:36:52 -0500
X-Received-Bytes: 10768
X-Original-Bytes: 10634
 by: Richard Damon - Sat, 22 Jan 2022 21:36 UTC

On 1/22/22 4:25 PM, olcott wrote:
> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>
>> On 1/22/22 3:42 PM, olcott wrote:
>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on
>>>>>>>>>>>>>>>>> the behavior of its pure simulation of N steps of its
>>>>>>>>>>>>>>>>> input. N is either the number of steps that it takes
>>>>>>>>>>>>>>>>> for its simulated input to reach its final state or the
>>>>>>>>>>>>>>>>> number of steps required for H to match an infinite
>>>>>>>>>>>>>>>>> behavior pattern proving that the simulated input would
>>>>>>>>>>>>>>>>> never reach its own final state. In this case H aborts
>>>>>>>>>>>>>>>>> the simulation of this input and transitions to H.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern,
>>>>>>>>>>>>>>>> thus your H can't correctly abort and becomes
>>>>>>>>>>>>>>>> non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The non-existance has been proven and you have ignored
>>>>>>>>>>>>>>>> that proof, showing you have no counter for the proof.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>>> provide it or accept that your logic is just plain
>>>>>>>>>>>>>>>> flawed as you are claiming the existance of something
>>>>>>>>>>>>>>>> that is impossible.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write a
>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>>> of the Linz Turing machine Ĥ, it is now a single
>>>>>>>>>>>>>>>>> machine with a single start state. A copy of Linz H is
>>>>>>>>>>>>>>>>> embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> 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 what the behavior
>>>>>>>>>>>>>>>>> of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H simulates
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE
>>>>>>>>>>>>>>> THE TRUTH OF THIS:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The fact that there are no finite number of steps that
>>>>>>>>>>>>>>> the simulated input to embedded_H would ever reach its
>>>>>>>>>>>>>>> final state conclusively proves that embedded_H is
>>>>>>>>>>>>>>> correct to abort its simulation of this input and
>>>>>>>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>> number of steps, gives the wrong answer because it only
>>>>>>>>>>>>>> looked to see if the input doesn't halt at some specific
>>>>>>>>>>>>>> finite number.
>>>>>>>>>>>>>
>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>> infinite) number of steps such that the simulated input to
>>>>>>>>>>>>> embedded_H reaches its final state then we know that this
>>>>>>>>>>>>> simulated input does not halt.
>>>>>>>>>>>>
>>>>>>>>>>>> And the only case when that happens is when H does not abort
>>>>>>>>>>>> its simulation,
>>>>>>>>>>>>
>>>>>>>>>>> WRONG !!!  That happens in every possible case. The simulated
>>>>>>>>>>> input to embedded_H cannot possibly ever reach its final
>>>>>>>>>>> state NO MATTER WHAT !!!
>>>>>>>>>>
>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter
>>>>>>>>>> if IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>> embedded_H cannot possibly ever reach its final state no matter
>>>>>>>>> what embedded_H does, thus conclusively proving that this input
>>>>>>>>> never halts.
>>>>>>>>>
>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied to
>>>>>>>>>> <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn and
>>>>>>>>>> Halt.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>>> Ĥ.qn on the basis of the behavior specified by these inputs.
>>>>>>>>> embedded_H is not accountable for the behavior of the
>>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩
>>>>>>>>> because this is not an actual input to embedded_H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation by
>>>>>>>> the computation UTM(<H^>,<H^>) will show that H^ also go to
>>>>>>>> H^.Qn and Halt.
>>>>>>>>
>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>
>>>>>>>
>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>> MATTER WHAT.
>>>>>>
>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>
>>>>> If the simulated input cannot possibly every reach its final state
>>>>> no matter what embedded_H does then this simulated input is
>>>>> correctly determined to meet the Linz definition of never halting.
>>>>>
>>>>
>>>> Except that the simulated input DOES reach its final state if
>>>> H/embeded_H goes to H.Qn.
>>>
>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>> simulated input making it utterly impossible for any aspect of this
>>> simulated input to do anything at all.
>>
>> Then you are just talking POOP and not halting.
>>
>
> It is simply beyond your intellectual capacity:
>
> This is true for infinite loops, infinite recursion, infinitely nested
> simulation and all other non halting inputs:
>
> When-so-ever any simulated input to any simulating halt decider would
> never reach the final state of this simulated input in any finite number
> of steps it is always correct for the simulating halt decider to abort
> its simulation and transition to its reject state.
>


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

<_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 15:45:28 -0600
Date: Sat, 22 Jan 2022 15:45:27 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <UN_GJ.275715$1d1.2334@fx99.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>
Lines: 220
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-x1vkLl9mODrb90g92L4WkTL1SH8jbABKHiOARDTYt9QUysOcmRrxpjRQiCQqg3nhX2oKi8EFYmKWOyk!mmdYM33d20uXmZeoPjBjiAIAdEhdizI3U5WvA9S/oCsP3nX5ntjTAAxvtfbkTF5cfmgwVSHvbBG7
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: 11732
 by: olcott - Sat, 22 Jan 2022 21:45 UTC

On 1/22/2022 3:36 PM, Richard Damon wrote:
> On 1/22/22 4:25 PM, olcott wrote:
>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>
>>> On 1/22/22 3:42 PM, olcott wrote:
>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on
>>>>>>>>>>>>>>>>>> the behavior of its pure simulation of N steps of its
>>>>>>>>>>>>>>>>>> input. N is either the number of steps that it takes
>>>>>>>>>>>>>>>>>> for its simulated input to reach its final state or
>>>>>>>>>>>>>>>>>> the number of steps required for H to match an
>>>>>>>>>>>>>>>>>> infinite behavior pattern proving that the simulated
>>>>>>>>>>>>>>>>>> input would never reach its own final state. In this
>>>>>>>>>>>>>>>>>> case H aborts the simulation of this input and
>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern,
>>>>>>>>>>>>>>>>> thus your H can't correctly abort and becomes
>>>>>>>>>>>>>>>>> non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The non-existance has been proven and you have ignored
>>>>>>>>>>>>>>>>> that proof, showing you have no counter for the proof.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>>>> provide it or accept that your logic is just plain
>>>>>>>>>>>>>>>>> flawed as you are claiming the existance of something
>>>>>>>>>>>>>>>>> that is impossible.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write a
>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the definition
>>>>>>>>>>>>>>>>>> of the Linz Turing machine Ĥ, it is now a single
>>>>>>>>>>>>>>>>>> machine with a single start state. A copy of Linz H is
>>>>>>>>>>>>>>>>>> embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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 what the behavior
>>>>>>>>>>>>>>>>>> of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE
>>>>>>>>>>>>>>>> THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The fact that there are no finite number of steps that
>>>>>>>>>>>>>>>> the simulated input to embedded_H would ever reach its
>>>>>>>>>>>>>>>> final state conclusively proves that embedded_H is
>>>>>>>>>>>>>>>> correct to abort its simulation of this input and
>>>>>>>>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>>> number of steps, gives the wrong answer because it only
>>>>>>>>>>>>>>> looked to see if the input doesn't halt at some specific
>>>>>>>>>>>>>>> finite number.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>> infinite) number of steps such that the simulated input to
>>>>>>>>>>>>>> embedded_H reaches its final state then we know that this
>>>>>>>>>>>>>> simulated input does not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the only case when that happens is when H does not
>>>>>>>>>>>>> abort its simulation,
>>>>>>>>>>>>>
>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever reach its
>>>>>>>>>>>> final state NO MATTER WHAT !!!
>>>>>>>>>>>
>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter
>>>>>>>>>>> if IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>> matter what embedded_H does, thus conclusively proving that
>>>>>>>>>> this input never halts.
>>>>>>>>>>
>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied
>>>>>>>>>>> to <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn
>>>>>>>>>>> and Halt.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>>>> Ĥ.qn on the basis of the behavior specified by these inputs.
>>>>>>>>>> embedded_H is not accountable for the behavior of the
>>>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>> because this is not an actual input to embedded_H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation
>>>>>>>>> by the computation UTM(<H^>,<H^>) will show that H^ also go to
>>>>>>>>> H^.Qn and Halt.
>>>>>>>>>
>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>>> MATTER WHAT.
>>>>>>>
>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>
>>>>>> If the simulated input cannot possibly every reach its final state
>>>>>> no matter what embedded_H does then this simulated input is
>>>>>> correctly determined to meet the Linz definition of never halting.
>>>>>>
>>>>>
>>>>> Except that the simulated input DOES reach its final state if
>>>>> H/embeded_H goes to H.Qn.
>>>>
>>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>>> simulated input making it utterly impossible for any aspect of this
>>>> simulated input to do anything at all.
>>>
>>> Then you are just talking POOP and not halting.
>>>
>>
>> It is simply beyond your intellectual capacity:
>>
>> This is true for infinite loops, infinite recursion, infinitely nested
>> simulation and all other non halting inputs:
>>
>> When-so-ever any simulated input to any simulating halt decider would
>> never reach the final state of this simulated input in any finite
>> number of steps it is always correct for the simulating halt decider
>> to abort its simulation and transition to its reject state.
>>
>
> Can you PROVE that statement, or is this just one of your false 'self
> evident truth'. Does the proof include the posibility that the input
> includes a copy of the decider?
>
> The problem is that IF the simulating halt decider does abort its input
> based on some condition, then it is no longer a source of truth for the
> halting status of that input.
>
> It turns out that for H^, if H does abort its simulation, then it turns
> out that an actual simulation of the input proves that it will halt.
>


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

<%s%GJ.38348$gX.18571@fx40.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx40.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 240
Message-ID: <%s%GJ.38348$gX.18571@fx40.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 17:22:51 -0500
X-Received-Bytes: 12579
X-Original-Bytes: 12445
 by: Richard Damon - Sat, 22 Jan 2022 22:22 UTC

On 1/22/22 4:45 PM, olcott wrote:
> On 1/22/2022 3:36 PM, Richard Damon wrote:
>> On 1/22/22 4:25 PM, olcott wrote:
>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>
>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on
>>>>>>>>>>>>>>>>>>> the behavior of its pure simulation of N steps of its
>>>>>>>>>>>>>>>>>>> input. N is either the number of steps that it takes
>>>>>>>>>>>>>>>>>>> for its simulated input to reach its final state or
>>>>>>>>>>>>>>>>>>> the number of steps required for H to match an
>>>>>>>>>>>>>>>>>>> infinite behavior pattern proving that the simulated
>>>>>>>>>>>>>>>>>>> input would never reach its own final state. In this
>>>>>>>>>>>>>>>>>>> case H aborts the simulation of this input and
>>>>>>>>>>>>>>>>>>> transitions to H.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^> pattern,
>>>>>>>>>>>>>>>>>> thus your H can't correctly abort and becomes
>>>>>>>>>>>>>>>>>> non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have ignored
>>>>>>>>>>>>>>>>>> that proof, showing you have no counter for the proof.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>>>>> provide it or accept that your logic is just plain
>>>>>>>>>>>>>>>>>> flawed as you are claiming the existance of something
>>>>>>>>>>>>>>>>>> that is impossible.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write a
>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is now a
>>>>>>>>>>>>>>>>>>> single machine with a single start state. A copy of
>>>>>>>>>>>>>>>>>>> Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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 what the
>>>>>>>>>>>>>>>>>>> behavior of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> these steps would keep repeating:
>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO ACKNOWLEDGE
>>>>>>>>>>>>>>>>> THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps that
>>>>>>>>>>>>>>>>> the simulated input to embedded_H would ever reach its
>>>>>>>>>>>>>>>>> final state conclusively proves that embedded_H is
>>>>>>>>>>>>>>>>> correct to abort its simulation of this input and
>>>>>>>>>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>>>> number of steps, gives the wrong answer because it only
>>>>>>>>>>>>>>>> looked to see if the input doesn't halt at some specific
>>>>>>>>>>>>>>>> finite number.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>> infinite) number of steps such that the simulated input
>>>>>>>>>>>>>>> to embedded_H reaches its final state then we know that
>>>>>>>>>>>>>>> this simulated input does not halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And the only case when that happens is when H does not
>>>>>>>>>>>>>> abort its simulation,
>>>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever reach
>>>>>>>>>>>>> its final state NO MATTER WHAT !!!
>>>>>>>>>>>>
>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't matter
>>>>>>>>>>>> if IT sees it or not, as it isn't then a UTM any longer.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>>> matter what embedded_H does, thus conclusively proving that
>>>>>>>>>>> this input never halts.
>>>>>>>>>>>
>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied
>>>>>>>>>>>> to <H^> and the UTM Simulation of <H^> <H^> will go to H^.Qn
>>>>>>>>>>>> and Halt.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy or
>>>>>>>>>>> Ĥ.qn on the basis of the behavior specified by these inputs.
>>>>>>>>>>> embedded_H is not accountable for the behavior of the
>>>>>>>>>>> computation that it is contained within: Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>> because this is not an actual input to embedded_H.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation
>>>>>>>>>> by the computation UTM(<H^>,<H^>) will show that H^ also go to
>>>>>>>>>> H^.Qn and Halt.
>>>>>>>>>>
>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>>>> MATTER WHAT.
>>>>>>>>
>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>
>>>>>>> If the simulated input cannot possibly every reach its final
>>>>>>> state no matter what embedded_H does then this simulated input is
>>>>>>> correctly determined to meet the Linz definition of never halting.
>>>>>>>
>>>>>>
>>>>>> Except that the simulated input DOES reach its final state if
>>>>>> H/embeded_H goes to H.Qn.
>>>>>
>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>>>> simulated input making it utterly impossible for any aspect of this
>>>>> simulated input to do anything at all.
>>>>
>>>> Then you are just talking POOP and not halting.
>>>>
>>>
>>> It is simply beyond your intellectual capacity:
>>>
>>> This is true for infinite loops, infinite recursion, infinitely
>>> nested simulation and all other non halting inputs:
>>>
>>> When-so-ever any simulated input to any simulating halt decider would
>>> never reach the final state of this simulated input in any finite
>>> number of steps it is always correct for the simulating halt decider
>>> to abort its simulation and transition to its reject state.
>>>
>>
>> Can you PROVE that statement, or is this just one of your false 'self
>> evident truth'. Does the proof include the posibility that the input
>> includes a copy of the decider?
>>
>> The problem is that IF the simulating halt decider does abort its
>> input based on some condition, then it is no longer a source of truth
>> for the halting status of that input.
>>
>> It turns out that for H^, if H does abort its simulation, then it
>> turns out that an actual simulation of the input proves that it will
>> halt.
>>
>
> You really must have actual brain damage. That would not be your fault
> I have told you the Linz definintion of halting many dozens of times:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> Any you can't seem to rememeber that I ever said it once.
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>
> HALTING DOES NOT MEAN STOPS RUNNING
> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>


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

<4NSdnQ1BvdVyGHH8nZ2dnUU7-U2dnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 16:32:15 -0600
Date: Sat, 22 Jan 2022 16:32:14 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>
<%s%GJ.38348$gX.18571@fx40.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <%s%GJ.38348$gX.18571@fx40.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <4NSdnQ1BvdVyGHH8nZ2dnUU7-U2dnZ2d@giganews.com>
Lines: 244
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6zq0itprVIQ/BWBOra3SWZsuouGWQ/PvtQ2eMOuNNN82TneqMWNPXkVQSB1fxJVZ933dT0kJvuGti6J!o/uUOs8c5DWjFq5RqMw46Nmk4jYmATg8T5VVwJV011upzeyn7a0lU2z1qq4ePWWlY3CPoDXV1JuD
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: 13339
 by: olcott - Sat, 22 Jan 2022 22:32 UTC

On 1/22/2022 4:22 PM, Richard Damon wrote:
> On 1/22/22 4:45 PM, olcott wrote:
>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>> On 1/22/22 4:25 PM, olcott wrote:
>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>
>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely nested
>>>>>>>>>>>>>>>>>>>> simulation (V3)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision on
>>>>>>>>>>>>>>>>>>>> the behavior of its pure simulation of N steps of
>>>>>>>>>>>>>>>>>>>> its input. N is either the number of steps that it
>>>>>>>>>>>>>>>>>>>> takes for its simulated input to reach its final
>>>>>>>>>>>>>>>>>>>> state or the number of steps required for H to match
>>>>>>>>>>>>>>>>>>>> an infinite behavior pattern proving that the
>>>>>>>>>>>>>>>>>>>> simulated input would never reach its own final
>>>>>>>>>>>>>>>>>>>> state. In this case H aborts the simulation of this
>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter for
>>>>>>>>>>>>>>>>>>> the proof.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>>>>>> provide it or accept that your logic is just plain
>>>>>>>>>>>>>>>>>>> flawed as you are claiming the existance of something
>>>>>>>>>>>>>>>>>>> that is impossible.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write a
>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is now a
>>>>>>>>>>>>>>>>>>>> single machine with a single start state. A copy of
>>>>>>>>>>>>>>>>>>>> Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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 what the
>>>>>>>>>>>>>>>>>>>> behavior of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then the
>>>>>>>>>>>>>>>>>>> pattern is broken.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps that
>>>>>>>>>>>>>>>>>> the simulated input to embedded_H would ever reach its
>>>>>>>>>>>>>>>>>> final state conclusively proves that embedded_H is
>>>>>>>>>>>>>>>>>> correct to abort its simulation of this input and
>>>>>>>>>>>>>>>>>> transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>>>>> number of steps, gives the wrong answer because it only
>>>>>>>>>>>>>>>>> looked to see if the input doesn't halt at some
>>>>>>>>>>>>>>>>> specific finite number.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated input
>>>>>>>>>>>>>>>> to embedded_H reaches its final state then we know that
>>>>>>>>>>>>>>>> this simulated input does not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And the only case when that happens is when H does not
>>>>>>>>>>>>>>> abort its simulation,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever reach
>>>>>>>>>>>>>> its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>
>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM any
>>>>>>>>>>>>> longer.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>>>> matter what embedded_H does, thus conclusively proving that
>>>>>>>>>>>> this input never halts.
>>>>>>>>>>>>
>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^ applied
>>>>>>>>>>>>> to <H^> and the UTM Simulation of <H^> <H^> will go to
>>>>>>>>>>>>> H^.Qn and Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
>>>>>>>>>>>> or Ĥ.qn on the basis of the behavior specified by these
>>>>>>>>>>>> inputs. embedded_H is not accountable for the behavior of
>>>>>>>>>>>> the computation that it is contained within: Ĥ applied to
>>>>>>>>>>>> ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper simulation
>>>>>>>>>>> by the computation UTM(<H^>,<H^>) will show that H^ also go
>>>>>>>>>>> to H^.Qn and Halt.
>>>>>>>>>>>
>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>>>>> MATTER WHAT.
>>>>>>>>>
>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>
>>>>>>>> If the simulated input cannot possibly every reach its final
>>>>>>>> state no matter what embedded_H does then this simulated input
>>>>>>>> is correctly determined to meet the Linz definition of never
>>>>>>>> halting.
>>>>>>>>
>>>>>>>
>>>>>>> Except that the simulated input DOES reach its final state if
>>>>>>> H/embeded_H goes to H.Qn.
>>>>>>
>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>>>>> simulated input making it utterly impossible for any aspect of
>>>>>> this simulated input to do anything at all.
>>>>>
>>>>> Then you are just talking POOP and not halting.
>>>>>
>>>>
>>>> It is simply beyond your intellectual capacity:
>>>>
>>>> This is true for infinite loops, infinite recursion, infinitely
>>>> nested simulation and all other non halting inputs:
>>>>
>>>> When-so-ever any simulated input to any simulating halt decider
>>>> would never reach the final state of this simulated input in any
>>>> finite number of steps it is always correct for the simulating halt
>>>> decider to abort its simulation and transition to its reject state.
>>>>
>>>
>>> Can you PROVE that statement, or is this just one of your false 'self
>>> evident truth'. Does the proof include the posibility that the input
>>> includes a copy of the decider?
>>>
>>> The problem is that IF the simulating halt decider does abort its
>>> input based on some condition, then it is no longer a source of truth
>>> for the halting status of that input.
>>>
>>> It turns out that for H^, if H does abort its simulation, then it
>>> turns out that an actual simulation of the input proves that it will
>>> halt.
>>>
>>
>> You really must have actual brain damage. That would not be your fault
>> I have told you the Linz definintion of halting many dozens of times:
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Any you can't seem to rememeber that I ever said it once.
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>> HALTING DOES NOT MEAN STOPS RUNNING
>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>
>
> And stopping simulating doesn't mean non-halt.
>


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

<yO%GJ.6189$9O.526@fx12.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!3.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed8.news.xs4all.nl!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx12.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>
<%s%GJ.38348$gX.18571@fx40.iad>
<4NSdnQ1BvdVyGHH8nZ2dnUU7-U2dnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <4NSdnQ1BvdVyGHH8nZ2dnUU7-U2dnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 253
Message-ID: <yO%GJ.6189$9O.526@fx12.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 22 Jan 2022 17:45:50 -0500
X-Received-Bytes: 13642
 by: Richard Damon - Sat, 22 Jan 2022 22:45 UTC

On 1/22/22 5:32 PM, olcott wrote:
> On 1/22/2022 4:22 PM, Richard Damon wrote:
>> On 1/22/22 4:45 PM, olcott wrote:
>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an apparent
>>>>>>>>>>>>>>>>>>>> infinite loop.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision
>>>>>>>>>>>>>>>>>>>>> on the behavior of its pure simulation of N steps
>>>>>>>>>>>>>>>>>>>>> of its input. N is either the number of steps that
>>>>>>>>>>>>>>>>>>>>> it takes for its simulated input to reach its final
>>>>>>>>>>>>>>>>>>>>> state or the number of steps required for H to
>>>>>>>>>>>>>>>>>>>>> match an infinite behavior pattern proving that the
>>>>>>>>>>>>>>>>>>>>> simulated input would never reach its own final
>>>>>>>>>>>>>>>>>>>>> state. In this case H aborts the simulation of this
>>>>>>>>>>>>>>>>>>>>> input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter for
>>>>>>>>>>>>>>>>>>>> the proof.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you MUST
>>>>>>>>>>>>>>>>>>>> provide it or accept that your logic is just plain
>>>>>>>>>>>>>>>>>>>> flawed as you are claiming the existance of
>>>>>>>>>>>>>>>>>>>> something that is impossible.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write a
>>>>>>>>>>>>>>>>>>>> halt decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is now
>>>>>>>>>>>>>>>>>>>>> a single machine with a single start state. A copy
>>>>>>>>>>>>>>>>>>>>> of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> 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 what the
>>>>>>>>>>>>>>>>>>>>> behavior of the UTM simulation of its inputs would be.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then
>>>>>>>>>>>>>>>>>>>> the pattern is broken.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps
>>>>>>>>>>>>>>>>>>> that the simulated input to embedded_H would ever
>>>>>>>>>>>>>>>>>>> reach its final state conclusively proves that
>>>>>>>>>>>>>>>>>>> embedded_H is correct to abort its simulation of this
>>>>>>>>>>>>>>>>>>> input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>>>>>> number of steps, gives the wrong answer because it
>>>>>>>>>>>>>>>>>> only looked to see if the input doesn't halt at some
>>>>>>>>>>>>>>>>>> specific finite number.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated input
>>>>>>>>>>>>>>>>> to embedded_H reaches its final state then we know that
>>>>>>>>>>>>>>>>> this simulated input does not halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And the only case when that happens is when H does not
>>>>>>>>>>>>>>>> abort its simulation,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever reach
>>>>>>>>>>>>>>> its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM any
>>>>>>>>>>>>>> longer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>>>>> matter what embedded_H does, thus conclusively proving that
>>>>>>>>>>>>> this input never halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^> will
>>>>>>>>>>>>>> go to H^.Qn and Halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
>>>>>>>>>>>>> or Ĥ.qn on the basis of the behavior specified by these
>>>>>>>>>>>>> inputs. embedded_H is not accountable for the behavior of
>>>>>>>>>>>>> the computation that it is contained within: Ĥ applied to
>>>>>>>>>>>>> ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show that
>>>>>>>>>>>> H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>
>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>>>>>> MATTER WHAT.
>>>>>>>>>>
>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>
>>>>>>>>> If the simulated input cannot possibly every reach its final
>>>>>>>>> state no matter what embedded_H does then this simulated input
>>>>>>>>> is correctly determined to meet the Linz definition of never
>>>>>>>>> halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Except that the simulated input DOES reach its final state if
>>>>>>>> H/embeded_H goes to H.Qn.
>>>>>>>
>>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>>>>>> simulated input making it utterly impossible for any aspect of
>>>>>>> this simulated input to do anything at all.
>>>>>>
>>>>>> Then you are just talking POOP and not halting.
>>>>>>
>>>>>
>>>>> It is simply beyond your intellectual capacity:
>>>>>
>>>>> This is true for infinite loops, infinite recursion, infinitely
>>>>> nested simulation and all other non halting inputs:
>>>>>
>>>>> When-so-ever any simulated input to any simulating halt decider
>>>>> would never reach the final state of this simulated input in any
>>>>> finite number of steps it is always correct for the simulating halt
>>>>> decider to abort its simulation and transition to its reject state.
>>>>>
>>>>
>>>> Can you PROVE that statement, or is this just one of your false
>>>> 'self evident truth'. Does the proof include the posibility that the
>>>> input includes a copy of the decider?
>>>>
>>>> The problem is that IF the simulating halt decider does abort its
>>>> input based on some condition, then it is no longer a source of
>>>> truth for the halting status of that input.
>>>>
>>>> It turns out that for H^, if H does abort its simulation, then it
>>>> turns out that an actual simulation of the input proves that it will
>>>> halt.
>>>>
>>>
>>> You really must have actual brain damage. That would not be your fault
>>> I have told you the Linz definintion of halting many dozens of times:
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> Any you can't seem to rememeber that I ever said it once.
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>> HALTING DOES NOT MEAN STOPS RUNNING
>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>
>>
>> And stopping simulating doesn't mean non-halt.
>>
>
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
> Matching the infinite behavior pattern means not halt.
>


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

<4OSdnRWHGK-6EHH8nZ2dnUU7-T2dnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 22 Jan 2022 17:03:03 -0600
Date: Sat, 22 Jan 2022 17:03:02 -0600
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.5.0
Subject: Re: Concise refutation of halting problem proofs V52 [ Ignorant or
Dishonest ]
Content-Language: en-US
Newsgroups: comp.theory
References: <ssh8vu$4c0$1@dont-email.me> <7cWGJ.53033$Y01.48629@fx45.iad>
<O_2dnZH5oMRzrXH8nZ2dnUU7-L3NnZ2d@giganews.com>
<YqWGJ.17235$OU.1179@fx22.iad>
<VuWdnWDDRYaYqHH8nZ2dnUU7-UXNnZ2d@giganews.com> <7XWGJ.2501$2V.1175@fx07.iad>
<MJudnaGsk80GoXH8nZ2dnUU7-cPNnZ2d@giganews.com>
<8eXGJ.53034$Y01.12453@fx45.iad>
<rY2dnfFFpOQU2XH8nZ2dnUU7-KPNnZ2d@giganews.com>
<pWXGJ.18523$VK4.16193@fx08.iad>
<i4idnXTXWeLE0XH8nZ2dnUU7-WfNnZ2d@giganews.com> <AeYGJ.3517$2W.1872@fx36.iad>
<a6-dnU-EiYU0z3H8nZ2dnUU7-SHNnZ2d@giganews.com>
<7NZGJ.253260$VS2.134222@fx44.iad>
<_c-dnS9uAqrU8XH8nZ2dnUU7-YvNnZ2d@giganews.com> <8y_GJ.7767$tW.1827@fx39.iad>
<JOqdnYm4c7z463H8nZ2dnUU7-anNnZ2d@giganews.com>
<UN_GJ.275715$1d1.2334@fx99.iad>
<_rOdnURKz_Nl53H8nZ2dnUU7-UvNnZ2d@giganews.com>
<%s%GJ.38348$gX.18571@fx40.iad>
<4NSdnQ1BvdVyGHH8nZ2dnUU7-U2dnZ2d@giganews.com> <yO%GJ.6189$9O.526@fx12.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <yO%GJ.6189$9O.526@fx12.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <4OSdnRWHGK-6EHH8nZ2dnUU7-T2dnZ2d@giganews.com>
Lines: 268
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-yQZVrU15yCzTPuw8QJcyOCltJWP9RqJ+K3fLle/SH/rSHVdxXLP27gVUPEMjw/UShD4BAKg1s+BQA6+!xIPUrgmevbP3+NJ+4GU8GxjwjHtLzVAsgb/PwpSA9PiT3PGGx2LxP4VIx4psxoy1nDZFIBzUKbBb
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: 14516
 by: olcott - Sat, 22 Jan 2022 23:03 UTC

On 1/22/2022 4:45 PM, Richard Damon wrote:
>
> On 1/22/22 5:32 PM, olcott wrote:
>> On 1/22/2022 4:22 PM, Richard Damon wrote:
>>> On 1/22/22 4:45 PM, olcott wrote:
>>>> On 1/22/2022 3:36 PM, Richard Damon wrote:
>>>>> On 1/22/22 4:25 PM, olcott wrote:
>>>>>> On 1/22/2022 3:20 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 1/22/22 3:42 PM, olcott wrote:
>>>>>>>> On 1/22/2022 2:27 PM, Richard Damon wrote:
>>>>>>>>> On 1/22/22 1:53 PM, olcott wrote:
>>>>>>>>>> On 1/22/2022 12:42 PM, Richard Damon wrote:
>>>>>>>>>>> On 1/22/22 1:26 PM, olcott wrote:
>>>>>>>>>>>> On 1/22/2022 12:21 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 1/22/22 12:53 PM, olcott wrote:
>>>>>>>>>>>>>> On 1/22/2022 11:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 1/22/22 12:19 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 1/22/2022 11:13 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 1/22/22 11:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 1/22/2022 10:39 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 1/22/22 11:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 1/22/2022 10:23 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 1/22/22 10:48 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> Halting problem undecidability and infinitely
>>>>>>>>>>>>>>>>>>>>>> nested simulation (V3)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Take FIFTY TWO, I think you are stuck in an
>>>>>>>>>>>>>>>>>>>>> apparent infinite loop.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You keep on repeating the same basic mistakes.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> We define Linz H to base its halt status decision
>>>>>>>>>>>>>>>>>>>>>> on the behavior of its pure simulation of N steps
>>>>>>>>>>>>>>>>>>>>>> of its input. N is either the number of steps that
>>>>>>>>>>>>>>>>>>>>>> it takes for its simulated input to reach its
>>>>>>>>>>>>>>>>>>>>>> final state or the number of steps required for H
>>>>>>>>>>>>>>>>>>>>>> to match an infinite behavior pattern proving that
>>>>>>>>>>>>>>>>>>>>>> the simulated input would never reach its own
>>>>>>>>>>>>>>>>>>>>>> final state. In this case H aborts the simulation
>>>>>>>>>>>>>>>>>>>>>> of this input and transitions to H.qn.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Such a pattern NOT existing for the <H^> <H^>
>>>>>>>>>>>>>>>>>>>>> pattern, thus your H can't correctly abort and
>>>>>>>>>>>>>>>>>>>>> becomes non-answering and thus FAILS to be a decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The non-existance has been proven and you have
>>>>>>>>>>>>>>>>>>>>> ignored that proof, showing you have no counter for
>>>>>>>>>>>>>>>>>>>>> the proof.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If you want to claim such a pattern exists, you
>>>>>>>>>>>>>>>>>>>>> MUST provide it or accept that your logic is just
>>>>>>>>>>>>>>>>>>>>> plain flawed as you are claiming the existance of
>>>>>>>>>>>>>>>>>>>>> something that is impossible.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> In effect, you are saying that if you have a halt
>>>>>>>>>>>>>>>>>>>>> decider for you halt decider to use, you can write
>>>>>>>>>>>>>>>>>>>>> a halt decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The following simplifies the syntax for the
>>>>>>>>>>>>>>>>>>>>>> definition of the Linz Turing machine Ĥ, it is now
>>>>>>>>>>>>>>>>>>>>>> a single machine with a single start state. A copy
>>>>>>>>>>>>>>>>>>>>>> of Linz H is embedded at Ĥ.qx.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 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 what
>>>>>>>>>>>>>>>>>>>>>> the behavior of the UTM simulation of its inputs
>>>>>>>>>>>>>>>>>>>>>> would be.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When Ĥ applied to ⟨Ĥ⟩ has embedded_H simulate ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ these steps would keep repeating:
>>>>>>>>>>>>>>>>>>>>>> Ĥ copies its input ⟨Ĥ⟩ to ⟨Ĥ⟩ then embedded_H
>>>>>>>>>>>>>>>>>>>>>> simulates ⟨Ĥ⟩ ⟨Ĥ⟩...
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But only if H never aborts, if H does abort, then
>>>>>>>>>>>>>>>>>>>>> the pattern is broken.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> YOU ARE EITHER TOO IGNORANT OR DISHONEST TO
>>>>>>>>>>>>>>>>>>>> ACKNOWLEDGE THE TRUTH OF THIS:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The fact that there are no finite number of steps
>>>>>>>>>>>>>>>>>>>> that the simulated input to embedded_H would ever
>>>>>>>>>>>>>>>>>>>> reach its final state conclusively proves that
>>>>>>>>>>>>>>>>>>>> embedded_H is correct to abort its simulation of
>>>>>>>>>>>>>>>>>>>> this input and transition to Ĥ.qn.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The problem is that any H that aborts after a finite
>>>>>>>>>>>>>>>>>>> number of steps, gives the wrong answer because it
>>>>>>>>>>>>>>>>>>> only looked to see if the input doesn't halt at some
>>>>>>>>>>>>>>>>>>> specific finite number.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> OK IGNORANT it is. When there exists no finite (or
>>>>>>>>>>>>>>>>>> infinite) number of steps such that the simulated
>>>>>>>>>>>>>>>>>> input to embedded_H reaches its final state then we
>>>>>>>>>>>>>>>>>> know that this simulated input does not halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And the only case when that happens is when H does not
>>>>>>>>>>>>>>>>> abort its simulation,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> WRONG !!!  That happens in every possible case. The
>>>>>>>>>>>>>>>> simulated input to embedded_H cannot possibly ever reach
>>>>>>>>>>>>>>>> its final state NO MATTER WHAT !!!
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But if H/embedded_H aborts its simulation, it doesn't
>>>>>>>>>>>>>>> matter if IT sees it or not, as it isn't then a UTM any
>>>>>>>>>>>>>>> longer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It remains true (invariant) that the simulated input to
>>>>>>>>>>>>>> embedded_H cannot possibly ever reach its final state no
>>>>>>>>>>>>>> matter what embedded_H does, thus conclusively proving
>>>>>>>>>>>>>> that this input never halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H aborts its simulation and goes to H.Qn then H^
>>>>>>>>>>>>>>> applied to <H^> and the UTM Simulation of <H^> <H^> will
>>>>>>>>>>>>>>> go to H^.Qn and Halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Because a halt decider is a decider embedded_H is only
>>>>>>>>>>>>>> accountable for computing the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qy
>>>>>>>>>>>>>> or Ĥ.qn on the basis of the behavior specified by these
>>>>>>>>>>>>>> inputs. embedded_H is not accountable for the behavior of
>>>>>>>>>>>>>> the computation that it is contained within: Ĥ applied to
>>>>>>>>>>>>>> ⟨Ĥ⟩ because this is not an actual input to embedded_H.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, and if H(<H^>,<H^>) -> H.Qn then the proper
>>>>>>>>>>>>> simulation by the computation UTM(<H^>,<H^>) will show that
>>>>>>>>>>>>> H^ also go to H^.Qn and Halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> THAT is the defined behavior of the actual input to H.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You can define that a cat is a dog, yet the actual simulated
>>>>>>>>>>>> input to embedded_H cannot possibly reach its final state NO
>>>>>>>>>>>> MATTER WHAT.
>>>>>>>>>>>
>>>>>>>>>>> But it does. embeddd_H can't simuate to that point,
>>>>>>>>>>
>>>>>>>>>> If the simulated input cannot possibly every reach its final
>>>>>>>>>> state no matter what embedded_H does then this simulated input
>>>>>>>>>> is correctly determined to meet the Linz definition of never
>>>>>>>>>> halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Except that the simulated input DOES reach its final state if
>>>>>>>>> H/embeded_H goes to H.Qn.
>>>>>>>>
>>>>>>>> Before embedded_H transitions to Ĥ.qn it has already aborted its
>>>>>>>> simulated input making it utterly impossible for any aspect of
>>>>>>>> this simulated input to do anything at all.
>>>>>>>
>>>>>>> Then you are just talking POOP and not halting.
>>>>>>>
>>>>>>
>>>>>> It is simply beyond your intellectual capacity:
>>>>>>
>>>>>> This is true for infinite loops, infinite recursion, infinitely
>>>>>> nested simulation and all other non halting inputs:
>>>>>>
>>>>>> When-so-ever any simulated input to any simulating halt decider
>>>>>> would never reach the final state of this simulated input in any
>>>>>> finite number of steps it is always correct for the simulating
>>>>>> halt decider to abort its simulation and transition to its reject
>>>>>> state.
>>>>>>
>>>>>
>>>>> Can you PROVE that statement, or is this just one of your false
>>>>> 'self evident truth'. Does the proof include the posibility that
>>>>> the input includes a copy of the decider?
>>>>>
>>>>> The problem is that IF the simulating halt decider does abort its
>>>>> input based on some condition, then it is no longer a source of
>>>>> truth for the halting status of that input.
>>>>>
>>>>> It turns out that for H^, if H does abort its simulation, then it
>>>>> turns out that an actual simulation of the input proves that it
>>>>> will halt.
>>>>>
>>>>
>>>> You really must have actual brain damage. That would not be your fault
>>>> I have told you the Linz definintion of halting many dozens of times:
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> Any you can't seem to rememeber that I ever said it once.
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>> HALTING DOES NOT MEAN STOPS RUNNING
>>>> NOT HALTING MEANS CANNOT POSSIBLY REACH A FINAL STATE
>>>>
>>>
>>> And stopping simulating doesn't mean non-halt.
>>>
>>
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>> Matching the infinite behavior pattern means not halt.
>>
>
>
> WRONG. UTM never halting means does not Halt, use the right definitons.
>


Click here to read the complete article
Pages:123456789101112
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor