Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #33708 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-05-16 14:09 -0500 |
| Last post | 2021-05-17 20:34 -0500 |
| Articles | 20 on this page of 32 — 6 participants |
Back to article view | Back to comp.theory
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 14:09 -0500
Re: Infinitely Recursive input on HP Proofs Jeff Barnett <jbb@notatt.com> - 2021-05-16 13:46 -0600
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 19:05 -0400
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 18:21 -0500
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 21:11 -0400
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 21:01 -0500
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 23:18 -0400
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 22:23 -0500
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 07:11 -0400
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 07:26 -0400
Re: Infinitely Recursive input on HP Proofs Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-05-17 05:45 -0700
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-17 10:23 -0500
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 20:41 -0400
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-17 20:27 +0100
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-17 14:31 -0500
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-18 01:38 +0100
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-17 19:54 -0500
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 21:21 -0400
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-20 12:57 +0100
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-17 20:43 -0400
Re: Infinitely Recursive input on HP Proofs André G. Isaak <agisaak@gm.invalid> - 2021-05-16 19:15 -0600
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 20:34 -0500
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 21:55 -0400
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 15:56 -0400
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-16 21:21 +0100
Re: Infinitely Recursive input on HP Proofs Richard Damon <Richard@Damon-Family.org> - 2021-05-16 17:19 -0400
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 16:37 -0500
Re: Infinitely Recursive input on HP Proofs olcott <NoOne@NoWhere.com> - 2021-05-16 16:00 -0500
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-17 02:19 +0100
Re: Infinitely Recursive input on HP Proofs (Full Linz text) olcott <NoOne@NoWhere.com> - 2021-05-16 20:54 -0500
Re: Infinitely Recursive input on HP Proofs (Full Linz text) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-18 01:57 +0100
Re: Infinitely Recursive input on HP Proofs (eternally on this point) olcott <NoOne@NoWhere.com> - 2021-05-17 20:34 -0500
Page 1 of 2 [1] 2 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-16 14:09 -0500 |
| Subject | Re: Infinitely Recursive input on HP Proofs |
| Message-ID | <a4ydnWkMIKhS8Dz9nZ2dnUU7-L3NnZ2d@giganews.com> |
On 3/11/2017 3:13 PM, peteolcott wrote: > http://LiarParadox.org/HP_Infinite_Recursion.pdf > > As this page 319 of An Introduction to Formal Languages and Automata > by Peter Linz 1990 indicates > > From H' we construct another Turing machine H-Hat. This new machine takes as input Wm, copies it then behaves exactly like H'. > > q0 Wm |-* H-Hat q0 Wm Wm... > > Page 320 indicates that we apply H-Hat to itself as input. > > The problem is that every H-Hat needs a pair of inputs. > > H-Hat takes an H-Hat as input and copies it so that it > can analyze how its input H-hat would analyze the copy > of H-Hat that it just made. > > The input H-Hat would have to copy its own input H-Hat > so that it can analyze what its own input H-Hat would > do on its own input, on and on forever... > > Copyright 2016 and 2017 Pete Olcott. > Any genius knowing the theory of computation quite well can easily confirm that Ĥ(Ĥ) specifies the non halting behavior pattern of [infinitely_nested_simulation] to every simulating halt decider. This equally applies to all of the halting problem instances. Ĥ(Ĥ) is short-hand for: Now Ĥ is a Turing machine, so that it will have some description in Σ*, say ŵ. This string, in addition to being the description of Ĥ can also be used as input string. We can therefore legitimately ask what would happen if Ĥ is applied to ŵ. (Linz:1990:320) Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. (315-320) http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-05-16 13:46 -0600 |
| Message-ID | <s7rsqh$8rg$1@dont-email.me> |
| In reply to | #33708 |
On 5/16/2021 1:09 PM, olcott wrote: > On 3/11/2017 3:13 PM, peteolcott wrote: > Any genius knowing the theory of computation Ah, we are at the heart of the matter!!!! 1) You are not a genius, not even close. Just a lonesome troll feeding on newsgroup interactions for the human interactions in her/his life. 2) You have shown no knowledge of theory of computation or, its engineering kin, software engineer. I think your life would be much more fulfilling if you wrote a foundational paper "Cut and Pasting, Theory and Practice" and then a minor epic such as "Emphasis from the Cap Key and Repetition". Together they would revolutionize keyboard designs and give you a firm place in the history of the field. Trolling, at last, would be put on a firm scientific and engineering foundation and could join other modern occupations that are well prepared for the future. BTW, don't forget to patent and copyright your papers. -- Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-16 19:05 -0400 |
| Message-ID | <_yhoI.542847$nn2.449398@fx48.iad> |
| In reply to | #33708 |
On 5/16/21 5:37 PM, olcott wrote: > On 5/16/2021 4:19 PM, Richard Damon wrote: >> On 5/16/21 5:00 PM, olcott wrote: >>> On 5/16/2021 3:21 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> Any genius knowing the theory of computation quite well can easily >>>>> confirm that Ĥ(Ĥ) specifies the non halting behavior pattern of >>>>> [infinitely_nested_simulation] to every simulating halt decider. >>>>> This equally applies to all of the halting problem instances. >>>>> >>>>> Ĥ(Ĥ) is short-hand for: >>>>> Now Ĥ is a Turing machine, so that it will have some description in >>>>> Σ*, >>>>> say ŵ. This string, in addition to being the description of Ĥ can >>>>> also be used >>>>> as input string. We can therefore legitimately ask what would happen >>>>> if Ĥ is >>>>> applied to ŵ. (Linz:1990:320) >>>>> >>>>> Linz, Peter 1990. An Introduction to Formal Languages and >>>>> Automata. Lexington/Toronto: D. C. Heath and Company. (315-320) >>>> >>>> Nonsense. H is the name given in Linz to a non-existent Turing >>>> machine. H^, derived from it, also does not exit. Anyone who has read >>>> that book should know that H^([H^]) specifies no behaviour at all. >>>> >>>> You have constructed a poor-man's partial decider that gets the "hat" >>>> case wrong, but you can't justify the wrong answer by appeal Linz. >>>> >>>> Your "infinitely nested simulation" explanation for your decider giving >>>> the wrong answer can be put on a more formal basis, but you can't do by >>>> re-using the names of nonexistent TM's from Linz. >>>> >>> >>> Well I won't say that you are not a genius or that you don't know the >>> theory of computation very well. >>> >>> The actual Ĥ(<Ĥ>) does specify [infinitely_nested_simulation] to every >>> simulating halt decider. This [infinitely_nested_simulation] is more >>> complex than the one that Halts recognizes. >>> >>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >>> >>> The above is adapted from (Linz:1990:319). >>> It shows that Turing machine Ĥ copies its input at (q0) and begins >>> executing an embedded copy of the original halt decider with this input >>> at (qx). >>> >>> The (qy) state indicates that the halt decider decides that its input >>> would halt. The ((qn)) state indicates the input would not halt. The >>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >>> decider decides that its input would halt. >>> >>> It can be understood from the above specification that when the embedded >>> halt decider @Ĥ.qx bases its halting decision on simulating its input, >>> and it has (Ĥ, Ĥ) as its input that: >>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>> this copy then >>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>> this copy then >>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>> this copy... >>> unless and until the halt decider @Ĥ.qx stops simulating its input. >> >> BUT, since H is required to be finite in execution, the copy of H within >> H^ must have some alteration from a simple simulator to break the loop. >> >> If it does, then it WILL break the loop, and be finite in execution. >> >> If it doesn't then H(H^,H^) won't break the loop, and thus will not >> answer in finite time and thus fail to give an answer and not be a >> decider. >> > > That is why we need this truism to dislodge the pathological > self-reference: > > On 5/11/2021 11:10 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> Truism: >>> Every simulation that would never stop unless Halts() stops >>> it at some point specifies infinite execution. >> >> Any algorithm that implements this truism is, of course, a halting >> decider. > > Whether a computation is finite is more nuanced than it simply stops > running otherwise an infinite loop that had its simulation aborted > because its behavior matched the [infinite_loop] non-halting behavior > pattern would have to be classified as a halting computation. > > Unless the simulating halt decider stops simulating Ĥ(Ĥ) at some point > its simulation would be infinite ∴ meets the non-halting truism. > But you can't use a 'Falsism' to change the facts about the definition. And, as I have said, there IS no pathological self-reference in the problem. YOU create the self-reference by not implementing the required copy operation. In actuality the Linz proof has no real self-reference, just two copies of what just happens to be the same thing.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-16 18:21 -0500 |
| Message-ID | <EsCdnduL051HNTz9nZ2dnUU7-d_NnZ2d@giganews.com> |
| In reply to | #33715 |
On 5/16/2021 6:05 PM, Richard Damon wrote: > On 5/16/21 5:37 PM, olcott wrote: >> On 5/16/2021 4:19 PM, Richard Damon wrote: >>> On 5/16/21 5:00 PM, olcott wrote: >>>> On 5/16/2021 3:21 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> Any genius knowing the theory of computation quite well can easily >>>>>> confirm that Ĥ(Ĥ) specifies the non halting behavior pattern of >>>>>> [infinitely_nested_simulation] to every simulating halt decider. >>>>>> This equally applies to all of the halting problem instances. >>>>>> >>>>>> Ĥ(Ĥ) is short-hand for: >>>>>> Now Ĥ is a Turing machine, so that it will have some description in >>>>>> Σ*, >>>>>> say ŵ. This string, in addition to being the description of Ĥ can >>>>>> also be used >>>>>> as input string. We can therefore legitimately ask what would happen >>>>>> if Ĥ is >>>>>> applied to ŵ. (Linz:1990:320) >>>>>> >>>>>> Linz, Peter 1990. An Introduction to Formal Languages and >>>>>> Automata. Lexington/Toronto: D. C. Heath and Company. (315-320) >>>>> >>>>> Nonsense. H is the name given in Linz to a non-existent Turing >>>>> machine. H^, derived from it, also does not exit. Anyone who has read >>>>> that book should know that H^([H^]) specifies no behaviour at all. >>>>> >>>>> You have constructed a poor-man's partial decider that gets the "hat" >>>>> case wrong, but you can't justify the wrong answer by appeal Linz. >>>>> >>>>> Your "infinitely nested simulation" explanation for your decider giving >>>>> the wrong answer can be put on a more formal basis, but you can't do by >>>>> re-using the names of nonexistent TM's from Linz. >>>>> >>>> >>>> Well I won't say that you are not a genius or that you don't know the >>>> theory of computation very well. >>>> >>>> The actual Ĥ(<Ĥ>) does specify [infinitely_nested_simulation] to every >>>> simulating halt decider. This [infinitely_nested_simulation] is more >>>> complex than the one that Halts recognizes. >>>> >>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >>>> >>>> The above is adapted from (Linz:1990:319). >>>> It shows that Turing machine Ĥ copies its input at (q0) and begins >>>> executing an embedded copy of the original halt decider with this input >>>> at (qx). >>>> >>>> The (qy) state indicates that the halt decider decides that its input >>>> would halt. The ((qn)) state indicates the input would not halt. The >>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >>>> decider decides that its input would halt. >>>> >>>> It can be understood from the above specification that when the embedded >>>> halt decider @Ĥ.qx bases its halting decision on simulating its input, >>>> and it has (Ĥ, Ĥ) as its input that: >>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>> this copy then >>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>> this copy then >>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>> this copy... >>>> unless and until the halt decider @Ĥ.qx stops simulating its input. >>> >>> BUT, since H is required to be finite in execution, the copy of H within >>> H^ must have some alteration from a simple simulator to break the loop. >>> >>> If it does, then it WILL break the loop, and be finite in execution. >>> >>> If it doesn't then H(H^,H^) won't break the loop, and thus will not >>> answer in finite time and thus fail to give an answer and not be a >>> decider. >>> >> >> That is why we need this truism to dislodge the pathological >> self-reference: >> >> On 5/11/2021 11:10 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> Truism: >>>> Every simulation that would never stop unless Halts() stops >>>> it at some point specifies infinite execution. >>> >>> Any algorithm that implements this truism is, of course, a halting >>> decider. >> >> Whether a computation is finite is more nuanced than it simply stops >> running otherwise an infinite loop that had its simulation aborted >> because its behavior matched the [infinite_loop] non-halting behavior >> pattern would have to be classified as a halting computation. >> >> Unless the simulating halt decider stops simulating Ĥ(Ĥ) at some point >> its simulation would be infinite ∴ meets the non-halting truism. >> > > But you can't use a 'Falsism' to change the facts about the definition. > > And, as I have said, there IS no pathological self-reference in the problem. > > YOU create the self-reference by not implementing the required copy > operation. In actuality the Linz proof has no real self-reference, just > two copies of what just happens to be the same thing. > I am referring to the complete Peter Linz version where a copy <is> made. Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn The above is adapted from (Linz:1990:319). It shows that Turing machine Ĥ copies its input at (q0) and begins executing an embedded copy of the original halt decider with this input at (qx). The (qy) state indicates that the halt decider decides that its input would halt. The ((qn)) state indicates the input would not halt. The appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt decider decides that its input would halt. It can be understood from the above specification that when the embedded halt decider @Ĥ.qx bases its halting decision on simulating its input, and it has (Ĥ, Ĥ) as its input that: Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with this copy then Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with this copy then Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with this copy... unless and until the halt decider @Ĥ.qx stops simulating its input. Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-16 21:11 -0400 |
| Message-ID | <HojoI.604824$%W6.542760@fx44.iad> |
| In reply to | #33735 |
On 5/16/21 7:21 PM, olcott wrote: > On 5/16/2021 6:05 PM, Richard Damon wrote: >> >> But you can't use a 'Falsism' to change the facts about the definition. >> >> And, as I have said, there IS no pathological self-reference in the >> problem. >> >> YOU create the self-reference by not implementing the required copy >> operation. In actuality the Linz proof has no real self-reference, just >> two copies of what just happens to be the same thing. >> > > I am referring to the complete Peter Linz version where a copy <is> made. > > Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ > Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn > > The above is adapted from (Linz:1990:319). > It shows that Turing machine Ĥ copies its input at (q0) and begins > executing an embedded copy of the original halt decider with this input > at (qx). > > The (qy) state indicates that the halt decider decides that its input > would halt. The ((qn)) state indicates the input would not halt. The > appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt > decider decides that its input would halt. > > It can be understood from the above specification that when the embedded > halt decider @Ĥ.qx bases its halting decision on simulating its input, > and it has (Ĥ, Ĥ) as its input that: > Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with > this copy then > Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with > this copy then > Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with > this copy... > unless and until the halt decider @Ĥ.qx stops simulating its input. > > Linz, Peter 1990. An Introduction to Formal Languages and Automata. > Lexington/Toronto: D. C. Heath and Company. > > > Key point to notice is that Linz's description doesn't have ANY self-reference, or even things done via a 'reference' EVERYTHING is done with a copy, and there is no references to be self. H^ has its own copy of the algorithm of H in it, it doesn't 'reference' H, so this is NOT a self-reference. The input to H^ doesn't 'reference' H^, it is built on the description of H^ With no references, you can't have self-reference. The only self-references in your 'proof' are the one YOU create by not making the 'required' copies. This also makes it so things are likely not actually the Equivalents of the required Turing Machines. Another flaw in your proof.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-16 21:01 -0500 |
| Message-ID | <daudnYwj2vzXUzz9nZ2dnUU7-XPNnZ2d@giganews.com> |
| In reply to | #33740 |
On 5/16/2021 8:11 PM, Richard Damon wrote: > On 5/16/21 7:21 PM, olcott wrote: >> On 5/16/2021 6:05 PM, Richard Damon wrote: > >>> >>> But you can't use a 'Falsism' to change the facts about the definition. >>> >>> And, as I have said, there IS no pathological self-reference in the >>> problem. >>> >>> YOU create the self-reference by not implementing the required copy >>> operation. In actuality the Linz proof has no real self-reference, just >>> two copies of what just happens to be the same thing. >>> >> >> I am referring to the complete Peter Linz version where a copy <is> made. >> >> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >> >> The above is adapted from (Linz:1990:319). >> It shows that Turing machine Ĥ copies its input at (q0) and begins >> executing an embedded copy of the original halt decider with this input >> at (qx). >> >> The (qy) state indicates that the halt decider decides that its input >> would halt. The ((qn)) state indicates the input would not halt. The >> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >> decider decides that its input would halt. >> >> It can be understood from the above specification that when the embedded >> halt decider @Ĥ.qx bases its halting decision on simulating its input, >> and it has (Ĥ, Ĥ) as its input that: >> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >> this copy then >> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >> this copy then >> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >> this copy... >> unless and until the halt decider @Ĥ.qx stops simulating its input. >> >> Linz, Peter 1990. An Introduction to Formal Languages and Automata. >> Lexington/Toronto: D. C. Heath and Company. >> >> >> > Key point to notice is that Linz's description doesn't have ANY > self-reference, or even things done via a 'reference' > > EVERYTHING is done with a copy, and there is no references to be self. The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way that all entirely black cats are only rainbow colored and not black at all. > > H^ has its own copy of the algorithm of H in it, it doesn't 'reference' > H, so this is NOT a self-reference. > > The input to H^ doesn't 'reference' H^, it is built on the description of H^ > > With no references, you can't have self-reference. > > The only self-references in your 'proof' are the one YOU create by not > making the 'required' copies. This also makes it so things are likely > not actually the Equivalents of the required Turing Machines. Another > flaw in your proof. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-16 23:18 -0400 |
| Message-ID | <ngloI.149087$gq3.16218@fx04.iad> |
| In reply to | #33750 |
On 5/16/21 10:01 PM, olcott wrote: > On 5/16/2021 8:11 PM, Richard Damon wrote: >> On 5/16/21 7:21 PM, olcott wrote: >>> On 5/16/2021 6:05 PM, Richard Damon wrote: >> >>>> >>>> But you can't use a 'Falsism' to change the facts about the definition. >>>> >>>> And, as I have said, there IS no pathological self-reference in the >>>> problem. >>>> >>>> YOU create the self-reference by not implementing the required copy >>>> operation. In actuality the Linz proof has no real self-reference, just >>>> two copies of what just happens to be the same thing. >>>> >>> >>> I am referring to the complete Peter Linz version where a copy <is> >>> made. >>> >>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >>> >>> The above is adapted from (Linz:1990:319). >>> It shows that Turing machine Ĥ copies its input at (q0) and begins >>> executing an embedded copy of the original halt decider with this input >>> at (qx). >>> >>> The (qy) state indicates that the halt decider decides that its input >>> would halt. The ((qn)) state indicates the input would not halt. The >>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >>> decider decides that its input would halt. >>> >>> It can be understood from the above specification that when the embedded >>> halt decider @Ĥ.qx bases its halting decision on simulating its input, >>> and it has (Ĥ, Ĥ) as its input that: >>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>> this copy then >>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>> this copy then >>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>> this copy... >>> unless and until the halt decider @Ĥ.qx stops simulating its input. >>> >>> Linz, Peter 1990. An Introduction to Formal Languages and Automata. >>> Lexington/Toronto: D. C. Heath and Company. >>> >>> >>> >> Key point to notice is that Linz's description doesn't have ANY >> self-reference, or even things done via a 'reference' >> >> EVERYTHING is done with a copy, and there is no references to be self. > > The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way > that all entirely black cats are only rainbow colored and not black at all. Please show where in a proper encoding of H^(H^) you ever have something generate an actual reference to something. PLEASE. H^ has a COPY OF (not a reference to) H within it. It is given a DESCRIPTION OF (not a reference to) H^ No reference in sight! YOU fail to copy Halts, and make H_Hat use a reference to it, but that is actually in violation to the structure described in Linz. Turing Machines do not DO 'references'.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-16 22:23 -0500 |
| Message-ID | <lO2dncjmT5ftfDz9nZ2dnUU7-IWdnZ2d@giganews.com> |
| In reply to | #33753 |
On 5/16/2021 10:18 PM, Richard Damon wrote: > On 5/16/21 10:01 PM, olcott wrote: >> On 5/16/2021 8:11 PM, Richard Damon wrote: >>> On 5/16/21 7:21 PM, olcott wrote: >>>> On 5/16/2021 6:05 PM, Richard Damon wrote: >>> >>>>> >>>>> But you can't use a 'Falsism' to change the facts about the definition. >>>>> >>>>> And, as I have said, there IS no pathological self-reference in the >>>>> problem. >>>>> >>>>> YOU create the self-reference by not implementing the required copy >>>>> operation. In actuality the Linz proof has no real self-reference, just >>>>> two copies of what just happens to be the same thing. >>>>> >>>> >>>> I am referring to the complete Peter Linz version where a copy <is> >>>> made. >>>> >>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >>>> >>>> The above is adapted from (Linz:1990:319). >>>> It shows that Turing machine Ĥ copies its input at (q0) and begins >>>> executing an embedded copy of the original halt decider with this input >>>> at (qx). >>>> >>>> The (qy) state indicates that the halt decider decides that its input >>>> would halt. The ((qn)) state indicates the input would not halt. The >>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >>>> decider decides that its input would halt. >>>> >>>> It can be understood from the above specification that when the embedded >>>> halt decider @Ĥ.qx bases its halting decision on simulating its input, >>>> and it has (Ĥ, Ĥ) as its input that: >>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>> this copy then >>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>> this copy then >>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>> this copy... >>>> unless and until the halt decider @Ĥ.qx stops simulating its input. >>>> >>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata. >>>> Lexington/Toronto: D. C. Heath and Company. >>>> >>>> >>>> >>> Key point to notice is that Linz's description doesn't have ANY >>> self-reference, or even things done via a 'reference' >>> >>> EVERYTHING is done with a copy, and there is no references to be self. >> >> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way >> that all entirely black cats are only rainbow colored and not black at all. > > Please show where in a proper encoding of H^(H^) you ever have something > generate an actual reference to something. PLEASE. > http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf > H^ has a COPY OF (not a reference to) H within it. > > It is given a DESCRIPTION OF (not a reference to) H^ > > No reference in sight! > I have provided the full reference at least 50 times now. > YOU fail to copy Halts, and make H_Hat use a reference to it, but that > is actually in violation to the structure described in Linz. > > Turing Machines do not DO 'references'. > I changed the subject from the x86utm H_Hat C/x86 computation to the actual Linz: Ĥ(Ĥ) a few messages ago and you didn't notice. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-17 07:11 -0400 |
| Message-ID | <BbsoI.227125$N_4.174401@fx36.iad> |
| In reply to | #33754 |
On 5/16/21 11:23 PM, olcott wrote: > On 5/16/2021 10:18 PM, Richard Damon wrote: >> On 5/16/21 10:01 PM, olcott wrote: >>> On 5/16/2021 8:11 PM, Richard Damon wrote: >>>> On 5/16/21 7:21 PM, olcott wrote: >>>>> On 5/16/2021 6:05 PM, Richard Damon wrote: >>>> >>>>>> >>>>>> But you can't use a 'Falsism' to change the facts about the >>>>>> definition. >>>>>> >>>>>> And, as I have said, there IS no pathological self-reference in the >>>>>> problem. >>>>>> >>>>>> YOU create the self-reference by not implementing the required copy >>>>>> operation. In actuality the Linz proof has no real self-reference, >>>>>> just >>>>>> two copies of what just happens to be the same thing. >>>>>> >>>>> >>>>> I am referring to the complete Peter Linz version where a copy <is> >>>>> made. >>>>> >>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >>>>> >>>>> The above is adapted from (Linz:1990:319). >>>>> It shows that Turing machine Ĥ copies its input at (q0) and begins >>>>> executing an embedded copy of the original halt decider with this >>>>> input >>>>> at (qx). >>>>> >>>>> The (qy) state indicates that the halt decider decides that its input >>>>> would halt. The ((qn)) state indicates the input would not halt. The >>>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >>>>> decider decides that its input would halt. >>>>> >>>>> It can be understood from the above specification that when the >>>>> embedded >>>>> halt decider @Ĥ.qx bases its halting decision on simulating its input, >>>>> and it has (Ĥ, Ĥ) as its input that: >>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>>> this copy then >>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>>> this copy then >>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>>> this copy... >>>>> unless and until the halt decider @Ĥ.qx stops simulating its input. >>>>> >>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata. >>>>> Lexington/Toronto: D. C. Heath and Company. >>>>> >>>>> >>>>> >>>> Key point to notice is that Linz's description doesn't have ANY >>>> self-reference, or even things done via a 'reference' >>>> >>>> EVERYTHING is done with a copy, and there is no references to be self. >>> >>> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way >>> that all entirely black cats are only rainbow colored and not black >>> at all. >> >> Please show where in a proper encoding of H^(H^) you ever have something >> generate an actual reference to something. PLEASE. >> > > http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf > >> H^ has a COPY OF (not a reference to) H within it. >> >> It is given a DESCRIPTION OF (not a reference to) H^ >> >> No reference in sight! >> > > I have provided the full reference at least 50 times now. > >> YOU fail to copy Halts, and make H_Hat use a reference to it, but that >> is actually in violation to the structure described in Linz. >> >> Turing Machines do not DO 'references'. >> > > I changed the subject from the x86utm H_Hat C/x86 computation to the > actual Linz: Ĥ(Ĥ) a few messages ago and you didn't notice. > >
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-17 07:26 -0400 |
| Message-ID | <GpsoI.240833$PE7.20906@fx39.iad> |
| In reply to | #33754 |
On 5/16/21 11:23 PM, olcott wrote: > On 5/16/2021 10:18 PM, Richard Damon wrote: >> On 5/16/21 10:01 PM, olcott wrote: >>> On 5/16/2021 8:11 PM, Richard Damon wrote: >>>> On 5/16/21 7:21 PM, olcott wrote: >>>>> On 5/16/2021 6:05 PM, Richard Damon wrote: >>>> >>>>>> >>>>>> But you can't use a 'Falsism' to change the facts about the >>>>>> definition. >>>>>> >>>>>> And, as I have said, there IS no pathological self-reference in the >>>>>> problem. >>>>>> >>>>>> YOU create the self-reference by not implementing the required copy >>>>>> operation. In actuality the Linz proof has no real self-reference, >>>>>> just >>>>>> two copies of what just happens to be the same thing. >>>>>> >>>>> >>>>> I am referring to the complete Peter Linz version where a copy <is> >>>>> made. >>>>> >>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ >>>>> Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn >>>>> >>>>> The above is adapted from (Linz:1990:319). >>>>> It shows that Turing machine Ĥ copies its input at (q0) and begins >>>>> executing an embedded copy of the original halt decider with this >>>>> input >>>>> at (qx). >>>>> >>>>> The (qy) state indicates that the halt decider decides that its input >>>>> would halt. The ((qn)) state indicates the input would not halt. The >>>>> appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt >>>>> decider decides that its input would halt. >>>>> >>>>> It can be understood from the above specification that when the >>>>> embedded >>>>> halt decider @Ĥ.qx bases its halting decision on simulating its input, >>>>> and it has (Ĥ, Ĥ) as its input that: >>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>>> this copy then >>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>>> this copy then >>>>> Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with >>>>> this copy... >>>>> unless and until the halt decider @Ĥ.qx stops simulating its input. >>>>> >>>>> Linz, Peter 1990. An Introduction to Formal Languages and Automata. >>>>> Lexington/Toronto: D. C. Heath and Company. >>>>> >>>>> >>>>> >>>> Key point to notice is that Linz's description doesn't have ANY >>>> self-reference, or even things done via a 'reference' >>>> >>>> EVERYTHING is done with a copy, and there is no references to be self. >>> >>> The computation Ĥ(<Ĥ>) has no self-reference in the exactly same way >>> that all entirely black cats are only rainbow colored and not black >>> at all. >> >> Please show where in a proper encoding of H^(H^) you ever have something >> generate an actual reference to something. PLEASE. >> > > http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf > >> H^ has a COPY OF (not a reference to) H within it. >> >> It is given a DESCRIPTION OF (not a reference to) H^ >> >> No reference in sight! >> > > I have provided the full reference at least 50 times now. YOU have posted REFERENCES to articles, yes. You haven't provided ANY indication of where the problem you are describing actually includes anything IN THE PROBLEM that is actually a reference to something else in th problem. If nothing refers by reference, there can't be self-reference. H^ includes the code for H not by reference, but by making a copy. When H is deciding on H^, it doesn't see 'it self' in the machine, but machine that just happens to match what it does. The input to H^ isn't a reference to itself, but a pattern that just happens to match a description of itself. At no point can anything in the problem just look at what it is given and say, oh, that's ME! YOU change the definition of the problem to convert these copies into actual references, and in doing so you actually break the Turing Equivalence, because at the fundamental level, Turing Machines don't do references. I will again challenge you, WHERE in the original problem is there actually a reference that becomes a self-reference? > >> YOU fail to copy Halts, and make H_Hat use a reference to it, but that >> is actually in violation to the structure described in Linz. >> >> Turing Machines do not DO 'references'. >> > > I changed the subject from the x86utm H_Hat C/x86 computation to the > actual Linz: Ĥ(Ĥ) a few messages ago and you didn't notice. > > Non-responsive. Just proves that you didn't actually read things but just throw out random words when you feel cornered. Yes, a machine that claims to be a decider and just starts by blindly simulating will get into an infinite loop of recusing down the simulation tree. These means that said claimed decider will not be able to answer in finite time. This makes that claimed decider wrong, not the problem. If said claimed decider is improved to see the problem and stop it, now said decider may be able to answer in time, but, at least with your method, it can get the wrong answer because it doesn't get to see what the machine it is deciding on will do with that answer. Again, that is the problem with the design of that claimed decider, not the problem. ALL you have shown is that the method you claim is the obvious way to try to solve the problem doesn't work, not that some how the problem is defective. There is actually no basis to claim that there actually NEEDS to be a way to solve the problem, the answer that you can't build a Halt Decider that get all problems correctly is a perfectly good answer.
[toc] | [prev] | [next] | [standalone]
| From | Malcolm McLean <malcolm.arthur.mclean@gmail.com> |
|---|---|
| Date | 2021-05-17 05:45 -0700 |
| Message-ID | <15406379-420c-4c32-b713-be57e31901ban@googlegroups.com> |
| In reply to | #33770 |
On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: > > If said claimed decider is improved to see the problem and stop it, now > said decider may be able to answer in time, but, at least with your > method, it can get the wrong answer because it doesn't get to see what > the machine it is deciding on will do with that answer. > > Again, that is the problem with the design of that claimed decider, not > the problem. > It's an inherent problem with all deciders. You can simulate until it "looks stuck" and you might have a very good decider. But there will be some inputs which "look stuck" but aren't, and you will decide wrongly, and you can't design that out, because whatever your criteria an attacker can always look stuck, add one one step, then halt.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-17 10:23 -0500 |
| Message-ID | <Va-dnaC0HKatFz_9nZ2dnUU7-bfNnZ2d@giganews.com> |
| In reply to | #33775 |
On 5/17/2021 7:45 AM, Malcolm McLean wrote: > On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >> >> If said claimed decider is improved to see the problem and stop it, now >> said decider may be able to answer in time, but, at least with your >> method, it can get the wrong answer because it doesn't get to see what >> the machine it is deciding on will do with that answer. >> >> Again, that is the problem with the design of that claimed decider, not >> the problem. >> > It's an inherent problem with all deciders. You can simulate until it > "looks stuck" and you might have a very good decider. But there will > be some inputs which "look stuck" but aren't, and you will decide > wrongly, and you can't design that out, because whatever your criteria > an attacker can always look stuck, add one one step, then halt. > When a sufficient non-halting behavior pattern of [infinite_loop] or [infinitely_nested_simulation] has been matched then it has been proven on the basis that counter-examples do not exist that these patterns do match behavior that will never stop unless its simulation is aborted. The [infinitely_nested_simulation] behavior pattern must be adapted to the Linz proof Ĥ(<Ĥ>). That the behavior Ĥ(<Ĥ>) would meet a [infinitely_nested_simulation] behavior pattern can be seen on the basis of the execution trace of Ĥ(<Ĥ>) shown below: Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn The above is adapted from (Linz:1990:319). It shows that Turing machine Ĥ copies its input at (q0) and begins executing an embedded copy of the original halt decider with this input at (qx). The (qy) state indicates that the halt decider decides that its input would halt. The ((qn)) state indicates the input would not halt. The appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt decider decides that its input would halt. Linz, Peter 1990. An Introduction to Formal Languages and Automata. Lexington/Toronto: D. C. Heath and Company. The above definition specifies this execution trace: It can be understood from the above specification that when the embedded halt decider @Ĥ.qx bases its halting decision on simulating its input, and it has (<Ĥ>,<Ĥ>) as its input that: Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with this copy then Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with this copy then Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with this copy... unless and until the halt decider @Ĥ.qx stops simulating its input. As long as any halt decider must ever stop simulating its input the input does specify non-halting. The first halt decider that see this reports it. The convoluted way of saying Ĥ(<Ĥ>): Now Ĥ is a Turing machine, so that it will have some description in Σ*, say ŵ. This string, in addition to being the description of Ĥ can also be used as input string. We can therefore legitimately ask what would happen if Ĥ is applied to ŵ. Because Ĥ(<Ĥ>) must abort the simulation of its input ∴ this input <is> correctly decided as non-halting. Because H(<Ĥ>,<Ĥ>) must abort the simulation of its input ∴ this input <is> correctly decided as non-halting. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-17 20:41 -0400 |
| Message-ID | <k3EoI.129389$D16.17075@fx40.iad> |
| In reply to | #33782 |
On 5/17/21 11:23 AM, olcott wrote: > On 5/17/2021 7:45 AM, Malcolm McLean wrote: >> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >>> >>> If said claimed decider is improved to see the problem and stop it, now >>> said decider may be able to answer in time, but, at least with your >>> method, it can get the wrong answer because it doesn't get to see what >>> the machine it is deciding on will do with that answer. >>> >>> Again, that is the problem with the design of that claimed decider, not >>> the problem. >>> >> It's an inherent problem with all deciders. You can simulate until it >> "looks stuck" and you might have a very good decider. But there will >> be some inputs which "look stuck" but aren't, and you will decide >> wrongly, and you can't design that out, because whatever your criteria >> an attacker can always look stuck, add one one step, then halt. >> > > When a sufficient non-halting behavior pattern of [infinite_loop] or > [infinitely_nested_simulation] has been matched then it has been proven > on the basis that counter-examples do not exist that these patterns do > match behavior that will never stop unless its simulation is aborted. Yes, you MAY be able to recognize a behavior and can prove that it is non-halting. Your 'infinite recursion template', at least the way you process it, isn't right, as it DOES match the finite machine H_Hat(H_Hat). > > The [infinitely_nested_simulation] behavior pattern must be adapted to > the Linz proof Ĥ(<Ĥ>). And that is going to be a problem for you. Since Turing Machines DON'T have this handy 'address' and the Turing Machine you are simulating will have its own copy of the decider, and the machine it will ask its decider will have its own. There is no simple test to use in the Turing Machine to detect this. > > That the behavior Ĥ(<Ĥ>) would meet a [infinitely_nested_simulation] > behavior pattern can be seen on the basis of the execution trace of > Ĥ(<Ĥ>) shown below: > > Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qy ∞ > Ĥ.q0 wM ⊢* Ĥ.qx wM wM ⊢* Ĥ.qn > > The above is adapted from (Linz:1990:319). > It shows that Turing machine Ĥ copies its input at (q0) and begins > executing an embedded copy of the original halt decider with this input > at (qx). > > The (qy) state indicates that the halt decider decides that its input > would halt. The ((qn)) state indicates the input would not halt. The > appended (qa) and (qb) states cause Ĥ to infinitely loop if the halt > decider decides that its input would halt. > > Linz, Peter 1990. An Introduction to Formal Languages and Automata. > Lexington/Toronto: D. C. Heath and Company. > > The above definition specifies this execution trace: > It can be understood from the above specification that when the embedded > halt decider @Ĥ.qx bases its halting decision on simulating its input, > and it has (<Ĥ>,<Ĥ>) as its input that: > Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with > this copy then > Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with > this copy then > Ĥ.q0 would copy its input and then Ĥ.qx would simulate its input with > this copy... > unless and until the halt decider @Ĥ.qx stops simulating its input. > > As long as any halt decider must ever stop simulating its input the > input does specify non-halting. The first halt decider that see this > reports it. Right, so if the algorithm of the Halt Decider doesn't have anything to break this pattern, the Computation will be infinite. But then so will the asking of it directly to decide H(H^,H^), so H^ doesn't need to worry about refuting that case. If H DOES have in its algorithn the capability to detect this loop and terminate it, then H^ has that in its copy of H, and so H^ will not run infinitely, get its answer from its copy of H and do the opposite, thus making H wrong. > > The convoluted way of saying Ĥ(<Ĥ>): > Now Ĥ is a Turing machine, so that it will have some description in Σ*, > say ŵ. This string, in addition to being the description of Ĥ can also > be used > as input string. We can therefore legitimately ask what would happen if > Ĥ is > applied to ŵ. > > Because Ĥ(<Ĥ>) must abort the simulation of its input ∴ this input <is> > correctly decided as non-halting. > > Because H(<Ĥ>,<Ĥ>) must abort the simulation of its input ∴ this input > <is> correctly decided as non-halting. > Except that we see that H^(H^) will Halt, and thus it was wrong. The creator of H had several choices: They could let H just run in the loop and not return an answer, then H starts failing to decide, so it is clearly not universally right. They could detect the loop and call it non-halting (like you do) but then H^ will halt when given the answer so it was wrong. They could detect the loop and decider to be sneeky and say halting, at which point H^ see that and loops forever so it is still wrong. They could even try to do something more to try to figure out what the input would do, but whatever it returns, will be wrong. Ultimately, H WILL be wrong about H^, not because the definition of the problem is wrong, but because, just like in Tic-Tac-Toe, always winning this game is impossible. H doesn't get to redefine the 'winning condition', that isn't allowed, it just has to settle for doing the best it can, and that is being just a partial halt decider, and one machine it will NEVER be able to get right is the H^ that was built on it.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-17 20:27 +0100 |
| Message-ID | <87sg2l2ma2.fsf@bsb.me.uk> |
| In reply to | #33775 |
Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >> >> If said claimed decider is improved to see the problem and stop it, now >> said decider may be able to answer in time, but, at least with your >> method, it can get the wrong answer because it doesn't get to see what >> the machine it is deciding on will do with that answer. >> >> Again, that is the problem with the design of that claimed decider, not >> the problem. >> > It's an inherent problem with all deciders. You can simulate until it > "looks stuck" and you might have a very good decider. You seem determined to encourage PO's misconceptions. PO assumes simulation is involved. No one else should. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-17 14:31 -0500 |
| Message-ID | <356dndvIucnMWT_9nZ2dnUU7-bmdnZ2d@giganews.com> |
| In reply to | #33792 |
On 5/17/2021 2:27 PM, Ben Bacarisse wrote: > Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: > >> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >>> >>> If said claimed decider is improved to see the problem and stop it, now >>> said decider may be able to answer in time, but, at least with your >>> method, it can get the wrong answer because it doesn't get to see what >>> the machine it is deciding on will do with that answer. >>> >>> Again, that is the problem with the design of that claimed decider, not >>> the problem. >>> >> It's an inherent problem with all deciders. You can simulate until it >> "looks stuck" and you might have a very good decider. > > You seem determined to encourage PO's misconceptions. PO assumes > simulation is involved. No one else should. > None-the-less you cannot possibly provide any correct rebuttal because none exists. My current proof simply shows exactly how the exact Peter Linz H would correctly decide not halting on the exact Peter Linz Ĥ. This definition of halting circumvents the pathological self-reference error for every simulating halt decider: An input is decided to be halting only if its simulation never needs to be stopped by any simulating halt decider anywhere in its entire invocation chain. On that basis: Ĥ(<Ĥ>) ⊢* Ĥ.qn H(<Ĥ>,<Ĥ>) ⊢* H.qn -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-18 01:38 +0100 |
| Message-ID | <87eee43mgf.fsf@bsb.me.uk> |
| In reply to | #33793 |
olcott <NoOne@NoWhere.com> writes: > On 5/17/2021 2:27 PM, Ben Bacarisse wrote: >> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >> >>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >>>> >>>> If said claimed decider is improved to see the problem and stop it, now >>>> said decider may be able to answer in time, but, at least with your >>>> method, it can get the wrong answer because it doesn't get to see what >>>> the machine it is deciding on will do with that answer. >>>> >>>> Again, that is the problem with the design of that claimed decider, not >>>> the problem. >>>> >>> It's an inherent problem with all deciders. You can simulate until it >>> "looks stuck" and you might have a very good decider. >> >> You seem determined to encourage PO's misconceptions. PO assumes >> simulation is involved. No one else should. > > None-the-less you cannot possibly provide any correct rebuttal because > none exists. There's nothing to rebut as far as I can see. You've defined a "new kind if halting" which no one cares about. What you need is someone to tell you to stop lying about it being halting. Is there no friend you can turn to who will help you stay honest? > My current proof simply shows exactly how the exact Peter Linz H would > correctly decide not halting on the exact Peter Linz Ĥ. Don't be silly. The rebuttal is in Linz. > This definition of halting circumvents the pathological self-reference > error for every simulating halt decider: The definition is halting is already settled. You need a new name for whatever property you think we should care about. Whatever you think your mysterious and hidden Halts function decides, it is not halting. > An input is decided to be halting only if its simulation never needs > to be stopped by any simulating halt decider anywhere in its entire > invocation chain. However, an input /should/ be decided to be halting only if the sequence of machine configurations it generates is finite. No one cares about whatever it is you've decided to misname halting. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-17 19:54 -0500 |
| Message-ID | <IO6dnYnAp8SQjT79nZ2dnUU7-IPNnZ2d@giganews.com> |
| In reply to | #33815 |
On 5/17/2021 7:38 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 5/17/2021 2:27 PM, Ben Bacarisse wrote: >>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >>> >>>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >>>>> >>>>> If said claimed decider is improved to see the problem and stop it, now >>>>> said decider may be able to answer in time, but, at least with your >>>>> method, it can get the wrong answer because it doesn't get to see what >>>>> the machine it is deciding on will do with that answer. >>>>> >>>>> Again, that is the problem with the design of that claimed decider, not >>>>> the problem. >>>>> >>>> It's an inherent problem with all deciders. You can simulate until it >>>> "looks stuck" and you might have a very good decider. >>> >>> You seem determined to encourage PO's misconceptions. PO assumes >>> simulation is involved. No one else should. >> >> None-the-less you cannot possibly provide any correct rebuttal because >> none exists. > > There's nothing to rebut as far as I can see. You've defined a "new > kind if halting" which no one cares about. What you need is someone to > tell you to stop lying about it being halting. Is there no friend you > can turn to who will help you stay honest? > >> My current proof simply shows exactly how the exact Peter Linz H would >> correctly decide not halting on the exact Peter Linz Ĥ. > > Don't be silly. The rebuttal is in Linz. > On 5/11/2021 11:10 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> Truism: >> Every simulation that would never stop unless Halts() stops >> it at some point specifies infinite execution. > > Any algorithm that implements this truism is, of course, a halting > decider. Ĥ(<Ĥ>) Input <Ĥ> only halts because its simulator stopped simulating it precisely meeting the criteria of a non-halting computation therefore Ĥ correctly decides that its input <Ĥ> is a non-halting computation. >> This definition of halting circumvents the pathological self-reference >> error for every simulating halt decider: > > The definition is halting is already settled. You need a new name for > whatever property you think we should care about. Whatever you think > your mysterious and hidden Halts function decides, it is not halting. > >> An input is decided to be halting only if its simulation never needs >> to be stopped by any simulating halt decider anywhere in its entire >> invocation chain. > > However, an input /should/ be decided to be halting only if the sequence > of machine configurations it generates is finite. No one cares about > whatever it is you've decided to misname halting. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-17 21:21 -0400 |
| Message-ID | <BEEoI.340488$ST2.334418@fx47.iad> |
| In reply to | #33819 |
On 5/17/21 8:54 PM, olcott wrote: > On 5/17/2021 7:38 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 5/17/2021 2:27 PM, Ben Bacarisse wrote: >>>> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >>>> >>>>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >>>>>> >>>>>> If said claimed decider is improved to see the problem and stop >>>>>> it, now >>>>>> said decider may be able to answer in time, but, at least with your >>>>>> method, it can get the wrong answer because it doesn't get to see >>>>>> what >>>>>> the machine it is deciding on will do with that answer. >>>>>> >>>>>> Again, that is the problem with the design of that claimed >>>>>> decider, not >>>>>> the problem. >>>>>> >>>>> It's an inherent problem with all deciders. You can simulate until it >>>>> "looks stuck" and you might have a very good decider. >>>> >>>> You seem determined to encourage PO's misconceptions. PO assumes >>>> simulation is involved. No one else should. >>> >>> None-the-less you cannot possibly provide any correct rebuttal because >>> none exists. >> >> There's nothing to rebut as far as I can see. You've defined a "new >> kind if halting" which no one cares about. What you need is someone to >> tell you to stop lying about it being halting. Is there no friend you >> can turn to who will help you stay honest? >> >>> My current proof simply shows exactly how the exact Peter Linz H would >>> correctly decide not halting on the exact Peter Linz Ĥ. >> >> Don't be silly. The rebuttal is in Linz. >> > > On 5/11/2021 11:10 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> Truism: >>> Every simulation that would never stop unless Halts() stops >>> it at some point specifies infinite execution. >> >> Any algorithm that implements this truism is, of course, a halting >> decider. > > Ĥ(<Ĥ>) Input <Ĥ> only halts because its simulator stopped simulating it > precisely meeting the criteria of a non-halting computation therefore Ĥ > correctly decides that its input <Ĥ> is a non-halting computation. > > WRONG. H^ Halts because its own algorithm made that decision. The Simulator made a mistake, and H^ USES that mistake to allow itself to Halt. There is a simulator that terminates its simulation but it isn't the simulation of the machine we are running, as the test isn't to run a simulation of H^, but to run H^. H^ uses the alrgorithm of H to determine that H will say non-halting when it is run on H(H^,H^) and thus it knows that it wants to be a halting computation. Due to the structure of the 'game' H^ has the upper hand over H and can always defeat it.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-20 12:57 +0100 |
| Message-ID | <87fsyhvcre.fsf@bsb.me.uk> |
| In reply to | #33819 |
olcott <NoOne@NoWhere.com> writes:
> Ĥ(<Ĥ>) Input <Ĥ> only halts because its simulator stopped simulating
> it precisely meeting the criteria of a non-halting computation
> therefore Ĥ correctly decides that its input <Ĥ> is a non-halting
> computation.
Garbage. So many errors it's almost impossible to reply. Let me have a
go.
> Ĥ(<Ĥ>) Input <Ĥ> only halts
Inputs don't halt or not halt. Inputs are strings. TM's halt or don't
halt when presented with input strings.
> because its simulator stopped simulating
> it precisely meeting the criteria of a non-halting computation
It's called the silly-non-halting criterion. You refused to pick a name
so I picked that one. Call the criterion something that it is not is
dishonest.
> therefore Ĥ correctly decides
H^ is not a decider.
> that its input <Ĥ> is a non-halting computation.
<H^> is not even a computation. It's a string, and it's not even a
string representing a computation.
The facts:
(a) UTM^([UTM^]) is not a finite computation. The "hat" construction
means that a pure simulator will not halt on it's "hat" version.
(b) Your partial decider, D, is a UTM that also scans for the
silly-non-halting pattern. It is not a UTM.
(c) D^([D^]) is a finite computation.
(d) D(<[D^], [D^]>) gives the wrong result for the halting problem but,
according to you, the correct result or the silly-non-halting
problem.
You see? If you don't abuse names and language it's easy to keep things
clear and simple.
Notation: M(s) is the computation that results from Turing machine M
applied to string s. [M] is the string encoding of a TM M. <x, y> is
the encoding of a pair of strings. <[M], s> is therefore the string
representing M(s).
M^(s) is M'(<s, s>) where M' is a TM that does not halt on exactly those
inputs on which M halts.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-17 20:43 -0400 |
| Message-ID | <Q4EoI.129390$D16.102450@fx40.iad> |
| In reply to | #33793 |
On 5/17/21 3:31 PM, olcott wrote: > On 5/17/2021 2:27 PM, Ben Bacarisse wrote: >> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes: >> >>> On Monday, 17 May 2021 at 12:26:33 UTC+1, Richard Damon wrote: >>>> >>>> If said claimed decider is improved to see the problem and stop it, now >>>> said decider may be able to answer in time, but, at least with your >>>> method, it can get the wrong answer because it doesn't get to see what >>>> the machine it is deciding on will do with that answer. >>>> >>>> Again, that is the problem with the design of that claimed decider, not >>>> the problem. >>>> >>> It's an inherent problem with all deciders. You can simulate until it >>> "looks stuck" and you might have a very good decider. >> >> You seem determined to encourage PO's misconceptions. PO assumes >> simulation is involved. No one else should. >> > > None-the-less you cannot possibly provide any correct rebuttal because > none exists. > > My current proof simply shows exactly how the exact Peter Linz H would > correctly decide not halting on the exact Peter Linz Ĥ. Except Linz said what the correct decision was for H^, the opposite of whatever H will say, as H will be wrong. > > This definition of halting circumvents the pathological self-reference > error for every simulating halt decider: > > An input is decided to be halting only if its simulation never needs to > be stopped by any simulating halt decider anywhere in its entire > invocation chain. > > On that basis: > Ĥ(<Ĥ>) ⊢* Ĥ.qn > H(<Ĥ>,<Ĥ>) ⊢* H.qn > > But it isn't the right definition of Halting!
[toc] | [prev] | [next] | [standalone]
Page 1 of 2 [1] 2 Next page →
Back to top | Article view | comp.theory
csiph-web