Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"It's God. No, not Richard Stallman, or Linus Torvalds, but God." (By Matt Welsh)


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

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

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

<3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 21 Mar 2022 21:05:02 -0500
Date: Mon, 21 Mar 2022 21:05:00 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Followup-To: comp.theory
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 47
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Bp2ppWpdWC7TxjYZKnxM6Shw7XOYFvO7paR81hWg338diDXB2/I6wbwkCJsp4okIzSxCGRRtEykBG+5!45BCvntBu+BH2GIEe7NNb0mInv969An98Q9Tsatlv6g4sl9B/cL2MUENMhp/EnEodWb5h6czQqeX
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: 3158
 by: olcott - Tue, 22 Mar 2022 02:05 UTC

A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).

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

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

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

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

Because we can see that a correct simulation of the input to embedded_H
cannot possibly reach its final state we can see that this input never
halts.

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

Whether or not it is even possible for embedded_H to recognize this
infinitely nested simulation does not matter (for refuting Linz).

As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
that rejecting its input forms a necessary contradiction.
(bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf

After we have mutual agreement on the above point we can move on to how
embedded_H would use finite string comparison to detect that its input
specifies infinitely nested simulation.

Halting problem undecidability and infinitely nested simulation (V4)

https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
Copyright 2021 Pete Olcott

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

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

<Zja_J.200111$Tr18.169844@fx42.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 84
Message-ID: <Zja_J.200111$Tr18.169844@fx42.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 21 Mar 2022 22:16:27 -0400
X-Received-Bytes: 4422
 by: Richard Damon - Tue, 22 Mar 2022 02:16 UTC

On 3/21/22 10:05 PM, olcott wrote:
> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
> state.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
> final state.
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>
> Because we can see that a correct simulation of the input to embedded_H
> cannot possibly reach its final state we can see that this input never
> halts.

But ONLY if mbedded_H doesn't abort its simulation.

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

Right, THE TURING MACHINE (i.e. NOT looking at a (partial) simulation)

>
> Whether or not it is even possible for embedded_H to recognize this
> infinitely nested simulation does not matter (for refuting Linz).
>
> As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
> that rejecting its input forms a necessary contradiction.
> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>

Nope, because if embedded_H -> Qn, the the H^ that it is embedded into
Halts, and thus <H^> <H^> represents a HALTING computation.

>
>
> After we have mutual agreement on the above point we can move on to how
> embedded_H would use finite string comparison to detect that its input
> specifies infinitely nested simulation.

Who can agree to FALSE statements, only a LIAR.

>
> Halting problem undecidability and infinitely nested simulation (V4)
>
> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>
>

Note, if you actually READ Linz's proof, you will note that he never
needed to refer to HOW the decider made its answer. It is just a fact
that if H applied to <H^> <H^> goes to Qy, then H^ applied to <H^> never
halts, and thus H was wrong, and if H applied to <H^> <H^> goes to Qn
then H^ applied to <H^> Halts, and thus H was also was wrong. And if H
never answers in one of those ways, it fails to meet the definition of a
Decider.

BY THE DEFINITION of Halting, and the CONSTRUCTION of H^, there is no
correct answer that H CAN give and be right.

You may think there is something wrong about that fact, but it comes out
of the basic properties of Turing Machines and Computation Theory.

You have just been trying for years to obfuscate a lie to try to 'prove'
this wrong, but the Halting Theorem proof is solid. Appealing to 'Other
Logic' doesn't work, as you are then working outside the Field, which
HAS defined rules. That is the Nature of a Formal Logic System, it has
rules, and you aren't allowed to break them, even if you consider them
just 'learned by rote', as the Rules ARE the Rules.

FAIL.

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

<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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: Mon, 21 Mar 2022 21:39:02 -0500
Date: Mon, 21 Mar 2022 21:39:00 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <Zja_J.200111$Tr18.169844@fx42.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 43
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-LKw6rH3ahV2eY+zu3CWhd4u8bfjItZKgA/8/3O4epY30rF405mhHJvdSguZda6CKV+pzGOnfb8F7iZb!b4ioUkWE/OWGR4WqHhImydKR/9ueMOaGoQjrMSJvovSNBtn4FjuUznL8O1J+tDiaJtWkfrUYhNFI
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: 2863
 by: olcott - Tue, 22 Mar 2022 02:39 UTC

On 3/21/2022 9:16 PM, Richard Damon wrote:
>
> On 3/21/22 10:05 PM, olcott wrote:
>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>> ⟨Ĥ4⟩...
>>
>> Because we can see that a correct simulation of the input to
>> embedded_H cannot possibly reach its final state we can see that this
>> input never halts.
>
>
> But ONLY if mbedded_H doesn't abort its simulation.
>

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

Never halts means that the simulated input will never reach its final
state whether or not its simulation is aborted.

--
Copyright 2021 Pete Olcott

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

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

<qfCdnYqgdZ1JqqT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 21 Mar 2022 21:43:32 -0500
Date: Mon, 21 Mar 2022 21:43:30 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qfCdnYqgdZ1JqqT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 60
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Ho89K8esyIb8Re6NhUsPt5Dj68YrCo6qVmkHnYSv4XpsqJ/8uEL2ij/Zfvwj8slMds1zYPSVeJIK2ly!cLco6HuPP8z2rnZ2iTYxNsTItF3VLU399NQJRhqfXucRaDz1bW3CwcROgd5ydtZosE+srZRRv80l
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: 3659
 by: olcott - Tue, 22 Mar 2022 02:43 UTC

On 3/21/2022 9:05 PM, olcott wrote:
> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
> state.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
> final state.
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
>   Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>

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

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

> Because we can see that a correct simulation of the input to embedded_H
> cannot possibly reach its final state we can see that this input never
> halts.
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> Whether or not it is even possible for embedded_H to recognize this
> infinitely nested simulation does not matter (for refuting Linz).
>
> As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
> that rejecting its input forms a necessary contradiction.
> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>
>
>
> After we have mutual agreement on the above point we can move on to how
> embedded_H would use finite string comparison to detect that its input
> specifies infinitely nested simulation.
>
> Halting problem undecidability and infinitely nested simulation (V4)
>
> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>
>

--
Copyright 2021 Pete Olcott

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

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

<a1acb3be-94a8-4093-a5b2-f7530bc1a7ean@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a37:8606:0:b0:67e:7cb6:a055 with SMTP id i6-20020a378606000000b0067e7cb6a055mr6704080qkd.152.1647917971113;
Mon, 21 Mar 2022 19:59:31 -0700 (PDT)
X-Received: by 2002:a81:a251:0:b0:2e5:bde7:6a with SMTP id z17-20020a81a251000000b002e5bde7006amr24787386ywg.213.1647917970742;
Mon, 21 Mar 2022 19:59:30 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Mon, 21 Mar 2022 19:59:30 -0700 (PDT)
In-Reply-To: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=58.115.187.102; posting-account=QJ9iEwoAAACyjkKjQAWQOwSEULNvZZkc
NNTP-Posting-Host: 58.115.187.102
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <a1acb3be-94a8-4093-a5b2-f7530bc1a7ean@googlegroups.com>
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
From: wyni...@gmail.com (wij)
Injection-Date: Tue, 22 Mar 2022 02:59:31 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Lines: 82
 by: wij - Tue, 22 Mar 2022 02:59 UTC

On Tuesday, 22 March 2022 at 10:05:09 UTC+8, olcott wrote:
> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
> final state.
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>
> Then these steps would keep repeating:
> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>
> Because we can see that a correct simulation of the input to embedded_H
> cannot possibly reach its final state we can see that this input never
> halts.
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> Whether or not it is even possible for embedded_H to recognize this
> infinitely nested simulation does not matter (for refuting Linz).
>
> As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
> that rejecting its input forms a necessary contradiction.
> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>
>
>
> After we have mutual agreement on the above point we can move on to how
> embedded_H would use finite string comparison to detect that its input
> specifies infinitely nested simulation.
>
> Halting problem undecidability and infinitely nested simulation (V4)
>
> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

The H of the Halting Problem is not required to detect any infinite loop. H is
only required to report whether the given algorithm instance P halts or not.

Firstly, proving the conventional liar-paradox-like instance is wrong to prove
the Halting Problem is decidable. At most, such proof proves HP is still
unsolved. That HP remains unsolved is the most what such an approach can get.

Secondly, you modified Linz's proof to your POOP. Nothing you say is therefore
valid to the true/false status of Linz's proof.

The discussion is at most about your POOP.

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

<RumdnR8gEfm5oqT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 21 Mar 2022 22:14:44 -0500
Date: Mon, 21 Mar 2022 22:14:42 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<a1acb3be-94a8-4093-a5b2-f7530bc1a7ean@googlegroups.com>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <a1acb3be-94a8-4093-a5b2-f7530bc1a7ean@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <RumdnR8gEfm5oqT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 77
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JiwsXdCAduyVPFn2k68J8XU+LAbQ2pFH+A/F+GMj3tblPzISfAuYvv04yZu6F2KWvrpyz+Gs4Udg6fY!n1/zik6S0rRvFQcrcW6ktTouJRuA546f5TO/EbosTcduitz9vO9/ZUSFr7KJNLj9IIwCT2ZGSV4N
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: 4686
 by: olcott - Tue, 22 Mar 2022 03:14 UTC

On 3/21/2022 9:59 PM, wij wrote:
> On Tuesday, 22 March 2022 at 10:05:09 UTC+8, olcott wrote:
>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>
>> Because we can see that a correct simulation of the input to embedded_H
>> cannot possibly reach its final state we can see that this input never
>> halts.
>>
>> computation that halts … the Turing machine will halt whenever it enters
>> a final state. (Linz:1990:234)
>>
>> Whether or not it is even possible for embedded_H to recognize this
>> infinitely nested simulation does not matter (for refuting Linz).
>>
>> As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
>> that rejecting its input forms a necessary contradiction.
>> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>>
>>
>>
>> After we have mutual agreement on the above point we can move on to how
>> embedded_H would use finite string comparison to detect that its input
>> specifies infinitely nested simulation.
>>
>> Halting problem undecidability and infinitely nested simulation (V4)
>>
>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>
>> --
>> Copyright 2021 Pete Olcott
>>
>> Talent hits a target no one else can hit;
>> Genius hits a target no one else can see.
>> Arthur Schopenhauer
>
> The H of the Halting Problem is not required to detect any infinite loop. H is
> only required to report whether the given algorithm instance P halts or not.
>
> Firstly, proving the conventional liar-paradox-like instance is wrong to prove
> the Halting Problem is decidable. At most, such proof proves HP is still
> unsolved. That HP remains unsolved is the most what such an approach can get.
>
> Secondly, you modified Linz's proof to your POOP. Nothing you say is therefore
> valid to the true/false status of Linz's proof.
>
> The discussion is at most about your POOP.

It is about the halting problem because embedded_H rejects its input on
the basis that it specifies a non-halting sequence of configurations.

When the Linz H embedded in the Linz Ĥ (as a simulating halt decider)
rejects its input it is correct even if it does not know that it is
correct. That it is correct refutes the Linz conclusion that it cannot
possibly be correct.

--
Copyright 2021 Pete Olcott

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

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

<877d8mlli0.fsf@bsb.me.uk>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Date: Tue, 22 Mar 2022 03:22:15 +0000
Organization: A noiseless patient Spider
Lines: 27
Message-ID: <877d8mlli0.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="742c17acf5696fbc0906a16a3d94f61a";
logging-data="1138"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/BV9W+UKPlReuxDhkN04RhfRQBC/2Ez3Y="
Cancel-Lock: sha1:Kn6QoCoP4lk8oiF813xHgXkJKR4=
sha1:p56Qpt2Qjz8oYxAHFdH4Nlzzb40=
X-BSB-Auth: 1.b7d5570a29ee83b6a7ba.20220322032215GMT.877d8mlli0.fsf@bsb.me.uk
 by: Ben Bacarisse - Tue, 22 Mar 2022 03:22 UTC

olcott <NoOne@NoWhere.com> writes:

> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
> final state.

But for your "PO-machines":

"Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
corresponds to
H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"

and

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

so this has nothing to do with Linz. He is talking about Turing
machines.

--
Ben.

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

<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.math sci.logic
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 21 Mar 2022 22:59:25 -0500
Date: Mon, 21 Mar 2022 22:59:23 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.math,sci.logic
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <877d8mlli0.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 45
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-skB5nEx4GIdaRWlvSQYQr0zi6SiNPOxDMnWmlku/rM2w+9JOYJHfBw49AVg2srmsR1wBxxewy7u9myl!M8PppK/JAkKGTj3z/AxPMKJCDUAgEiEAKO4++BMmaNX2sS6Tt2sA4Ym91mok4SOKN8EoOkvL/RZs
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: 2816
 by: olcott - Tue, 22 Mar 2022 03:59 UTC

On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
> olcott <NoOne@NoWhere.com> writes:
>
>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>
> But for your "PO-machines":
>
> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
> corresponds to
> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>
> and
>
> "The copy of H at Ĥ.qx correctly decides that its input never halts.
> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>
> so this has nothing to do with Linz. He is talking about Turing
> machines.
>

The Linz conclusion only pertains to the behavior the copy of H
embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge from
this point:

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

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

--
Copyright 2021 Pete Olcott

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

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

<aSh_J.94086$WZCa.47136@fx08.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!peer02.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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com> <Zja_J.200111$Tr18.169844@fx42.iad> <J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 49
Message-ID: <aSh_J.94086$WZCa.47136@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: Tue, 22 Mar 2022 06:50:49 -0400
X-Received-Bytes: 2935
 by: Richard Damon - Tue, 22 Mar 2022 10:50 UTC

On 3/21/22 10:39 PM, olcott wrote:
> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>
>> On 3/21/22 10:05 PM, olcott wrote:
>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>> state.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>> final state.
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>> ⟨Ĥ4⟩...
>>>
>>> Because we can see that a correct simulation of the input to
>>> embedded_H cannot possibly reach its final state we can see that this
>>> input never halts.
>>
>>
>> But ONLY if mbedded_H doesn't abort its simulation.
>>
>
> computation that halts … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> Never halts means that the simulated input will never reach its final
> state whether or not its simulation is aborted.
>

Never Halts means the TURING MACHINE will never reach a final state.
(Where do you get 'Simulation' out of the definition?)

YOu can replace that with a simulation that is ACCURATE, but to be
accurate for non-halting, it must NOT be aborted, i.e., must run forever.

The fact that an aborted simulation didn't reach a final state is NOT
proof that the machine in non-halting.

You don't evn understand basic English.

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

<QVh_J.231119$Gojc.185392@fx99.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!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.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<qfCdnYqgdZ1JqqT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qfCdnYqgdZ1JqqT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 67
Message-ID: <QVh_J.231119$Gojc.185392@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: Tue, 22 Mar 2022 06:54:43 -0400
X-Received-Bytes: 3774
 by: Richard Damon - Tue, 22 Mar 2022 10:54 UTC

On 3/21/22 10:43 PM, olcott wrote:
> On 3/21/2022 9:05 PM, olcott wrote:
>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>> final state.
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>> ⟨Ĥ4⟩...
>>
>
> The above shows that the simulated input to embedded_H will never reach
> its own final state whether or not its simulation is aborted thus never
> meets the Linz definition of halting:
>
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)

No it doesm't. becasue it only shows what happens if you don't abort.

Note!!! Your example is STARTING with an actual Turing Machine H^ being
applied to <H^> as you MUST (or maybe a UTM simulating <H^> <H^>, but
that is the same as the UTM won't abort).

It can't be a trace of a 'embedded_H' as that isn't an actual machine to
trace! but just a piece of one.

>
>> Because we can see that a correct simulation of the input to
>> embedded_H cannot possibly reach its final state we can see that this
>> input never halts.
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Whether or not it is even possible for embedded_H to recognize this
>> infinitely nested simulation does not matter (for refuting Linz).
>>
>> As long as embedded_H transitions to Ĥ.qn it refutes the Linz
>> conclusion that rejecting its input forms a necessary contradiction.
>> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>>
>>
>>
>> After we have mutual agreement on the above point we can move on to
>> how embedded_H would use finite string comparison to detect that its
>> input specifies infinitely nested simulation.
>>
>> Halting problem undecidability and infinitely nested simulation (V4)
>>
>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>
>>
>
>

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

<vZh_J.288006$t2Bb.5721@fx98.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<a1acb3be-94a8-4093-a5b2-f7530bc1a7ean@googlegroups.com>
<RumdnR8gEfm5oqT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <RumdnR8gEfm5oqT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 91
Message-ID: <vZh_J.288006$t2Bb.5721@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 06:58:38 -0400
X-Received-Bytes: 4924
 by: Richard Damon - Tue, 22 Mar 2022 10:58 UTC

On 3/21/22 11:14 PM, olcott wrote:
> On 3/21/2022 9:59 PM, wij wrote:
>> On Tuesday, 22 March 2022 at 10:05:09 UTC+8, olcott wrote:
>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>> state.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>> final state.
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>
>>> Then these steps would keep repeating:
>>> Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>
>>> Because we can see that a correct simulation of the input to embedded_H
>>> cannot possibly reach its final state we can see that this input never
>>> halts.
>>>
>>> computation that halts … the Turing machine will halt whenever it enters
>>> a final state. (Linz:1990:234)
>>>
>>> Whether or not it is even possible for embedded_H to recognize this
>>> infinitely nested simulation does not matter (for refuting Linz).
>>>
>>> As long as embedded_H transitions to Ĥ.qn it refutes the Linz conclusion
>>> that rejecting its input forms a necessary contradiction.
>>> (bottom half of last page) https://www.liarparadox.org/Linz_Proof.pdf
>>>
>>>
>>>
>>> After we have mutual agreement on the above point we can move on to how
>>> embedded_H would use finite string comparison to detect that its input
>>> specifies infinitely nested simulation.
>>>
>>> Halting problem undecidability and infinitely nested simulation (V4)
>>>
>>> https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4
>>>
>>>
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see.
>>> Arthur Schopenhauer
>>
>> The H of the Halting Problem is not required to detect any infinite
>> loop. H is
>>   only required to report whether the given algorithm instance P halts
>> or not.
>>
>> Firstly, proving the conventional liar-paradox-like instance is wrong
>> to prove
>> the Halting Problem is decidable. At most, such proof proves HP is still
>> unsolved. That HP remains unsolved is the most what such an approach
>> can get.
>>
>> Secondly, you modified Linz's proof to your POOP. Nothing you say is
>> therefore
>> valid to the true/false status of Linz's proof.
>>
>> The discussion is at most about your POOP.
>
> It is about the halting problem because embedded_H rejects its input on
> the basis that it specifies a non-halting sequence of configurations.

Except that it doesn't. In only shows a non-halting sequence when
embedded_H DOESN'T reject its input, so at best it is looking at the
wrong input.

>
> When the Linz H embedded in the Linz Ĥ (as a simulating halt decider)
> rejects its input it is correct even if it does not know that it is
> correct. That it is correct refutes the Linz conclusion that it cannot
> possibly be correct.
>
>

Except that it isn't correct. You keep on thinking that Halting can be
shown by an aborted simulation, even when the unaborted machine is shown
to Halt. All you are doing is showing that a DIFFERENT problem, that no
one cares about, can't be shown not to exist by this same sort of proof.
(It still succumbs to things like the Busy Beaver problem).

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

<q%h_J.288007$t2Bb.122633@fx98.iad>

 copy mid

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

 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!newsfeed8.news.xs4all.nl!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx98.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 51
Message-ID: <q%h_J.288007$t2Bb.122633@fx98.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 07:00:41 -0400
X-Received-Bytes: 2761
 by: Richard Damon - Tue, 22 Mar 2022 11:00 UTC

On 3/21/22 11:59 PM, olcott wrote:
> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>>> state.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>> final state.
>>
>> But for your "PO-machines":
>>
>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>    corresponds to
>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>
>> and
>>
>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>
>> so this has nothing to do with Linz.  He is talking about Turing
>> machines.
>>
>
> The Linz conclusion only pertains to the behavior the copy of H
> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge from
> this point:

No, it applies to ALL copies of H, because they ALL behave the same.

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

And this isn't meet as embedded_H didn't do a pure simulation (aka UTM)
if it aborted it.

Fairy Dust Powered Unicorns doing Magic are needed for you 'Proof'.

FAIL.

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

<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!2.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 09:13:41 -0500
Date: Tue, 22 Mar 2022 09:13:41 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <aSh_J.94086$WZCa.47136@fx08.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 91
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JKIXt4YYKWA4FUumW43/9CydN/1fOQbrUfzG0nm5mJRQKwB7+pSKqtSKYWB8naeYz/ZNzHUoQbTTlcS!o+zsAlCJTe3MDsGy1gVXq5KY0PR1VCyMnMqa3wrrutoRlWHjxi5cuCm0cw/YMegQhOvjz32JIl/l
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: 4770
 by: olcott - Tue, 22 Mar 2022 14:13 UTC

On 3/22/2022 5:50 AM, Richard Damon wrote:
> On 3/21/22 10:39 PM, olcott wrote:
>> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>>
>>> On 3/21/22 10:05 PM, olcott wrote:
>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>> (SHD).
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>> final state.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>> its final state.
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>> ⟨Ĥ2⟩
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>> ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>> ⟨Ĥ4⟩...
>>>>
>>>> Because we can see that a correct simulation of the input to
>>>> embedded_H cannot possibly reach its final state we can see that
>>>> this input never halts.
>>>
>>>
>>> But ONLY if mbedded_H doesn't abort its simulation.
>>>
>>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> Never halts means that the simulated input will never reach its final
>> state whether or not its simulation is aborted.
>>
>
> Never Halts means the TURING MACHINE will never reach a final state.
> (Where do you get 'Simulation' out of the definition?)
>

AS YOU ALREADY KNOW:
An executed Turing machine and a Turing machine description simulated by
a UTM are computationally equivalent.

Pretending to not know these things just so that you are can remain
disagreeable is quite a jackass move.

> YOu can replace that with a simulation that is ACCURATE, but to be
> accurate for non-halting, it must NOT be aborted, i.e., must run forever.
>

YET ANOTHER JACKASS MOVE:
You know that aborting the simulation of a Turing machine description
that would never reach its final state does not cause this Turing
machine description to reach its final state.

Therefore you know that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H specifies a
sequence of configuration that never reach their final state under any
circumstances.

Therefore you know that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot meet the
Linz definition of a

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

Therefore you know that when embedded_H rejects its input it is correct.

Therefore you know that when embedded_H rejects its input it and is
correct the Linz proof that asserts that rejecting its input results in
a contradiction is refuted.

> The fact that an aborted simulation didn't reach a final state is NOT
> proof that the machine in non-halting.
>
> You don't evn understand basic English.
>

--
Copyright 2021 Pete Olcott

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

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

<T96dnZRuFIDWR6T_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 09:16:43 -0500
Date: Tue, 22 Mar 2022 09:16:43 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<q%h_J.288007$t2Bb.122633@fx98.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <q%h_J.288007$t2Bb.122633@fx98.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <T96dnZRuFIDWR6T_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sW4eVyDDwKtkuryZt56XW8Xzdfi0a0uj2mW6YVpQFVFo+HOG5vjFrHbfqFz9CYQE3kZP2WxAKISnI+B!1v5H7FhuGEJcX196/a57CYsvnQjYBKFK2/iCRIiztYazRYUY9ms5qJ5SKGESgOKxqR2S2XgI+88Y
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: 2995
 by: olcott - Tue, 22 Mar 2022 14:16 UTC

On 3/22/2022 6:00 AM, Richard Damon wrote:
> On 3/21/22 11:59 PM, olcott wrote:
>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>> (SHD).
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>> final state.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>> final state.
>>>
>>> But for your "PO-machines":
>>>
>>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>    corresponds to
>>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>
>>> and
>>>
>>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>
>>> so this has nothing to do with Linz.  He is talking about Turing
>>> machines.
>>>
>>
>> The Linz conclusion only pertains to the behavior the copy of H
>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge
>> from this point:
>
> No, it applies to ALL copies of H, because they ALL behave the same.

Because the outermost simulation sees that its abort criteria is met
before any of the inner simulations have seen this criteria the
outermost simulation aborts all the rest which cuts off their behavior.

--
Copyright 2021 Pete Olcott

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

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

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

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Date: Tue, 22 Mar 2022 14:32:40 +0000
Organization: A noiseless patient Spider
Lines: 51
Message-ID: <87wngmjbw7.fsf@bsb.me.uk>
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk>
<Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="742c17acf5696fbc0906a16a3d94f61a";
logging-data="29920"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19Ib15Y5KbAHEqVpruRXPUuNgsyyFgmEjY="
Cancel-Lock: sha1:AjmyLZi/cIbqSwXOcsblUNCGSaw=
sha1:IEhLcf5CwzXqW9mMjaly0jvMyuk=
X-BSB-Auth: 1.a18ce7335ca2e49ed788.20220322143240GMT.87wngmjbw7.fsf@bsb.me.uk
 by: Ben Bacarisse - Tue, 22 Mar 2022 14:32 UTC

olcott <NoOne@NoWhere.com> writes:

> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider (SHD).
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final state.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>> final state.
>> But for your "PO-machines":
>> "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>> corresponds to
>> H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>> and
>> "The copy of H at Ĥ.qx correctly decides that its input never halts.
>> H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>> so this has nothing to do with Linz. He is talking about Turing
>> machines.
>>
>
> The Linz conclusion only pertains to the behavior the copy of H
> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Everything Linz says, everything, is predicated on what a Turing machine
is. Unlike Turing machines, your machines are magic -- identical state
transition functions can entail different configuration sequences for
the same input. Nothing you say has any relevance to Linz's Turing
machines until you categorically repudiate this nonsense.

> I don't have time to diverge from this point:
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
> state.

And, since the action of your magic machines are not constrained by the
state transition function and the input, I can assert that a copy of
our Ĥ does this:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.q99 wibble

with just as much justification. Can you prove that no copy of your
magic Ĥ does not write "wibble" to the tape and transition to state q99
when given ⟨Ĥ⟩ as input?

--
Ben.

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

<tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!2.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 09:46:40 -0500
Date: Tue, 22 Mar 2022 09:46:39 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <87wngmjbw7.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 81
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zRCtVBZPl+ALLzWv1Q3Q/XUL1T0fDbHidgqpOqMjnYx9b3S+a11coZMqKsxeAiqfYp4+Q7bFf80RP/q!75nItwjSwsG8vCd3CYDFmWOlRv3Q0BASWQYdmDtlq5lJj2/ayojs8TrpeNArw4SoFVMcrCsEEqAM
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: 4818
 by: olcott - Tue, 22 Mar 2022 14:46 UTC

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

That your only rebuttal to what I say now is dredging up what I said
many months ago proves that you are being dishonest.

It is the case that the pure simulation of the input to the simulating
halt decider Linz H embedded at Ĥ.qx would never reach the final state
of this simulated input.

You ignore this and change the subject only because you know that it is
correct and have denigration rather than honest critique as your only goal.

>> I don't have time to diverge from this point:
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its final
>> state.
>
> And, since the action of your magic machines are not constrained by the
> state transition function and the input, I can assert that a copy of
> our Ĥ does this:
>

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

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

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

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

Halting problem undecidability and infinitely nested simulation (V4)
https://www.researchgate.net/publication/359349179_Halting_problem_undecidability_and_infinitely_nested_simulation_V4

--
Copyright 2021 Pete Olcott

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

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

<rvs_J.318099$mF2.144337@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!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!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 124
Message-ID: <rvs_J.318099$mF2.144337@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 18:57:30 -0400
X-Received-Bytes: 5689
 by: Richard Damon - Tue, 22 Mar 2022 22:57 UTC

On 3/22/22 10:13 AM, olcott wrote:
> On 3/22/2022 5:50 AM, Richard Damon wrote:
>> On 3/21/22 10:39 PM, olcott wrote:
>>> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>>>
>>>> On 3/21/22 10:05 PM, olcott wrote:
>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>> (SHD).
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>> final state.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>> its final state.
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩ ⟨Ĥ1⟩
>>>>>
>>>>> Then these steps would keep repeating:
>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩
>>>>> ⟨Ĥ2⟩
>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩
>>>>> ⟨Ĥ3⟩
>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩
>>>>> ⟨Ĥ4⟩...
>>>>>
>>>>> Because we can see that a correct simulation of the input to
>>>>> embedded_H cannot possibly reach its final state we can see that
>>>>> this input never halts.
>>>>
>>>>
>>>> But ONLY if mbedded_H doesn't abort its simulation.
>>>>
>>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> Never halts means that the simulated input will never reach its final
>>> state whether or not its simulation is aborted.
>>>
>>
>> Never Halts means the TURING MACHINE will never reach a final state.
>> (Where do you get 'Simulation' out of the definition?)
>>
>
> AS YOU ALREADY KNOW:
> An executed Turing machine and a Turing machine description simulated by
> a UTM are computationally equivalent.
>
> Pretending to not know these things just so that you are can remain
> disagreeable is quite a jackass move.
>
>> YOu can replace that with a simulation that is ACCURATE, but to be
>> accurate for non-halting, it must NOT be aborted, i.e., must run forever.
>>
>
> YET ANOTHER JACKASS MOVE:
> You know that aborting the simulation of a Turing machine description
> that would never reach its final state does not cause this Turing
> machine description to reach its final state.

The problem you have is that that the simulation that shows it would
never reach a final state requries that H/embedded_H NEVER abort its
simulation.

Yes, SOME OTHER decider could abort it and correctly answer, but if
H/embedded_H does, then it was incorrect in its simulation.

The 'Jackass Move' is you trying to pull the switcheroo.

H / embedded_H must be a FIXED algorithm, something external isn't
allowed to change it. Thus, it must EITHER NEVER abort, and thus we can
show that H^ applied to <H^> is non-Halting, or it DOES abort, and go to
Qn, and in then we can show that H^ appleid to <H^> WILL HALT.

Your failure to understand this says NOTHING you might claim as
'self-evident' in this field merits ANY attention.

>
> Therefore you know that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H specifies a
> sequence of configuration that never reach their final state under any
> circumstances.

Nope, only under the condition that embedded_H NEVER aborts its simulation.

>
> Therefore you know that the input ⟨Ĥ⟩ ⟨Ĥ⟩ to embedded_H cannot meet the
> Linz definition of a
>
> computation that halts … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234) UNDER ANY CIRCUMSTANCES

Nope, ONLY under the condition that embedded_H NEVER abort its simulation.

>
> Therefore you know that when embedded_H rejects its input it is correct.

Nope, when it rejects its input, it has violated the premises that it
used to 'prove' the input was non-halting, and thus has reached an
UNSOUND conclusion.

>
> Therefore you know that when embedded_H rejects its input it and is
> correct the Linz proof that asserts that rejecting its input results in
> a contradiction is refuted.

Nope. You are just proving you just don't understand what you are saying.

FAIL

>
>> The fact that an aborted simulation didn't reach a final state is NOT
>> proof that the machine in non-halting.
>>
>> You don't evn understand basic English.
>>
>
>

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

<1xs_J.318101$mF2.147367@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<q%h_J.288007$t2Bb.122633@fx98.iad>
<T96dnZRuFIDWR6T_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <T96dnZRuFIDWR6T_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 52
Message-ID: <1xs_J.318101$mF2.147367@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 18:59:13 -0400
X-Received-Bytes: 3047
 by: Richard Damon - Tue, 22 Mar 2022 22:59 UTC

On 3/22/22 10:16 AM, olcott wrote:
> On 3/22/2022 6:00 AM, Richard Damon wrote:
>> On 3/21/22 11:59 PM, olcott wrote:
>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>> (SHD).
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>> final state.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>> final state.
>>>>
>>>> But for your "PO-machines":
>>>>
>>>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>    corresponds to
>>>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>
>>>> and
>>>>
>>>>    "The copy of H at Ĥ.qx correctly decides that its input never halts.
>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>
>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>> machines.
>>>>
>>>
>>> The Linz conclusion only pertains to the behavior the copy of H
>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge
>>> from this point:
>>
>> No, it applies to ALL copies of H, because they ALL behave the same.
>
> Because the outermost simulation sees that its abort criteria is met
> before any of the inner simulations have seen this criteria the
> outermost simulation aborts all the rest which cuts off their behavior.
>
>

But we don't care about simulations, we care about actual machine
exectuitons.

If embedded_H applied to <H^> <H^> goes to Qn, then by construction (and
accepted by you) H^ applied to <H^> WILL HALT. THAT is the DEFINITION of
what the Halt Decider is supposed to report on, so it is just WRONG.

FAIL.

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

<xys_J.318102$mF2.179107@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 89
Message-ID: <xys_J.318102$mF2.179107@fx11.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 19:00:49 -0400
X-Received-Bytes: 4907
 by: Richard Damon - Tue, 22 Mar 2022 23:00 UTC

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

The above only doesn't halt if embedded_H never aborts its simulation,
at which point embedded_H and H both FAIL to be deciders.

If embedded_H does abort and go to Qn, then H^ applied to <H^> will halt
when its copy of embedded_H goes to Qn as that is also its Qn and it
halts there.

FAIL.

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

<rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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!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: Tue, 22 Mar 2022 18:07:13 -0500
Date: Tue, 22 Mar 2022 18:07:12 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<rvs_J.318099$mF2.144337@fx11.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <rvs_J.318099$mF2.144337@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 78
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gtMOnEzilMoPinsQlFBbPXaCzb/Vu/tL2hvw7giwXyUuW/5Q0Yc777gn0BCLEhELAEeXPBxGiNAd2PW!D5jQXqdNbY+A6oxGo+raUCOoQRCFo/vPJmqvY9IDsxb/RiutZaNMZTw8v8cORdOk2fyR8raiF4Y2
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: 4557
 by: olcott - Tue, 22 Mar 2022 23:07 UTC

On 3/22/2022 5:57 PM, Richard Damon wrote:
> On 3/22/22 10:13 AM, olcott wrote:
>> On 3/22/2022 5:50 AM, Richard Damon wrote:
>>> On 3/21/22 10:39 PM, olcott wrote:
>>>> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>>>>
>>>>> On 3/21/22 10:05 PM, olcott wrote:
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>> (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>>> its final state.
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>> ⟨Ĥ1⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>
>>>>>> Because we can see that a correct simulation of the input to
>>>>>> embedded_H cannot possibly reach its final state we can see that
>>>>>> this input never halts.
>>>>>
>>>>>
>>>>> But ONLY if mbedded_H doesn't abort its simulation.
>>>>>
>>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> Never halts means that the simulated input will never reach its
>>>> final state whether or not its simulation is aborted.
>>>>
>>>
>>> Never Halts means the TURING MACHINE will never reach a final state.
>>> (Where do you get 'Simulation' out of the definition?)
>>>
>>
>> AS YOU ALREADY KNOW:
>> An executed Turing machine and a Turing machine description simulated
>> by a UTM are computationally equivalent.
>>
>> Pretending to not know these things just so that you are can remain
>> disagreeable is quite a jackass move.
>>
>>> YOu can replace that with a simulation that is ACCURATE, but to be
>>> accurate for non-halting, it must NOT be aborted, i.e., must run
>>> forever.
>>>
>>
>> YET ANOTHER JACKASS MOVE:
>> You know that aborting the simulation of a Turing machine description
>> that would never reach its final state does not cause this Turing
>> machine description to reach its final state.
>
> The problem you have is that that the simulation that shows it would
> never reach a final state requries that H/embedded_H NEVER abort its
> simulation.
So basically when the simulated input has had it simulation aborted it
continues on and reaches its final state even though it was aborted.

--
Copyright 2021 Pete Olcott

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

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

<ULSdnTbJAPAbyqf_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Followup: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!1.us.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 22 Mar 2022 18:11:02 -0500
Date: Tue, 22 Mar 2022 18:11:01 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<q%h_J.288007$t2Bb.122633@fx98.iad>
<T96dnZRuFIDWR6T_nZ2dnUU7_8xh4p2d@giganews.com>
<1xs_J.318101$mF2.147367@fx11.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <1xs_J.318101$mF2.147367@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ULSdnTbJAPAbyqf_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 60
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WhumSMU1tmASH+S9jGRwaXpN6EhJxx0ZsaocPz0Ux69A5tELeatDBp798Di2Q6lCdrFAH2CeHxezty0!z8cNXBSVVy0GI/Pr638R3jygIABqqO/4HBnNgVCOcGUQDDhZtsEWqeB8FiJM78YOpc6OsVFu/pBf
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: 3601
 by: olcott - Tue, 22 Mar 2022 23:11 UTC

On 3/22/2022 5:59 PM, Richard Damon wrote:
> On 3/22/22 10:16 AM, olcott wrote:
>> On 3/22/2022 6:00 AM, Richard Damon wrote:
>>> On 3/21/22 11:59 PM, olcott wrote:
>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>> (SHD).
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>> final state.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its
>>>>>> final state.
>>>>>
>>>>> But for your "PO-machines":
>>>>>
>>>>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>    corresponds to
>>>>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>
>>>>> and
>>>>>
>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>> halts.
>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>
>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>> machines.
>>>>>
>>>>
>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge
>>>> from this point:
>>>
>>> No, it applies to ALL copies of H, because they ALL behave the same.
>>
>> Because the outermost simulation sees that its abort criteria is met
>> before any of the inner simulations have seen this criteria the
>> outermost simulation aborts all the rest which cuts off their behavior.
>>
>>
>
> But we don't care about simulations, we care about actual machine
> exectuitons.

So yet again you reject the computational equivalence of the direct
execution of a Turing machine with the UTM simulation of the Turing
machine description of this same machine.

--
Copyright 2021 Pete Olcott

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

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

<ULSdnTHJAPCFxaf_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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: Tue, 22 Mar 2022 18:13:28 -0500
Date: Tue, 22 Mar 2022 18:13:27 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<xys_J.318102$mF2.179107@fx11.iad>
Followup-To: comp.theory
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <xys_J.318102$mF2.179107@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ULSdnTHJAPCFxaf_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 94
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-REo+DaN9I+4ofh1ohqGavHAV2l9nXXRSiL8NUhO135vTUit8OBoeSCnkn0Q9um5Wm+dXS5dGOt9sqex!VVp20JUrFX6pPRZ/ZSPKNurKEj8i2PyYZUgqzoXLxNHBvckt9OUjDx/pAA8AIGVyxQEcv18xshP4
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: 5418
 by: olcott - Tue, 22 Mar 2022 23:13 UTC

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

--
Copyright 2021 Pete Olcott

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

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

<2Ws_J.457799$aT3.354849@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!news.freedyn.de!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ disingenuous ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<Zja_J.200111$Tr18.169844@fx42.iad>
<J_udnbiNL6Nbq6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<aSh_J.94086$WZCa.47136@fx08.iad>
<T96dnZVuFIAIRKT_nZ2dnUU7_8zNnZ2d@giganews.com>
<rvs_J.318099$mF2.144337@fx11.iad>
<rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <rbmdnRMhEq48y6f_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 89
Message-ID: <2Ws_J.457799$aT3.354849@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 19:25:53 -0400
X-Received-Bytes: 5066
 by: Richard Damon - Tue, 22 Mar 2022 23:25 UTC

On 3/22/22 7:07 PM, olcott wrote:
> On 3/22/2022 5:57 PM, Richard Damon wrote:
>> On 3/22/22 10:13 AM, olcott wrote:
>>> On 3/22/2022 5:50 AM, Richard Damon wrote:
>>>> On 3/21/22 10:39 PM, olcott wrote:
>>>>> On 3/21/2022 9:16 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 3/21/22 10:05 PM, olcott wrote:
>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>>> (SHD).
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>> final state.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>>>> its final state.
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>    Ĥ copies its input ⟨Ĥ0⟩ to ⟨Ĥ1⟩ then embedded_H simulates ⟨Ĥ0⟩
>>>>>>> ⟨Ĥ1⟩
>>>>>>>
>>>>>>> Then these steps would keep repeating:
>>>>>>>    Ĥ0 copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates
>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates
>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates
>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩...
>>>>>>>
>>>>>>> Because we can see that a correct simulation of the input to
>>>>>>> embedded_H cannot possibly reach its final state we can see that
>>>>>>> this input never halts.
>>>>>>
>>>>>>
>>>>>> But ONLY if mbedded_H doesn't abort its simulation.
>>>>>>
>>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>>
>>>>> Never halts means that the simulated input will never reach its
>>>>> final state whether or not its simulation is aborted.
>>>>>
>>>>
>>>> Never Halts means the TURING MACHINE will never reach a final state.
>>>> (Where do you get 'Simulation' out of the definition?)
>>>>
>>>
>>> AS YOU ALREADY KNOW:
>>> An executed Turing machine and a Turing machine description simulated
>>> by a UTM are computationally equivalent.
>>>
>>> Pretending to not know these things just so that you are can remain
>>> disagreeable is quite a jackass move.
>>>
>>>> YOu can replace that with a simulation that is ACCURATE, but to be
>>>> accurate for non-halting, it must NOT be aborted, i.e., must run
>>>> forever.
>>>>
>>>
>>> YET ANOTHER JACKASS MOVE:
>>> You know that aborting the simulation of a Turing machine description
>>> that would never reach its final state does not cause this Turing
>>> machine description to reach its final state.
>>
>> The problem you have is that that the simulation that shows it would
>> never reach a final state requries that H/embedded_H NEVER abort its
>> simulation.
> So basically when the simulated input has had it simulation aborted it
> continues on and reaches its final state even though it was aborted.
>

Not the 'simulation of it by H', but the simulation of it by a UTM or
the actual exectution, which are what matters, do.

You keep on trying to use the WRONG definition of Halting. It has ALWAYS
been about the actual execution of the actual Turing Machine, and
simulations can only come into play if/when they EXATLY match that
behavior (so you still need to look at the actual execution).

Just asking the question shows you don't understand Turing Machines and
think they need some 'machine' to run them. Why do you think they are
called Turing MACHINES? The ARE the machine that runs themselves.

They aren't some general purpose chunk of software, but each Turing
Machine is a specially built MACHINE that performs a calculation (no
batteries/plug needed, they are self powered).

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

<9Ys_J.457800$aT3.72012@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an
algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com>
<877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com>
<q%h_J.288007$t2Bb.122633@fx98.iad>
<T96dnZRuFIDWR6T_nZ2dnUU7_8xh4p2d@giganews.com>
<1xs_J.318101$mF2.147367@fx11.iad>
<ULSdnTbJAPAbyqf_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ULSdnTbJAPAbyqf_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 59
Message-ID: <9Ys_J.457800$aT3.72012@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 19:28:09 -0400
X-Received-Bytes: 3396
 by: Richard Damon - Tue, 22 Mar 2022 23:28 UTC

On 3/22/22 7:11 PM, olcott wrote:
> On 3/22/2022 5:59 PM, Richard Damon wrote:
>> On 3/22/22 10:16 AM, olcott wrote:
>>> On 3/22/2022 6:00 AM, Richard Damon wrote:
>>>> On 3/21/22 11:59 PM, olcott wrote:
>>>>> On 3/21/2022 10:22 PM, Ben Bacarisse wro0te:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> A copy of Linz H is embedded at Ĥ.qx as a simulating halt decider
>>>>>>> (SHD).
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its
>>>>>>> final state.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> If the pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach
>>>>>>> its
>>>>>>> final state.
>>>>>>
>>>>>> But for your "PO-machines":
>>>>>>
>>>>>>    "Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
>>>>>>    corresponds to
>>>>>>    H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"
>>>>>>
>>>>>> and
>>>>>>
>>>>>>    "The copy of H at Ĥ.qx correctly decides that its input never
>>>>>> halts.
>>>>>>    H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts"
>>>>>>
>>>>>> so this has nothing to do with Linz.  He is talking about Turing
>>>>>> machines.
>>>>>>
>>>>>
>>>>> The Linz conclusion only pertains to the behavior the copy of H
>>>>> embedded within Ĥ applied to ⟨Ĥ⟩ ⟨Ĥ⟩. I don't have time to diverge
>>>>> from this point:
>>>>
>>>> No, it applies to ALL copies of H, because they ALL behave the same.
>>>
>>> Because the outermost simulation sees that its abort criteria is met
>>> before any of the inner simulations have seen this criteria the
>>> outermost simulation aborts all the rest which cuts off their behavior.
>>>
>>>
>>
>> But we don't care about simulations, we care about actual machine
>> exectuitons.
>
> So yet again you reject the computational equivalence of the direct
> execution of a Turing machine with the UTM simulation of the Turing
> machine description of this same machine.
>
>

But a UTM simulation will never abort its simulation, so H / embedded_H
isn't a UTM simulation.

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

<SZs_J.457801$aT3.60942@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr2.eu1.usenetexpress.com!feeder5.feed.usenet.farm!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!fx09.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0) Gecko/20100101 Thunderbird/91.7.0
Subject: Re: Refuting the Peter Linz Halting Problem Proof V5 [ without an algorithm ]
Content-Language: en-US
Newsgroups: comp.theory
References: <3amdnfYHIblTs6T_nZ2dnUU7_8zNnZ2d@giganews.com> <877d8mlli0.fsf@bsb.me.uk> <Cv6dnf-LGsYA1KT_nZ2dnUU7_8zNnZ2d@giganews.com> <87wngmjbw7.fsf@bsb.me.uk> <tOqdnXu-xuDNfKT_nZ2dnUU7_8zNnZ2d@giganews.com> <xys_J.318102$mF2.179107@fx11.iad> <ULSdnTHJAPCFxaf_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ULSdnTHJAPCFxaf_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 96
Message-ID: <SZs_J.457801$aT3.60942@fx09.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Tue, 22 Mar 2022 19:29:57 -0400
X-Received-Bytes: 5351
 by: Richard Damon - Tue, 22 Mar 2022 23:29 UTC

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

Except that the actual machine DOES Halt, as does the UTM simulation.
THe only one that doesn't reach the halting state is the
INCORRECT/PARTIAL simulaiton by embedded_H, which doesn't count.

Pages:12345
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor