Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #171063 > unrolled thread
| Started by | George Greene <greeneg@email.unc.edu> |
|---|---|
| First post | 2018-01-25 20:26 -0800 |
| Last post | 2018-02-03 17:00 -0800 |
| Articles | 20 on this page of 118 — 9 participants |
Back to article view | Back to sci.logic
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 George Greene <greeneg@email.unc.edu> - 2018-01-25 20:26 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-25 21:49 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-26 04:10 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-26 11:37 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-26 15:12 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-26 05:34 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-26 20:33 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-27 05:05 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-27 06:57 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-27 13:53 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 20:24 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-27 13:03 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 21:58 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-29 19:02 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-29 20:11 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 08:49 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 09:43 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:07 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 17:41 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 18:40 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 19:17 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:20 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-30 21:21 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-29 21:21 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 08:58 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 03:16 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:14 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 22:37 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:53 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-31 19:38 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:42 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 18:08 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 21:57 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 16:21 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 01:44 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:11 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 01:54 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:15 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 19:36 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 21:13 +0000
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 21:30 +0000
Re: Infinitely Recursive input on HP Proofs Andy Walker <anw@cuboid.co.uk> - 2018-02-03 18:17 +0000
Re: Infinitely Recursive input on HP Proofs Andy Walker <anw@cuboid.co.uk> - 2018-02-03 18:42 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 12:46 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-03 20:53 -0600
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 19:51 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 18:56 -0600
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 17:22 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 20:45 -0600
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 21:45 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-06 15:34 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 08:02 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:51 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 10:23 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:52 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 17:19 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-06 17:59 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 19:02 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-07 20:57 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 22:39 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-06 23:14 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:45 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-06 22:28 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:31 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-06 17:54 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 02:13 +0000
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:49 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-06 22:48 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 16:27 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-07 23:22 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-08 21:05 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-08 18:44 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-09 11:08 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-11 08:44 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-11 08:47 -0800
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-11 17:55 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-12 20:39 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:41 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:43 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 18:56 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-07 20:50 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-06 20:13 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-05 17:45 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-04 17:01 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 16:44 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-05 17:42 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-05 18:09 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 21:50 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 19:57 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-01 11:02 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 19:10 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 01:51 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:24 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 17:34 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 02:04 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:31 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 19:43 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 21:38 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-02 17:54 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-02 16:08 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 00:51 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-03 00:38 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-02 23:05 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 13:37 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-03 14:27 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 23:49 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 16:03 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 00:44 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 17:11 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 01:27 +0000
Re: Infinitely Recursive input on HP Proofs Newberry <newberryxy@gmail.com> - 2018-02-03 18:01 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 20:44 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-04 02:32 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-03 16:47 -0800
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 14:12 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 19:27 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 02:13 +0000
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-03 17:00 -0800
Page 2 of 6 — ← Prev page 1 [2] 3 4 5 6 Next page →
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-01-30 19:17 -0800 |
| Message-ID | <f0f5e8ac-3f18-4d60-9b8c-008ab21c8b14@googlegroups.com> |
| In reply to | #171411 |
On Wednesday, January 31, 2018 at 12:40:06 PM UTC+10, peteolcott wrote: > On Tuesday, January 30, 2018 at 7:41:04 PM UTC-6, graham...@gmail.com wrote: > > On Wednesday, January 31, 2018 at 11:07:27 AM UTC+10, peteolcott wrote: > > > On Tuesday, January 30, 2018 at 11:43:38 AM UTC-6, graham...@gmail.com wrote: > > > > On Wednesday, January 31, 2018 at 2:49:08 AM UTC+10, peteolcott wrote: > > > > > On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote: > > > > > > On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote: > > > > > > > If we create a machine specification that counts the characters > > > > > > > of strings and a string of infinite length is provided as input > > > > > > > we cannot expect this machine to halt on every input. > > > > > > > > > > > > Of course, but that truly does NOT MATTER under the paradigm we > > > > > > are discussing. We are talking about treating TMs as functions > > > > > > with finite input (programs have to be finite). ONLY the behavior of the > > > > > > machine ON finite inputs is being considered. > > > > > > > > > > > > > > > > > > > > The same thing is occurring with the HP proof counter-example. > > > > > > > > > > > > NO, IT ISN'T, DUMBASS. > > > > > > H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string! > > > > > > > > > > Yes they are both finite strings. When I said the same thing > > > > > I meant analogous. > > > > > > > > > > If the definition of the requirements of the problem specify infinite > > > > > recursion then this is analogous to specifying input of infinite > > > > > length. > > > > > > > > > > Even though the strings are finite an infinitely recursive evaluation > > > > > sequence is specified in the same way that an infinitely recursive > > > > > evaluation sequence is specified in the Liar Paradox and the same way > > > > > that this Prolog specifies an infinitely recursive evaluation sequence: > > > > > > > > > > http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference.pdf > > > > > > > > > > match a term against an uninstantiated subterm of itself: > > > > > > > > > > equal(X, X). > > > > > ?- equal(foo(Y), Y). > > > > > > > > > > > > > > > > THEREFORE H' has a finite code-string (its code-string is just > > > > > > H's code-string plus some extra code for reversing the outcome), and therefore > > > > > > H^ has a finite code-string (it's just the code-string of H' with some code > > > > > > for doubling the input prepended). > > > > > > > > > > > > > > > > Halting for H^ w^ w^2 can only be decided in terms of > > > > > halting for w^ w^2 w^3 ... > > > > > > > > > > Everyone in the world missed this including myself until 2016. > > > > > I have been working on this since 2004. > > > > > > > > > > > > H^ is not actually provided a single TM / input pair, > > > > > > > > > > > > YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED > > > > > > h^, since it is the code-string of H^. > > > > > > > > > > > > > > > > Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does... > > > > > alternatively > > > > > > > > > > H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. > > > > > This causes w^ to transition to (qy) which causes H^ to correctly decide > > > > > halting by transitioning to ((qn)). > > > > > > > > > > So you either have infinite recursion, as an intrinsic part of the problem > > > > > definition or H^ correctly decides halting for w^ w^2. > > > > > > > > > > Copyright 2016, 2017, 2018 Pete Olcott > > > > > > > > > > > > > > > > > > > > if HALT has no infinite recursion, neither does H^ > > > > > > > > > > > > > > > > [HALT]----->[YES] > > > > | > > > > | > > > > | > > > > v > > > > [NO] > > > > > > > > > > > > > > > > > > > > [DOUBLE THE TAPE] > > > > | > > > > | > > > > | > > > > v > > > > [HALT]----->[YES]<---->[TOGGLE] > > > > | > > > > | > > > > | > > > > v > > > > [NO] > > > > > > > > > > > > > > You are not going to be able to understand this as a computer > > > science problem. The only way that this can be understood is > > > as a David Hilbert finite strings math problem. > > > > > > Only a David Hilbert math problem knows the required mathematical > > > evaluation sequence of the finite strings after state qx. > > > > > > > > INPUT = 00001110000 > > > > q0 ~~~~> qx > > > > > > TAPE = 000011101110000 > > > > > > qx ~~~~~> qYES > > | > > \ > > / > > \ > > | > > v > > > > qNO > > > > > > > > > > > > ASSUMPTION: HALT [START] -> qYES or qNO TOO! > > ∃x ∈ Turing_Machines_Descriptions > ∀y ∈ Turing_Machine_Descriptions > ∀z ∈ Finite_Strings Halts(x, y, z) > H ≡ Halts(H, H, H) // HOL with self-reference semantics > if HALT is a function, then a function can call HALT if a function can call HALT, then it can loop straight AFTER the YES answer!
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-01-31 00:20 -0600 |
| Message-ID | <5KadnfjtrPaJ_ezHnZ2dnUU7-Q_NnZ2d@giganews.com> |
| In reply to | #171436 |
On 1/30/2018 9:17 PM, grahamcooper7@gmail.com wrote: > On Wednesday, January 31, 2018 at 12:40:06 PM UTC+10, peteolcott wrote: >> On Tuesday, January 30, 2018 at 7:41:04 PM UTC-6, graham...@gmail.com wrote: >>> On Wednesday, January 31, 2018 at 11:07:27 AM UTC+10, peteolcott wrote: >>>> On Tuesday, January 30, 2018 at 11:43:38 AM UTC-6, graham...@gmail.com wrote: >>>>> On Wednesday, January 31, 2018 at 2:49:08 AM UTC+10, peteolcott wrote: >>>>>> On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote: >>>>>>> On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote: >>>>>>>> If we create a machine specification that counts the characters >>>>>>>> of strings and a string of infinite length is provided as input >>>>>>>> we cannot expect this machine to halt on every input. >>>>>>> >>>>>>> Of course, but that truly does NOT MATTER under the paradigm we >>>>>>> are discussing. We are talking about treating TMs as functions >>>>>>> with finite input (programs have to be finite). ONLY the behavior of the >>>>>>> machine ON finite inputs is being considered. >>>>>>> >>>>>>>> >>>>>>>> The same thing is occurring with the HP proof counter-example.. >>>>>>> >>>>>>> NO, IT ISN'T, DUMBASS. >>>>>>> H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string! >>>>>> >>>>>> Yes they are both finite strings. When I said the same thing >>>>>> I meant analogous. >>>>>> >>>>>> If the definition of the requirements of the problem specify infinite >>>>>> recursion then this is analogous to specifying input of infinite >>>>>> length. >>>>>> >>>>>> Even though the strings are finite an infinitely recursive evaluation >>>>>> sequence is specified in the same way that an infinitely recursive >>>>>> evaluation sequence is specified in the Liar Paradox and the same way >>>>>> that this Prolog specifies an infinitely recursive evaluation sequence: >>>>>> >>>>>> http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference..pdf >>>>>> >>>>>> match a term against an uninstantiated subterm of itself: >>>>>> >>>>>> equal(X, X). >>>>>> ?- equal(foo(Y), Y). >>>>>> >>>>>> >>>>>>> THEREFORE H' has a finite code-string (its code-string is just >>>>>>> H's code-string plus some extra code for reversing the outcome), and therefore >>>>>>> H^ has a finite code-string (it's just the code-string of H' with some code >>>>>>> for doubling the input prepended). >>>>>>> >>>>>> >>>>>> Halting for H^ w^ w^2 can only be decided in terms of >>>>>> halting for w^ w^2 w^3 ... >>>>>> >>>>>> Everyone in the world missed this including myself until 2016. >>>>>> I have been working on this since 2004. >>>>>> >>>>>>>> H^ is not actually provided a single TM / input pair, >>>>>>> >>>>>>> YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED >>>>>>> h^, since it is the code-string of H^. >>>>>>> >>>>>> >>>>>> Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does... >>>>>> alternatively >>>>>> >>>>>> H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. >>>>>> This causes w^ to transition to (qy) which causes H^ to correctly decide >>>>>> halting by transitioning to ((qn)). >>>>>> >>>>>> So you either have infinite recursion, as an intrinsic part of the problem >>>>>> definition or H^ correctly decides halting for w^ w^2. >>>>>> >>>>>> Copyright 2016, 2017, 2018 Pete Olcott >>>>> >>>>> >>>>> >>>>> >>>>> if HALT has no infinite recursion, neither does H^ >>>>> >>>>> >>>>> >>>>> [HALT]----->[YES] >>>>> | >>>>> | >>>>> | >>>>> v >>>>> [NO] >>>>> >>>>> >>>>> >>>>> >>>>> [DOUBLE THE TAPE] >>>>> | >>>>> | >>>>> | >>>>> v >>>>> [HALT]----->[YES]<---->[TOGGLE] >>>>> | >>>>> | >>>>> | >>>>> v >>>>> [NO] >>>>> >>>>> >>>> >>>> You are not going to be able to understand this as a computer >>>> science problem. The only way that this can be understood is >>>> as a David Hilbert finite strings math problem. >>>> >>>> Only a David Hilbert math problem knows the required mathematical >>>> evaluation sequence of the finite strings after state qx. >>> >>> >>> >>> INPUT = 00001110000 >>> >>> q0 ~~~~> qx >>> >>> >>> TAPE = 000011101110000 >>> >>> >>> qx ~~~~~> qYES >>> | >>> \ >>> / >>> \ >>> | >>> v >>> >>> qNO >>> >>> >>> >>> >>> >>> ASSUMPTION: HALT [START] -> qYES or qNO TOO! >> >> ∃x ∈ Turing_Machines_Descriptions >> ∀y ∈ Turing_Machine_Descriptions >> ∀z ∈ Finite_Strings Halts(x, y, z) >> H ≡ Halts(H, H, H) // HOL with self-reference semantics >> > > > > if HALT is a function, then a function can call HALT > > > if a function can call HALT, then it can loop straight AFTER the YES answer! > > Halt is not a function it is a predicate, which is essentially Boolean function. The key distinction between this is the typical presentation is the quantifiers. In computer science terms it would be as if every element of the set of all finite strings were actually tested. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-30 21:21 -0800 |
| Message-ID | <75caf1c1-a647-4c39-b58c-c97a75bfbd65@googlegroups.com> |
| In reply to | #171388 |
On Tuesday, January 30, 2018 at 8:07:27 PM UTC-5, peteolcott wrote: > You are not going to be able to understand this as a computer > science problem. The only way that this can be understood is > as a David Hilbert finite strings math problem. The two ARE NOT mutually exclusive, DUMBASS. > Only a David Hilbert math problem knows Oh, SHUT THE FUCK UP. THERE IS NO true continuation of that sentence. IF ANYthing knows something then that same something can be re-phrased in any number of other paradigms. Why do you make all these pontifications about PHILOSOPHY when your degree IS IN COMPUTER SCIENCE??
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-29 21:21 -0800 |
| Message-ID | <b054dc1d-74a7-4cb1-ac9b-921c5752cf9c@googlegroups.com> |
| In reply to | #171291 |
On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote: > H^ can only decide if w^ halts on it input w^2 THIS IS HORSE-SHIT. H^ only has ONE input -- w^ (= h^). What you call w^2 IS NEVER an input to H^. After creating w^2, H^ CALLS H'. > on the basis of w^2 halting on its input w^3... It does whatever it does on the basis of WHAT H' does (or would do) on (w^,w^) as an input string. It's almost wrong of you to call the "second copy" w^2 since it is identical in every way&character-position to w^. It's just w^, AGAIN. H' does NOT further copy EITHER of its w^ inputs: IT EMULATES H. H doesn't copy any of its inputs either. It tries to analyze whether the machine WHOSE CODE-STRING is w^ -- THAT WOULD BE H^ -- does or does not halt when given that code-string itself as input. It does NOT do that BY re-invoking H^ or copying anything again. IT CAN'T re-invoke H^ on w^ because THAT WOULD NOT HALT, and H *HAS* to halt.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-30 08:58 -0800 |
| Message-ID | <21deebbc-7e8e-4673-a5cf-e9ef422c2fc6@googlegroups.com> |
| In reply to | #171320 |
On Monday, January 29, 2018 at 11:21:47 PM UTC-6, George Greene wrote: > On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote: > > H^ can only decide if w^ halts on it input w^2 > > THIS IS HORSE-SHIT. > H^ only has ONE input -- w^ (= h^). What you call w^2 IS NEVER an input to H^. > After creating w^2, H^ CALLS H'. > As anyone with an MSCS would know no TM ever calls another TM. It is always only a matter of moving the read/write head read/writing and element to the tape and transitioning to a next state. After H^ transitions from (q0) to (qx) it processes a pair of finite strings w^ and w^2 on its tape. > > on the basis of w^2 halting on its input w^3... > > It does whatever it does on the basis of WHAT H' does (or would do) > on (w^,w^) as an input string. It's almost wrong of you to call the > "second copy" w^2 since it is identical in every way&character-position > to w^. It's just w^, AGAIN. Calling it a second copy explicitly indicates that its starting tape position is different than the starting tape position of w^. In computer science this would be the notion that w^ is a different memory address than w^2, w^2 is not merely an alias for the same memory address. > > H' does NOT further copy EITHER of its w^ inputs: H" is gone IT EMULATES H. > H doesn't copy any of its inputs either. It tries to analyze whether > the machine WHOSE CODE-STRING is w^ -- THAT WOULD BE H^ -- does or does > not halt when given that code-string itself as input. It does NOT do > that BY re-invoking H^ or copying anything again. IT CAN'T re-invoke > H^ on w^ because THAT WOULD NOT HALT, and H *HAS* to halt. For H^ to see what w^ would do on input w^2, H^ would see that w^ makes a copy of w^2 and then w^ would evaluate what w^2 would do on its input w^3.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-01-31 03:16 +0000 |
| Message-ID | <87lgged8fq.fsf@bsb.me.uk> |
| In reply to | #171291 |
peteolcott <peterolcott2@gmail.com> writes: > On Saturday, January 27, 2018 at 3:58:40 PM UTC-6, Ben Bacarisse wrote: >> I'm going to reply only the main point -- the error in your argument. >> It's too easy for Usenet threads to get side tracked by all the other >> things you say... >> >> peteolcott writes: >> >> > On Saturday, January 27, 2018 at 2:24:45 PM UTC-6, Ben Bacarisse wrote: >> >> peteolcott writes: >> >> <snip> >> >> > No you only need to trace the evaluation sequence of H^ to see that >> >> > it gets stuck in infinite recursion after state (qx). It never even >> >> > reaches state (qy) or ((qn)). >> >> This is wrong by the assumption made at the start of the proof -- that H >> decides halting (the fact that it decides anything is enough). The >> first time round I missed this clearly erroneous statement but I make >> the same point later on: >> >> >> > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >> >> > >> >> > Definition of Turing Machine Ĥ (state transition sequence) >> >> > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ >> >> > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn >> <remove side issue> >> >> > q0 to qx it copies its input ŵ to ŵ2 >> >> > after qx it evaluates its input ŵ ŵ2 >> >> >> >> No. You do not know exactly what H^ does from state qx onward. You >> >> certainly can't say it "evaluates" its input. >> > >> > From a David Hilbert Formalism pure math POV the entire process >> > is the evaluation of finite strings H^ w^. >> >> You are not allowed to change the formalism. H^ is a TM and it's action >> is determined by it's state transition function. To see your error you >> must stick with Turning machines and their actions. >> >> But in *any* formalism you may not assume what H^ does from state qx on. >> Any arguments that does so is flawed. You wanted to know where the >> error is. It is here. >> >> The only valid assumptions about H^'s behaviour are those you can derive >> from the assumption in the argument: that H decides halting. From that >> premise we know that all traces of H^ take the machine from state qx to >> either qy or qn. > > If we create a machine specification that counts the characters > of strings and a string of infinite length is provided as input > we cannot expect this machine to halt on every input. That's wrong in so many ways. No TM is ever provided with a string of infinite length (a good book will tell you this). A TM might construct a string that never ends, but that's not the same thing. > The same thing is occurring with the HP proof counter-example. H^ is > not actually provided a single TM / input pair, it superficially > seems that it is, but, deeper analysis indicates that H^ is actually > provided with an infinitely recursive set of TM / input pairs. No it isn't. I don't expect you to see why you wrong because you are no longer engaging with any arguments -- you are just repeating the error again and again. If you want to know why you are wrong, you need to take the time to find out what I am saying. Really find out -- ask about the why I said X or Y. Probe my statements. Repeating yourself will not help. > It took me at least 3,000 hours 12 years to see this so if you don't > get it right away that is quite understandable. The length of time is immaterial. I've been studies this material for far more than 3000 hours, but that does not make me right. What makes me right is that what I said is correct and what you said is wrong: You are making an incorrect assumption about what H^ does from state qx onwards. If you want to know why that's wrong (and what I wrote before is not enough to help you see it) just ask me some questions. Feel free to re-state your error again a few more times, but it won't alter the fact that your argument is unsound. > H^ can only decide if w^ halts on it input w^2 > on the basis of w^2 halting on its input w^3... No. From state qx on, H^ behaves like H' (which behaves like H until the very last state). The H (or the copy of H -- you decide which view you take) which is embedded in H^ must simply do what it does with any input it is asked to "decide". You can't (and mustn't) say anything about how it does that, but you *can* be sure that state qy or qn is reached in a finite number of steps. That's because, however it does it, it is a decider. > This is far too subtle for anyone in the world to notice until now. Nonsense. It's taken this long for someone misinformed enough to think that this is what H^ does. Everyone else has understood that H^ behaves like H' and H' will always transition into state qy or qn because that is required by the assumption at the start of the proof. The one thing that H^ can not do from state qx on is what you are assuming it does, and that is to "run" (or emulate or evaluate) its input. H^ is built from a decider, and no decider can run (or emulate or evaluate) its input. Such behaviour is ruled out from the start. That's a bit sweeping: a decider can *start* to run its input as a machine, but it can not get into a loop doing that. It has to go on to do something else that will cause it to terminate. You have a notation for this which you wrote out: qx w^ w^ |-H^ qy oo qx w^ w^ |-H^ qn Do you know what that means? If you do, why did you write it? It is correct and it contradicts what you are saying in words. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-01-31 00:14 -0600 |
| Message-ID | <PbSdnTmmwYlVw-zHnZ2dnUU7-LfNnZ2d@giganews.com> |
| In reply to | #171434 |
On 1/30/2018 9:16 PM, Ben Bacarisse wrote: > peteolcott <peterolcott2@gmail.com> writes: > >> On Saturday, January 27, 2018 at 3:58:40 PM UTC-6, Ben Bacarisse wrote: >>> I'm going to reply only the main point -- the error in your argument. >>> It's too easy for Usenet threads to get side tracked by all the other >>> things you say... >>> >>> peteolcott writes: >>> >>>> On Saturday, January 27, 2018 at 2:24:45 PM UTC-6, Ben Bacarisse wrote: >>>>> peteolcott writes: >>>>> <snip> >>>>>> No you only need to trace the evaluation sequence of H^ to see that >>>>>> it gets stuck in infinite recursion after state (qx). It never even >>>>>> reaches state (qy) or ((qn)). >>> >>> This is wrong by the assumption made at the start of the proof -- that H >>> decides halting (the fact that it decides anything is enough). The >>> first time round I missed this clearly erroneous statement but I make >>> the same point later on: >>> >>>>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >>>>>> >>>>>> Definition of Turing Machine Ĥ (state transition sequence) >>>>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ >>>>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn >>> <remove side issue> >>>>>> q0 to qx it copies its input ŵ to ŵ2 >>>>>> after qx it evaluates its input ŵ ŵ2 >>>>> >>>>> No. You do not know exactly what H^ does from state qx onward. You >>>>> certainly can't say it "evaluates" its input. >>>> >>>> From a David Hilbert Formalism pure math POV the entire process >>>> is the evaluation of finite strings H^ w^. >>> >>> You are not allowed to change the formalism. H^ is a TM and it's action >>> is determined by it's state transition function. To see your error you >>> must stick with Turning machines and their actions. >>> >>> But in *any* formalism you may not assume what H^ does from state qx on. >>> Any arguments that does so is flawed. You wanted to know where the >>> error is. It is here. >>> >>> The only valid assumptions about H^'s behaviour are those you can derive >>> from the assumption in the argument: that H decides halting. From that >>> premise we know that all traces of H^ take the machine from state qx to >>> either qy or qn. >> >> If we create a machine specification that counts the characters >> of strings and a string of infinite length is provided as input >> we cannot expect this machine to halt on every input. > > That's wrong in so many ways. No TM is ever provided with a string of > infinite length (a good book will tell you this). A TM might construct > a string that never ends, but that's not the same thing. > It is sufficiently analogous. If a TM is provided with a problem that specifies infinite recursion then a David Hilbert finite string formalization of this problem inherently requires infinite recursion. This is an analogous idea to a TM that counts the characters of a string and would otherwise halt except in the case where this string is (for all practical purpose) infinite. >> The same thing is occurring with the HP proof counter-example. H^ is >> not actually provided a single TM / input pair, it superficially >> seems that it is, but, deeper analysis indicates that H^ is actually >> provided with an infinitely recursive set of TM / input pairs. > > No it isn't. I don't expect you to see why you wrong because you are no > longer engaging with any arguments -- you are just repeating the error > again and again. If you want to know why you are wrong, you need to > take the time to find out what I am saying. Really find out -- ask > about the why I said X or Y. Probe my statements. Repeating yourself > will not help. > I will tell you what try and find out why the Truth teller paradox: "This sentence is true" is not true and then you might actually begin to see what I mean. >> It took me at least 3,000 hours 12 years to see this so if you don't >> get it right away that is quite understandable. > > The length of time is immaterial. I've been studies this material for > far more than 3000 hours, but that does not make me right. What makes > me right is that what I said is correct and what you said is wrong: > > You are making an incorrect assumption about what H^ does from state qx > onwards. If you want to know why that's wrong (and what I wrote before > is not enough to help you see it) just ask me some questions. A David Hilbert finite string evaluation inherently specifies the sequence that I am claiming. The Truth Teller paradox will show you this. > > Feel free to re-state your error again a few more times, but it won't > alter the fact that your argument is unsound. > Lets use a process of elimination to get to the truth. You would of course agree that the sequence that I am specifying is one of the possible sequences, right? ∃x ∈ Turing_Machines_Descriptions ∀y ∈ Turing_Machine_Descriptions ∀z ∈ Finite_Strings Halts(x, y, z) H ≡ Halts(H, H, H) // HOL with self-reference semantics Try and provide a counter-example that does not violate the above specs. >> H^ can only decide if w^ halts on it input w^2 >> on the basis of w^2 halting on its input w^3... > > No. From state qx on, H^ behaves like H' (which behaves like H until > the very last state). The H (or the copy of H -- you decide which view > you take) which is embedded in H^ must simply do what it does with any > input it is asked to "decide". It lacks sufficient information to decide. H^ can only decide what w^ does on its input w^2 based on what w^ decides. The essence of this (like the Truth Teller Paradox) is infinitely recursive. If it is not infinitely recursive (and it is) then w^ would simply decide that w^2 halts on its NULL input. The H^ decides that this will cause w^ to loop so it simply transitions to ((qn)). > You can't (and mustn't) say anything > about how it does that, but you *can* be sure that state qy or qn is > reached in a finite number of steps. That's because, however it does > it, it is a decider. Making that assumption turns out to be exactly analogous to being certain that the Liar Paradox must be True or False. It turns out the the LP is simply incorrect. > >> This is far too subtle for anyone in the world to notice until now. > > Nonsense. It's taken this long for someone misinformed enough to think > that this is what H^ does. Everyone else has understood that H^ behaves > like H' and H' will always transition into state qy or qn because that > is required by the assumption at the start of the proof. > > The one thing that H^ can not do from state qx on is what you are > assuming it does, and that is to "run" (or emulate or evaluate) its It cannot run, it cannot emulate, in math terms evaluate is all that is left. All math expressions are evaluated, that is how math works. > input. H^ is built from a decider, and no decider can run (or emulate > or evaluate) its input. Such behaviour is ruled out from the start. > The title of my final published paper will be: The Halting Problem proof is merely the Liar Paradox in disguise. > That's a bit sweeping: a decider can *start* to run its input as a > machine, but it can not get into a loop doing that. It has to go on to > do something else that will cause it to terminate. > > You have a notation for this which you wrote out: > > qx w^ w^ |-H^ qy oo > qx w^ w^ |-H^ qn > > Do you know what that means? If you do, why did you write it? It is > correct and it contradicts what you are saying in words. > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ You left some key state transitions out: Definition of Turing Machine Ĥ (state transition sequence) q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn // As a David Hilbert mathematical formalism. Ĥ ≡ Halts(Ĥ, Ĥ, Ĥ) // HOL with self-reference semantics Every possible definition of the above Ĥ must necessarily fail because the problem itself inherently specifies infinite recursion in the same way that the Liar Paradox and the Truth Teller Paradox inherently specify infinite recursion: LP ≡ ~True(LP) // HOL with self-reference semantics TT ≡ True(TT) // HOL with self-reference semantics Copyright 2016, 2017, 2018 Pete Olcott -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-01-30 22:37 -0800 |
| Message-ID | <63aec479-1d94-4599-9ffc-9670523e708f@googlegroups.com> |
| In reply to | #171469 |
On Wednesday, January 31, 2018 at 4:14:38 PM UTC+10, Pete Olcott wrote: > On 1/30/2018 9:16 PM, Ben Bacarisse wrote: > > > No. From state qx on, H^ behaves like H' (which behaves like H until > > the very last state). The H (or the copy of H -- you decide which view > > you take) which is embedded in H^ must simply do what it does with any > > input it is asked to "decide". > > It lacks sufficient information to decide. > H^ can only decide what w^ does on its input w^2 based on what w^ decides. > The essence of this (like the Truth Teller Paradox) is infinitely recursive. > > If it is not infinitely recursive (and it is) then w^ would simply decide > that w^2 halts on its NULL input. The H^ decides that this will cause w^ > to loop so it simply transitions to ((qn)). Theres 2 possibilities: qx --> qn H^ finishes in qNO H^ stops CONTRADICTION qx --> qy H^ finished in LOOP after qYES H^ loops CONTRADICTION remember H^ is just running the numbers on itself!
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-01-31 10:53 -0600 |
| Message-ID | <4O6dnQ5W3Pk7aezHnZ2dnUU7-ffNnZ2d@giganews.com> |
| In reply to | #171471 |
On 1/31/2018 12:37 AM, grahamcooper7@gmail.com wrote: > On Wednesday, January 31, 2018 at 4:14:38 PM UTC+10, Pete Olcott wrote: >> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: >> >>> No. From state qx on, H^ behaves like H' (which behaves like H until >>> the very last state). The H (or the copy of H -- you decide which view >>> you take) which is embedded in H^ must simply do what it does with any >>> input it is asked to "decide". >> >> It lacks sufficient information to decide. >> H^ can only decide what w^ does on its input w^2 based on what w^ decides. >> The essence of this (like the Truth Teller Paradox) is infinitely recursive. >> >> If it is not infinitely recursive (and it is) then w^ would simply decide >> that w^2 halts on its NULL input. The H^ decides that this will cause w^ >> to loop so it simply transitions to ((qn)). > > > > Theres 2 possibilities: > > > qx --> qn > H^ finishes in qNO > H^ stops > > CONTRADICTION > > Not at all. H^ w^ w^2 w^2 transitions to ((qn)) on NULL input causing w^ to transition to (qy) infinite loop causing H^ to transition to ((qn)) correctly reporting not halting for w^ w^2 > qx --> qy > H^ finished in LOOP after qYES > H^ loops > > CONTRADICTION > > > > remember H^ is just running the numbers on itself! > -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-01-31 19:38 -0800 |
| Message-ID | <7754c55f-6064-4258-aef9-ba55d4eb47a8@googlegroups.com> |
| In reply to | #171506 |
On Thursday, February 1, 2018 at 2:54:04 AM UTC+10, Pete Olcott wrote: > On 1/31/2018 12:37 AM, grahamcooper7@gmail.com wrote: > > On Wednesday, January 31, 2018 at 4:14:38 PM UTC+10, Pete Olcott wrote: > >> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: > >> > >>> No. From state qx on, H^ behaves like H' (which behaves like H until > >>> the very last state). The H (or the copy of H -- you decide which view > >>> you take) which is embedded in H^ must simply do what it does with any > >>> input it is asked to "decide". > >> > >> It lacks sufficient information to decide. > >> H^ can only decide what w^ does on its input w^2 based on what w^ decides. > >> The essence of this (like the Truth Teller Paradox) is infinitely recursive. > >> > >> If it is not infinitely recursive (and it is) then w^ would simply decide > >> that w^2 halts on its NULL input. The H^ decides that this will cause w^ > >> to loop so it simply transitions to ((qn)). > > > > > > > > Theres 2 possibilities: > > > > > > qx --> qn > > H^ finishes in qNO > > H^ stops > > > > CONTRADICTION > > > > > > Not at all. > H^ w^ w^2 > w^2 transitions to ((qn)) on NULL input > causing w^ to transition to (qy) infinite loop > causing H^ to transition to ((qn)) correctly reporting not halting for w^ w^2 > > w^ is a number H^ (w^) ==> H'( w^ w^ ) ==> [qYES] iff w^(w^) HALTS ==> [qNO] iff w^(w^) NEVER HALTS but the outputs are BACK-TO-FRONT! yes-->loop, no-->terminates
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-01 19:42 -0600 |
| Message-ID | <u72dnSZNK-u_X-7HnZ2dnUU7-f_NnZ2d@giganews.com> |
| In reply to | #171559 |
On 1/31/2018 9:38 PM, grahamcooper7@gmail.com wrote: > On Thursday, February 1, 2018 at 2:54:04 AM UTC+10, Pete Olcott wrote: >> On 1/31/2018 12:37 AM, grahamcooper7@gmail.com wrote: >>> On Wednesday, January 31, 2018 at 4:14:38 PM UTC+10, Pete Olcott wrote: >>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: >>>> >>>>> No. From state qx on, H^ behaves like H' (which behaves like H until >>>>> the very last state). The H (or the copy of H -- you decide which view >>>>> you take) which is embedded in H^ must simply do what it does with any >>>>> input it is asked to "decide". >>>> >>>> It lacks sufficient information to decide. >>>> H^ can only decide what w^ does on its input w^2 based on what w^ decides. >>>> The essence of this (like the Truth Teller Paradox) is infinitely recursive. >>>> >>>> If it is not infinitely recursive (and it is) then w^ would simply decide >>>> that w^2 halts on its NULL input. The H^ decides that this will cause w^ >>>> to loop so it simply transitions to ((qn)). >>> >>> >>> >>> Theres 2 possibilities: >>> >>> >>> qx --> qn >>> H^ finishes in qNO >>> H^ stops >>> >>> CONTRADICTION >>> >>> >> >> Not at all. >> H^ w^ w^2 >> w^2 transitions to ((qn)) on NULL input >> causing w^ to transition to (qy) infinite loop >> causing H^ to transition to ((qn)) correctly reporting not halting for w^ w^2 >> >> > > > w^ is a number > > > H^ (w^) > > ==> H'( w^ w^ ) > > > ==> [qYES] iff w^(w^) HALTS > > ==> [qNO] iff w^(w^) NEVER HALTS > > > > but the outputs are BACK-TO-FRONT! yes-->loop, no-->terminates > > The analysis must be in reverse order because the H^ decision depends on the w^ decision which depends on the w^2 decision. H^ w^ w^2 --->no (correctly decided halting). -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-01 18:08 -0800 |
| Message-ID | <72c94f62-7596-45cc-97fa-d9df4d20faa3@googlegroups.com> |
| In reply to | #171678 |
On Friday, February 2, 2018 at 11:43:04 AM UTC+10, Pete Olcott wrote: > On 1/31/2018 9:38 PM, grahamcooper7@gmail.com wrote: > > On Thursday, February 1, 2018 at 2:54:04 AM UTC+10, Pete Olcott wrote: > >> On 1/31/2018 12:37 AM, grahamcooper7@gmail.com wrote: > >>> On Wednesday, January 31, 2018 at 4:14:38 PM UTC+10, Pete Olcott wrote: > >>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: > >>>> > >>>>> No. From state qx on, H^ behaves like H' (which behaves like H until > >>>>> the very last state). The H (or the copy of H -- you decide which view > >>>>> you take) which is embedded in H^ must simply do what it does with any > >>>>> input it is asked to "decide". > >>>> > >>>> It lacks sufficient information to decide. > >>>> H^ can only decide what w^ does on its input w^2 based on what w^ decides. > >>>> The essence of this (like the Truth Teller Paradox) is infinitely recursive. > >>>> > >>>> If it is not infinitely recursive (and it is) then w^ would simply decide > >>>> that w^2 halts on its NULL input. The H^ decides that this will cause w^ > >>>> to loop so it simply transitions to ((qn)). > >>> > >>> > >>> > >>> Theres 2 possibilities: > >>> > >>> > >>> qx --> qn > >>> H^ finishes in qNO > >>> H^ stops > >>> > >>> CONTRADICTION > >>> > >>> > >> > >> Not at all. > >> H^ w^ w^2 > >> w^2 transitions to ((qn)) on NULL input > >> causing w^ to transition to (qy) infinite loop > >> causing H^ to transition to ((qn)) correctly reporting not halting for w^ w^2 > >> > >> > > > > > > w^ is a number > > > > > > H^ (w^) > > > > ==> H'( w^ w^ ) > > > > > > ==> [qYES] iff w^(w^) HALTS > > > > ==> [qNO] iff w^(w^) NEVER HALTS > > > > > > > > but the outputs are BACK-TO-FRONT! yes-->loop, no-->terminates > > > > > > The analysis must be in reverse order because the H^ decision > depends on the w^ decision which depends on the w^2 decision. > > H^ w^ w^2 --->no (correctly decided halting). You dont seem to grasp UNIVERSAL TURING MACHINES. U w# x = w(x) Here H^ H^# --> H'( H^# , H^# ) --->LOOPS if HALT(H^# H^#) --->HALTS if !HALT( H^# H^#) HTH!
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-01-31 21:57 +0000 |
| Message-ID | <87fu6lbsjp.fsf@bsb.me.uk> |
| In reply to | #171469 |
Pete Olcott <Pete@NoEmail.address> writes: > On 1/30/2018 9:16 PM, Ben Bacarisse wrote: >> peteolcott <peterolcott2@gmail.com> writes: >> <snip> >>> If we create a machine specification that counts the characters >>> of strings and a string of infinite length is provided as input >>> we cannot expect this machine to halt on every input. >> >> That's wrong in so many ways. No TM is ever provided with a string of >> infinite length (a good book will tell you this). A TM might construct >> a string that never ends, but that's not the same thing. > > It is sufficiently analogous. If a TM is provided with a problem that > specifies infinite recursion then a David Hilbert finite string > formalization of this problem inherently requires infinite recursion. > > This is an analogous idea to a TM that counts the characters of a string > and would otherwise halt except in the case where this string is (for > all practical purpose) infinite. There is no "for all practical purposes" here. TMs can not be provided with infinite input. The input is always finite. I don't know why you want to keep defending this minor mistake because your argument incorrect though it is, does not depend on a TM being given an infinite input string. We all know that some finite input strings can cause some TMs to loop without end. <snip> >>> H^ can only decide if w^ halts on it input w^2 >>> on the basis of w^2 halting on its input w^3... >> >> No. From state qx on, H^ behaves like H' (which behaves like H until >> the very last state). The H (or the copy of H -- you decide which view >> you take) which is embedded in H^ must simply do what it does with any >> input it is asked to "decide". > > It lacks sufficient information to decide. > H^ can only decide what w^ does on its input w^2 based on what w^ decides. > The essence of this (like the Truth Teller Paradox) is infinitely recursive. > > If it is not infinitely recursive (and it is) then w^ would simply decide > that w^2 halts on its NULL input. The H^ decides that this will cause w^ > to loop so it simply transitions to ((qn)). No. I won't explain again because you are not listening. Your words have all sort of errors (H^ is not a decider so it does not decide anything, w^ is a string so it can not loop, and so on) but I'm just glossing over those -- you no longer care about details. >> You can't (and mustn't) say anything >> about how it does that, but you *can* be sure that state qy or qn is >> reached in a finite number of steps. That's because, however it does >> it, it is a decider. > > Making that assumption turns out to be exactly analogous to being certain > that the Liar Paradox must be True or False. I don't care about your analogies -- mathematics requires stronger arguments than "it's like this other thing". Provided you accept that the assumption must go we are in agreement. As a result, I suspect you will have to say you misspoke here. Do you, in fact, agree that the assumption made at the start of the proof must be wrong? >> The one thing that H^ can not do from state qx on is what you are >> assuming it does, and that is to "run" (or emulate or evaluate) its > > It cannot run, it cannot emulate, in math terms evaluate is all that is left. > All math expressions are evaluated, that is how math works. No, that is not how maths works, but going into that would derail the whole thread. You are wrong in this specific case because your argument assumes something it can not assume. H^ *always* transitions from qx to either qn or qy by the assumption made at the start of the proof. Any other assumptions are unwarranted. Anything else you say along the line of "H^ must always..." or "the only way H^ can..." are red-flags showing that you are making assumptions about behaviour with is entirely unknown. You know only two significant facts about H^: one of which is that H^ always transitions to state qy or qn in a finite number of steps (the second is not currently important). >> input. H^ is built from a decider, and no decider can run (or emulate >> or evaluate) its input. Such behaviour is ruled out from the start. > > The title of my final published paper will be: > The Halting Problem proof is merely the Liar Paradox in disguise. An odd title (problems don't have proofs), but it does at least make it clear that you accept that the halting *theorem* (presumably that's what you meant) has a proof. >> You have a notation for this which you wrote out: >> >> qx w^ w^ |-H^ qy oo >> qx w^ w^ |-H^ qn >> >> Do you know what that means? If you do, why did you write it? It is >> correct and it contradicts what you are saying in words. > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > You left some key state transitions out: No. You don't know what this notation means so you think the part I left off matters. I can't really help with that because I don't think you want to learn about the notation. > Definition of Turing Machine Ĥ (state transition sequence) > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn This contradicts what you are saying in words, and it backs up (it is in fact exactly) what I am saying with *my* words. You clearly don't know what this notation means or you would not keep writing something that contradicts yourself again and again. I've said this before, but I think you should stick to words. It's a shame, because they can be so very ambiguous, but you don't seem to have the right mentality for formal notations. Lots of the formulas you write are either under-specified (and thus have a sort of vague poetic quality) or are well-defined and say something you don't mean. I repeat: those two lines are correct and they say what I am saying not what you are trying to say. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-01-31 16:21 -0600 |
| Message-ID | <z_OdnRgSrqDz3O_HnZ2dnUU7-dXNnZ2d@giganews.com> |
| In reply to | #171531 |
On 1/31/2018 3:57 PM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > >> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: >>> peteolcott <peterolcott2@gmail.com> writes: >>> > <snip> >>>> If we create a machine specification that counts the characters >>>> of strings and a string of infinite length is provided as input >>>> we cannot expect this machine to halt on every input. >>> >>> That's wrong in so many ways. No TM is ever provided with a string of >>> infinite length (a good book will tell you this). A TM might construct >>> a string that never ends, but that's not the same thing. >> >> It is sufficiently analogous. If a TM is provided with a problem that >> specifies infinite recursion then a David Hilbert finite string >> formalization of this problem inherently requires infinite recursion. >> >> This is an analogous idea to a TM that counts the characters of a string >> and would otherwise halt except in the case where this string is (for >> all practical purpose) infinite. > > There is no "for all practical purposes" here. TMs can not be provided > with infinite input. The input is always finite. > So it is an analytical impossibility for a TM to be defined to count the number of times that another TM moves its read write head when this other TM has been defined to write the result of doubling the integer value of 2, an infinite number of times? This would be the TM equivalent of infinite input.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-01 01:44 +0000 |
| Message-ID | <871si5bi0y.fsf@bsb.me.uk> |
| In reply to | #171537 |
Pete Olcott <Pete@NoEmail.address> writes: > On 1/31/2018 3:57 PM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: >> >>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: >>>> peteolcott <peterolcott2@gmail.com> writes: >>>> >> <snip> >>>>> If we create a machine specification that counts the characters >>>>> of strings and a string of infinite length is provided as input >>>>> we cannot expect this machine to halt on every input. >>>> >>>> That's wrong in so many ways. No TM is ever provided with a string of >>>> infinite length (a good book will tell you this). A TM might construct >>>> a string that never ends, but that's not the same thing. >>> >>> It is sufficiently analogous. If a TM is provided with a problem that >>> specifies infinite recursion then a David Hilbert finite string >>> formalization of this problem inherently requires infinite recursion. >>> >>> This is an analogous idea to a TM that counts the characters of a string >>> and would otherwise halt except in the case where this string is (for >>> all practical purpose) infinite. >> >> There is no "for all practical purposes" here. TMs can not be provided >> with infinite input. The input is always finite. > > So it is an analytical impossibility for a TM to be defined to count > the number of times that another TM moves its read write head when > this other TM has been defined to write the result of doubling the > integer value of 2, an infinite number of times? Too many begged questions for me to even hazard an answer but I don't see how what I said could be interpreted as anything so fussy. TMs are presented with finite inputs despite the tape being unbounded. Is that what's confusing you? The input is that finite part of the tape that starts with non-blank symbols on it. > This would be the TM equivalent of infinite input. No TM can be given an infinite input. This is simply how they are defined. Your error is unrelated to this issue so there is not need to get sidetracked by it. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-01 19:11 -0600 |
| Message-ID | <oPqdnZrXkPZKJ-7HnZ2dnUU7-WXNnZ2d@giganews.com> |
| In reply to | #171552 |
On 1/31/2018 7:44 PM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > >> On 1/31/2018 3:57 PM, Ben Bacarisse wrote: >>> Pete Olcott <Pete@NoEmail.address> writes: >>> >>>> On 1/30/2018 9:16 PM, Ben Bacarisse wrote: >>>>> peteolcott <peterolcott2@gmail.com> writes: >>>>> >>> <snip> >>>>>> If we create a machine specification that counts the characters >>>>>> of strings and a string of infinite length is provided as input >>>>>> we cannot expect this machine to halt on every input. >>>>> >>>>> That's wrong in so many ways. No TM is ever provided with a string of >>>>> infinite length (a good book will tell you this). A TM might construct >>>>> a string that never ends, but that's not the same thing. >>>> >>>> It is sufficiently analogous. If a TM is provided with a problem that >>>> specifies infinite recursion then a David Hilbert finite string >>>> formalization of this problem inherently requires infinite recursion. >>>> >>>> This is an analogous idea to a TM that counts the characters of a string >>>> and would otherwise halt except in the case where this string is (for >>>> all practical purpose) infinite. >>> >>> There is no "for all practical purposes" here. TMs can not be provided >>> with infinite input. The input is always finite. >> >> So it is an analytical impossibility for a TM to be defined to count >> the number of times that another TM moves its read write head when >> this other TM has been defined to write the result of doubling the >> integer value of 2, an infinite number of times? > > Too many begged questions for me to even hazard an answer but I don't > see how what I said could be interpreted as anything so fussy. TMs are > presented with finite inputs despite the tape being unbounded. Is that > what's confusing you? The input is that finite part of the tape that > starts with non-blank symbols on it. > >> This would be the TM equivalent of infinite input. > > No TM can be given an infinite input. This is simply how they are > defined. Your error is unrelated to this issue so there is not need to > get sidetracked by it. > A TM (such as a UTM) could be instructed to count the read/write head movements of every TM that it executes. The TM that it executes could have been instructed to infinitely double the initial value of 1. This UTM could also have a design constraint that it must halt. Some of its possible inputs contradict this design constraint. Unless the UTM is encoded to stop on a finite number of steps, it will violate its design constraint on some inputs. In any case once we remove the infinite recursion H^ w^ w^2 becomes decidable. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-02 01:54 +0000 |
| Message-ID | <87bmh840ls.fsf@bsb.me.uk> |
| In reply to | #171670 |
Pete Olcott <Pete@NoEmail.address> writes: <snip> > In any case once we remove the infinite recursion H^ w^ w^2 becomes > decidable. (a) There is no infinite recursion in the instance you keep quoting. I have explained why your argument is wrong: you may assume nothing about H^'s behaviour after state qx other than the fact that it transitions to either state qy or qn in a finite number of steps. Each H^ is derived from a machine H about which you know nothing at all except that it does as I keep telling you. (Well, we know one more thing but that does not com into play until you accept the first.) As it happens, when you try to show this "infinite recursion" you keep showing two lines that state this very fact -- that H^ always gets to qn or qy in a finite number of steps. (b) If H^ w^ w^2 means the set of computation where each H^ (each one derived from some H) is given input w^ w^2 as input then of course it is decidable. It is the empty set. If it does not mean that you need to say what it does mean. (And you should read up on what decidable means. It doubt it means what you think it means.) And you really should stop using w^2 (and ideally w^). By far the best notation is something that shows what machine is encoded. In Usenet posts I would use [M] for the string encoding M. Thus the proof discusses the computation H^ [H^] and for some reason you want to talk about H^ [H^] [H^]. What this new computation has to do with the argument I don't know. The proof relies on analysing a different computation so anything you say about this one is irrelevant. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-01 21:15 -0600 |
| Message-ID | <xo-dnQx52bdTSu7HnZ2dnUU7-N_NnZ2d@giganews.com> |
| In reply to | #171679 |
On 2/1/2018 7:54 PM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > <snip> >> In any case once we remove the infinite recursion H^ w^ w^2 becomes >> decidable. > > (a) There is no infinite recursion in the instance you keep quoting. I > have explained why your argument is wrong: you may assume nothing about > H^'s behaviour after state qx other than the fact that it transitions to > either state qy or qn in a finite number of steps. Each H^ is derived > from a machine H about which you know nothing at all except that it does > as I keep telling you. (Well, we know one more thing but that does not > com into play until you accept the first.) > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ None the less when I remove this "non existent" infinite recursion H^ correctly decides whether or not one instance of its own TM description would halt on another instance of its TM description. Furthermore it is impossible to construct any single pair of finite string TM descriptions that would confirm the HP proof conclusion. The Halting Problem is about whether or not a TM exists that can decide halting for a single TM input pair. No valid counter-examples exist. Copyright 2016 2017 2018 Pete Olcott
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-01 19:36 -0800 |
| Message-ID | <88ec9f43-0c2b-468c-9687-56addec6c6f0@googlegroups.com> |
| In reply to | #171685 |
> The Halting Problem is about whether or not a TM exists that can decide > halting for a single TM input pair. No valid counter-examples exist. > > Copyright 2016 2017 2018 Pete Olcott The counter-example depends on HALT()! Its a HYPOTHETICAL (YET CONSTRUCTABLE-GIVEN-HALT-EXISTS) COUNTER EXAMPLE! STOP CHANGING H^ YOU CHEATER! It just _APPENDS_ 500 GOTO 500 to the end of the HALT function. some Turing Machines DONT HALT!!! halt -- 1 2 3 4 ------ INPUT 1 2 1 0 1 1 3 halt 0 0 1 0 4 5 h^ ? ? ? ? ? 7 | | PROGRAMS YOUR HALT FUNCTION IS MISSING ROW H^
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-02 21:13 +0000 |
| Message-ID | <87po5n2iys.fsf@bsb.me.uk> |
| In reply to | #171685 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/1/2018 7:54 PM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: >> <snip> >>> In any case once we remove the infinite recursion H^ w^ w^2 becomes >>> decidable. >> >> (a) There is no infinite recursion in the instance you keep quoting. I >> have explained why your argument is wrong: you may assume nothing about >> H^'s behaviour after state qx other than the fact that it transitions to >> either state qy or qn in a finite number of steps. Each H^ is derived >> from a machine H about which you know nothing at all except that it does >> as I keep telling you. (Well, we know one more thing but that does not >> com into play until you accept the first.) >> > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > > None the less when I remove this "non existent" infinite recursion You can't remove something that is not there. What's more, if it is there, it can't be "removed" by changing the input to H^ -- that's just some other vaguely similar computation whose behaviour is of no relevance to the case hypothesised in the proof. > H^ correctly decides whether or not one instance of its own TM description > would halt on another instance of its TM description. H^ is not a decider, but that's the sort of detail you don't care about. More significant, though, is that deciding one case is trivial. No one cares if some machine decides one case or not. > Furthermore it is impossible to construct any single pair of finite string TM > descriptions that would confirm the HP proof conclusion. I wonder what that means. What is "the HP proof"? Problems don't have proofs. What is a "proof conclusion"? Is it what everyone else calls a theorem? If so, how could any single anything confirm it? And what significance could there be to not being able to confirm it with some single thing? > The Halting Problem is about whether or not a TM exists that can decide > halting for a single TM input pair. No. How many years have you been working on this? Understanding the problem should surely have been the very first step. No wonder you are confused about the proof if you can't even state the problem. > No valid counter-examples exist. Indeed. Everyone agrees on that. It seems that you don't yet know what the halting problem is. I'd like to think that maybe you just don't know how to express it in words, odd though that would be after all this time, but I can't shake the thought that maybe you really don't know what computational problem the halting theorem is about. -- Ben.
[toc] | [prev] | [next] | [standalone]
Page 2 of 6 — ← Prev page 1 [2] 3 4 5 6 Next page →
Back to top | Article view | sci.logic
csiph-web