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 | 18 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 6 of 6 — ← Prev page 1 2 3 4 5 [6]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-03 00:51 +0000 |
| Message-ID | <87bmh63nfg.fsf@bsb.me.uk> |
| In reply to | #171734 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/2/2018 3:38 PM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: >> >>> On 2/1/2018 8:04 PM, Ben Bacarisse wrote: >>>> Pete Olcott <Pete@NoEmail.address> writes: >>>> >>>>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote: >> <snip> >>>>>> The argument you presented has an error which I pointed out. You have >>>>>> not addressed it (and I don't mind that) but you have not even responded >>>>>> to a simple request for a clarification. I think you've entered "post >>>>>> any old answer" mode now so I expect you will soon be gone for a >>>>>> while... >>>>> >>>>> OK F is not expressive enough to have a provability predicate so I will use H. >>>>> >>>>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉). >>>>> (G2) H ⊢ GH ↔ ¬ProvF(GH). >>>>> G2 is precisely analogous to G1 such that showing G2 is erroneous >>>>> shows that G1 is erroneous. --- >>>> >>>> You made incorrect statements about a well-know proof. I pointed out >>>> why they were wrong. Do you retract them? They are still on your blog >>>> (along with some more new errors). >>> >>> Can you be more evasive? If you try really hard I think that you can. >> >> I have been as direct as I can be. You have not addressed the error I >> pointed out. >> >>> In any case we are not talking about my blog we are talking about the >>> above two formulas. >> >> No, I'm not talking about them. I am still talking about the error you >> are avoiding. You have no addressed it. I mention your blog only >> because you keep posting the reference and you've stopped talking about >> the error here. > > Then be completely specific about the error on the blog, I have at least > forty blog posts, and so far the closest you came to pointing out any error > was a vague assertion that I made some mistake somewhere. I was very explicit about the error when you posted it here. You did not address it. I can't imagine why you want me to tell you again but here goes... At http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ you repeat the incorrect conclusion that "The HP proof counter-examples all get stuck in infinite recursion (never reaching states qy or qn)". This is incorrect and you reach this incorrect conclusion by making (at step (2)) and unwarranted assumption that is contrary to what you know about H^ a this point -- contrary to how H^ is defined. Oddly, to explain why H^ does not get to either qy or qn you write q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn which says exactly what you deny. Those two lines happen to be correct and they state that H^ transitions into either state qn or state qy in a finite number of steps. There are, of course, lots of other errors. (3) and (4) talk about strings doing things. It might be poetry, but it's not mathematics. You then go on to eliminate something that does no exist by showing a machine configuration that has nothing to do with the halting problem. Then you assert that the notation you clearly don't understand: q0 ŵ ŵ2 ⊢* Ĥ qy ∞ q0 ŵ ŵ2 ⊢* Ĥ qn says that H^ *will* (in this case) transition to either state qy or qn in a finite number of steps. But if you applied the (admittedly incorrect) argument you did a few lines previously you'd see it applies to this configuration as well. You are not even consistently wrong. And that is far from being the full list. There are strings transitioning and talk about counter-examples and odd things being "decidable" and so on, but the main error is the first: you assume something about H^ that is contrary to it's definition. > The reason that you have to stick with vague assertions and cannot > point out a specific mistake and why it is a mistake is that there is > no mistake at all. No, the assertions become vague when I see you won't respond to them. Why not bookmark or save this post because I'm sure you will again tell me I have not told you where you are wrong in a few posts time. Not that there is nothing here that is new. I've said it all before. To be fair, you did try to address this key error at one time, but your conclusion -- that the assumptions made about H must be wrong -- is exactly what the poof is establishing. Maybe you realised that, because you stopped saying this and switched to posting more of your symbol poems. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-03 00:38 -0600 |
| Message-ID | <kvGdnadq9Kp2xejHnZ2dnUU7-a3NnZ2d@giganews.com> |
| In reply to | #171740 |
On 2/2/2018 6:51 PM, Ben Bacarisse wrote: > Pete Olcott <Pete@NoEmail.address> writes: > >> On 2/2/2018 3:38 PM, Ben Bacarisse wrote: >>> Pete Olcott <Pete@NoEmail.address> writes: >>> >>>> On 2/1/2018 8:04 PM, Ben Bacarisse wrote: >>>>> Pete Olcott <Pete@NoEmail.address> writes: >>>>> >>>>>> On 1/31/2018 7:51 PM, Ben Bacarisse wrote: >>> <snip> >>>>>>> The argument you presented has an error which I pointed out. You have >>>>>>> not addressed it (and I don't mind that) but you have not even responded >>>>>>> to a simple request for a clarification. I think you've entered "post >>>>>>> any old answer" mode now so I expect you will soon be gone for a >>>>>>> while... >>>>>> >>>>>> OK F is not expressive enough to have a provability predicate so I will use H. >>>>>> >>>>>> (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉). >>>>>> (G2) H ⊢ GH ↔ ¬ProvF(GH). >>>>>> G2 is precisely analogous to G1 such that showing G2 is erroneous >>>>>> shows that G1 is erroneous. --- >>>>> >>>>> You made incorrect statements about a well-know proof. I pointed out >>>>> why they were wrong. Do you retract them? They are still on your blog >>>>> (along with some more new errors). >>>> >>>> Can you be more evasive? If you try really hard I think that you can. >>> >>> I have been as direct as I can be. You have not addressed the error I >>> pointed out. >>> >>>> In any case we are not talking about my blog we are talking about the >>>> above two formulas. >>> >>> No, I'm not talking about them. I am still talking about the error you >>> are avoiding. You have no addressed it. I mention your blog only >>> because you keep posting the reference and you've stopped talking about >>> the error here. >> >> Then be completely specific about the error on the blog, I have at least >> forty blog posts, and so far the closest you came to pointing out any error >> was a vague assertion that I made some mistake somewhere. > > I was very explicit about the error when you posted it here. You did > not address it. I can't imagine why you want me to tell you again but > here goes... At > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > > you repeat the incorrect conclusion that "The HP proof counter-examples > all get stuck in infinite recursion (never reaching states qy or qn)". > This is incorrect and you reach this incorrect conclusion by making (at > step (2)) and unwarranted assumption that is contrary to what you know > about H^ a this point -- contrary to how H^ is defined. > OK great you are getting specific here. It is not contrary to how H^ is defined. I am working on proving this more unequivocally. The essential nature of the problem presented to H^ is inherently infinitely recursive. Whether or not H^ actually executes infinite recursion is a different question. These are Facts: After H^ makes a copy of its input H^ must decide based on what H^2 H^3 would do. H^2 would make a copy and then it would decide based on what H^3 H^4 would do. The definition of the problem is infinitely recursive. That does not necessarily entail that H^ would actually execute infinite recursion. > Oddly, to explain why H^ does not get to either qy or qn you write > > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn > The potential halt decider and every instance of its input are all defined to have exactly the same behavior. This is the part that makes the inherent definition of the problem infinitely recursive: Every instance of the above definition would begin at q0 copy its input and then transition to qx. If H^ would copy its input H^2 to H^3, then H^2 would also copy its input H^3 to H^4 on and on... > which says exactly what you deny. Those two lines happen to be correct > and they state that H^ transitions into either state qn or state qy in a > finite number of steps. > > There are, of course, lots of other errors. (3) and (4) talk about > strings doing things. It might be poetry, but it's not mathematics. > H^ evaluates what H^2 would do even if H^2 actually does nothing besides just sit there. If H^2 was executed by a UTM it would copy its input. H^ must decide what H^2 would do if it was executed by a UTM. > You then go on to eliminate something that does no exist by showing a > machine configuration that has nothing to do with the halting problem. > Then you assert that the notation you clearly don't understand: > > q0 ŵ ŵ2 ⊢* Ĥ qy ∞ > q0 ŵ ŵ2 ⊢* Ĥ qn > > says that H^ *will* (in this case) transition to either state qy or qn > in a finite number of steps. But if you applied the (admittedly > incorrect) argument you did a few lines previously you'd see it applies > to this configuration as well. You are not even consistently wrong. > There is no infinitely recursive evaluation sequence defined in that machine. (The H' machine of Figure 12.2) H'3 --> qn (NULL input) H'2 --> qy loops H' --> qn If the above was evaluated by H (Figure 12.1) H would be a decider for H' H'. H'2 --> qn (NULL input) H' --> qy loops H --> qn > And that is far from being the full list. There are strings > transitioning and talk about counter-examples and odd things being > "decidable" and so on, but the main error is the first: > you assume > something about H^ that is contrary to it's definition. > I never did this. Hopefully my clarifications will make my point more clear. I am shooting to get published, first I must be understood. >> The reason that you have to stick with vague assertions and cannot >> point out a specific mistake and why it is a mistake is that there is >> no mistake at all. > > No, the assertions become vague when I see you won't respond to them. > Why not bookmark or save this post because I'm sure you will again tell > me I have not told you where you are wrong in a few posts time. > As long as you remain totally specific I will very carefully study everything that you say. I want to focus in the infinite recursion aspect though. I will try to use terminology precisely correctly. With the HP proof the correct terms exist. > Not that there is nothing here that is new. I've said it all before. > > To be fair, you did try to address this key error at one time, but your > conclusion -- that the assumptions made about H must be wrong -- is > exactly what the poof is establishing. Maybe you realised that, because > you stopped saying this and switched to posting more of your symbol > poems. > The two key errors that you claimed and I responded to are not errors at all. Let's focus on the infinite recursion aspect. It is not that I am wrong, it is that I have not yet proven my point. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-02 23:05 -0800 |
| Message-ID | <c83783fe-b761-488c-86c0-22a130484c4f@googlegroups.com> |
| In reply to | #171758 |
On Saturday, Pete Olcott wrote: > > OK great you are getting specific here. > It is not contrary to how H^ is defined. > I am working on proving this more unequivocally. > > The essential nature of the problem presented to H^ is inherently infinitely recursive. OK.... HALT is presented problems too, some halt, some loop or recurse > > Whether or not H^ actually executes infinite recursion is a different question. > > These are Facts: > After H^ makes a copy of its input CORRECT! > H^ must decide based on what H^2 H^3 would do. RIGHT! but this is just H^(H^) all over again! > H^2 would make a copy and then it would WHO CARES! H^2(H^3) is the same as H^(H^) > decide based on what H^3 H^4 would do. > > The definition of the problem is infinitely recursive. NO! Its a proof by CONTRADICTION! if you cant code ..... if (halt( halt(x,y)) ... then halt cannot exist! > That does not necessarily entail that H^ would actually execute infinite recursion. CORRECT! > > > Oddly, to explain why H^ does not get to either qy or qn you write > > > > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ > > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn > > > > The potential halt decider and every instance of its input are all defined > to have exactly the same behavior. > > This is the part that makes the inherent definition of the problem infinitely recursive: > > Every instance of the above definition would begin at q0 copy its input and then transition to qx. > > If H^ would copy its input H^2 to H^3, > then H^2 would also copy its input H^3 to H^4 > on and on... this is CASE 1. there are 2 CASES > > > which says exactly what you deny. Those two lines happen to be correct > > and they state that H^ transitions into either state qn or state qy in a > > finite number of steps. YES! CONTRADICTION! > > > > There are, of course, lots of other errors. (3) and (4) talk about > > strings doing things. It might be poetry, but it's not mathematics. > > > > H^ evaluates what H^2 would do even if H^2 actually does nothing besides > just sit there. If H^2 was executed by a UTM it would copy its input. > H^ must decide what H^2 would do if it was executed by a UTM. [YES] or [NO] (qy or qn) BOTH ARE WRONG! > > > You then go on to eliminate something that does no exist by showing a > > machine configuration that has nothing to do with the halting problem. > > Then you assert that the notation you clearly don't understand: > > > > q0 ŵ ŵ2 ⊢* Ĥ qy ∞ > > q0 ŵ ŵ2 ⊢* Ĥ qn > > > > says that H^ *will* (in this case) transition to either state qy or qn > > in a finite number of steps. But if you applied the (admittedly > > incorrect) argument you did a few lines previously you'd see it applies > > to this configuration as well. You are not even consistently wrong. > > > > There is no infinitely recursive evaluation sequence defined in that > machine. (The H' machine of Figure 12.2) > H'3 --> qn (NULL input) > H'2 --> qy loops > H' --> qn > > If the above was evaluated by H (Figure 12.1) H would be a decider for H' H'. > H'2 --> qn (NULL input) > H' --> qy loops > H --> qn > > > And that is far from being the full list. There are strings > > transitioning and talk about counter-examples and odd things being > > "decidable" and so on, but the main error is the first: > > > you assume > > something about H^ that is contrary to it's definition. > > > > I never did this. Hopefully my clarifications will make my point > more clear. I am shooting to get published, first I must be understood. > > >> The reason that you have to stick with vague assertions and cannot > >> point out a specific mistake and why it is a mistake is that there is > >> no mistake at all. > > > > No, the assertions become vague when I see you won't respond to them. > > Why not bookmark or save this post because I'm sure you will again tell > > me I have not told you where you are wrong in a few posts time. > > > > As long as you remain totally specific I will very carefully study > everything that you say. I want to focus in the infinite recursion > aspect though. I will try to use terminology precisely correctly. > With the HP proof the correct terms exist. > > > Not that there is nothing here that is new. I've said it all before. > > > > To be fair, you did try to address this key error at one time, but your > > conclusion -- that the assumptions made about H must be wrong -- is > > exactly what the poof is establishing. Maybe you realised that, because > > you stopped saying this and switched to posting more of your symbol > > poems. > > > > The two key errors that you claimed and I responded to are not errors at all. > Let's focus on the infinite recursion aspect. It is not that I am wrong, > it is that I have not yet proven my point. > OK! DEFINE H H--->[yes] | | | v [no] Add 2 more TURING STATES J--->[toggle]<--->[toggle] | | | v [no] Add a small TM that copies the tape in 2 copies. (000111111110000) <- the number of below machine [copy] | | (0001111111101111111000) <- input has been copied | v [J]---->[toggle]<--->[toggle] | | | [no] If J says M(M) halts [qy] then M(M) loops If J says M(M) loops [qn] then M(M) stops
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-03 13:37 +0000 |
| Message-ID | <87vafe19f9.fsf@bsb.me.uk> |
| In reply to | #171758 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/2/2018 6:51 PM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: <snip> >>> Then be completely specific about the error on the blog, I have at least >>> forty blog posts, and so far the closest you came to pointing out any error >>> was a vague assertion that I made some mistake somewhere. >> >> I was very explicit about the error when you posted it here. You did >> not address it. I can't imagine why you want me to tell you again but >> here goes... At >> >> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >> >> you repeat the incorrect conclusion that "The HP proof counter-examples >> all get stuck in infinite recursion (never reaching states qy or qn)". >> This is incorrect and you reach this incorrect conclusion by making (at >> step (2)) and unwarranted assumption that is contrary to what you know >> about H^ a this point -- contrary to how H^ is defined. > > OK great you are getting specific here. I have said all of this before and the key part (your main mistake) several times. I'm not inclined to accuse you of dishonesty so I must assume that have not been reading the posts you are replying to. Is that the case? > It is not contrary to how H^ is defined. Yes it is. H^ is derived from H' which is derived from H which is assumed to be halt decider. You must only make deductions that are consistent with this definition. > I am working on proving this more unequivocally. > > The essential nature of the problem presented to H^ is inherently > infinitely recursive. The essential nature of H^ is that it does not exist. Thus the supposed problem (which involves [H^] -- that's my way of writing H^'s encoding) does not exist either. You often loose track of this rather basic fact. > Whether or not H^ actually executes infinite recursion is a different > question. Actually it's the key question and the key to your error. You keep saying (and you say it again below) that H^ really does execute indefinitely rather than transitioning to qy or qn in a finite number of steps as per its definition. > These are Facts: > After H^ makes a copy of its input > H^ must decide based on what H^2 H^3 would do. > H^2 would make a copy and then it would > decide based on what H^3 H^4 would do. No. There is only one "must" you can say about H^ -- it must transition to either qy or qn in a finite number of steps. You then compound this error by talking about what strings do. You really need to stop saying anything about what a string does. If you are assuming that H^ is or behaves line a universal TM (thereby making the idea of a string doing something at least metaphorically reasonable), that too is an error. > The definition of the problem is infinitely recursive. > That does not necessarily entail that H^ would actually execute infinite recursion. > >> Oddly, to explain why H^ does not get to either qy or qn you write >> >> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞ >> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn > > The potential halt decider and every instance of its input are all defined > to have exactly the same behavior. Does this remark have anything to do with your incorrect use of Linz's notation? Those two lines, which you keep writing to show the "infinite recursion", actually state the opposite. Some correction of this error would be appreciated. Either that or you could explain why you think those two lines support your case rather than directly refute it. That would allow me to see what it is you've misunderstood about these two simple lines. > This is the part that makes the inherent definition of the problem > infinitely recursive: > > Every instance of the above definition would begin at q0 copy its > input and then transition to qx. The above is not a definition. H^'s definition in given only in words and diagrams in Linz. The two lines you are not understand say something (but not everything) about what H^ *does* in some particular cases. It does *not* say (because that would be wrong) what you claim. > If H^ would copy its input H^2 to H^3, Don't keep inventing new, bad, notations. There is no need to keep numbering strings, and you should not label them with a capital letter. H^2 looks like a machine, not a string. If you stick with writing out configurations there can be no confusion. This is the initial configuration of H^, written out properly: q0 [H^] q0 is the state of the machine, [H^] is the encoding of H^. By the definition of H^, the following happens: q0 [H^] |-* qx [H^] [H^] There is no need to keep writing H^ under the |- symbol since it's the only machine whose traces we will be writing. qx is the state of H^ that corresponds to the initial state of H (and also of H'). This line says "after copying the input string, H^ behaves exactly like H'". Also form the definition of H^ we may go on to say q0 [H^] |-* qx [H^] [H^] |-* qy oo (that's an infinity symbol) q0 [H^] |-* qx [H^] [H^] |-* qn This says that H^ goes on to transition into either state qy or qn. This follows from the fact the H^ is now behaving like H' and H' is defined to do this. > then H^2 would also copy its input H^3 to H^4 > on and on... H^2 is a string, confusingly named in a way that makes it look like a machine. It does not copy anything. Part of the reason you keep making these category errors is that you have no good notation to write what is going on. I know as well as anyone that what you write as H^2 (and I write as [H^]) is the encoding of a machine, but encodings -- even of machines -- can't do anything. They can be interpreted by a UTM, but it is still the UTM that is doing things, changing state and writing symbols and so on. From what you write below it's clear that you talk of strings doing things because you can think of no other way that H could decide halting but to interpret (or run or evaluate) its input string. However, that is one thing you can *not* assume about H (or the H' and H^ derived from it). >> which says exactly what you deny. Those two lines happen to be correct >> and they state that H^ transitions into either state qn or state qy in a >> finite number of steps. >> >> There are, of course, lots of other errors. (3) and (4) talk about >> strings doing things. It might be poetry, but it's not mathematics. > > H^ evaluates what H^2 would do even if H^2 actually does nothing besides > just sit there. If H^2 was executed by a UTM it would copy its input. > H^ must decide what H^2 would do if it was executed by a UTM. No. You may not assume that H^ evaluates what H^2 would do. Any argument that relies on such an unwarranted assumption must be rejected. >> You then go on to eliminate something that does no exist by showing a >> machine configuration that has nothing to do with the halting problem. >> Then you assert that the notation you clearly don't understand: >> >> q0 ŵ ŵ2 ⊢* Ĥ qy ∞ >> q0 ŵ ŵ2 ⊢* Ĥ qn >> >> says that H^ *will* (in this case) transition to either state qy or qn >> in a finite number of steps. But if you applied the (admittedly >> incorrect) argument you did a few lines previously you'd see it applies >> to this configuration as well. You are not even consistently wrong. > > There is no infinitely recursive evaluation sequence defined in that > machine. It does not matter. This configuration is irrelevant. You are fixing a non-extent problem in some computation by presenting a new computation that does not occur. You happen to be wrong about this new computation as well, but since it does not matter, we should not waste time on it. What matters is what happens in *this* configuration: q0 [H^] not what happens in this new one you've pulled out of a hat: q0 [H^] [H^] <snip> > The two key errors that you claimed and I responded to are not errors at all. > Let's focus on the infinite recursion aspect. Absolutely. Nothing else matter after you make your unwarranted assumption about what H^ does, but it would help if you understood the notation you keep using since you keep contradicting your words with the symbols you write. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-02-03 14:27 -0600 |
| Message-ID | <f8KdnRcZ5MqwhuvHnZ2dnUU7-IHNnZ2d@giganews.com> |
| In reply to | #171767 |
On 2/3/2018 7:37 AM, Ben Bacarisse wrote:
> Pete Olcott <Pete@NoEmail.address> writes:
>
>> On 2/2/2018 6:51 PM, Ben Bacarisse wrote:
>>> Pete Olcott <Pete@NoEmail.address> writes:
> <snip>
>>>> Then be completely specific about the error on the blog, I have at least
>>>> forty blog posts, and so far the closest you came to pointing out any error
>>>> was a vague assertion that I made some mistake somewhere.
>>>
>>> I was very explicit about the error when you posted it here. You did
>>> not address it. I can't imagine why you want me to tell you again but
>>> here goes... At
>>>
>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>>>
>>> you repeat the incorrect conclusion that "The HP proof counter-examples
>>> all get stuck in infinite recursion (never reaching states qy or qn)".
>>> This is incorrect and you reach this incorrect conclusion by making (at
>>> step (2)) and unwarranted assumption that is contrary to what you know
>>> about H^ a this point -- contrary to how H^ is defined.
>>
>> OK great you are getting specific here.
>
> I have said all of this before and the key part (your main mistake)
> several times. I'm not inclined to accuse you of dishonesty so I must
> assume that have not been reading the posts you are replying to. Is
> that the case?
>
>> It is not contrary to how H^ is defined.
>
> Yes it is. H^ is derived from H' which is derived from H which is
> assumed to be halt decider. You must only make deductions that are
> consistent with this definition.
>
I agree with this completely you disagree with it below.
>> I am working on proving this more unequivocally.
>>
>> The essential nature of the problem presented to H^ is inherently
>> infinitely recursive.
>
> The essential nature of H^ is that it does not exist. Thus the supposed
> problem (which involves [H^] -- that's my way of writing H^'s encoding)
> does not exist either. You often loose track of this rather basic fact.
>
>> Whether or not H^ actually executes infinite recursion is a different
>> question.
>
> Actually it's the key question and the key to your error. You keep
> saying (and you say it again below) that H^ really does execute
> indefinitely rather than transitioning to qy or qn in a finite number of
No I do not say this. I have said it before, I have retracted that now.
Since I just retracted that above you must not be paying enough attention.
> steps as per its definition.
>
>> These are Facts:
>> After H^ makes a copy of its input
>> H^ must decide based on what H^2 H^3 would do.
>> H^2 would make a copy and then it would
>> decide based on what H^3 H^4 would do.
>
> No. There is only one "must" you can say about H^ -- it must transition
> to either qy or qn in a finite number of steps.
Ah, but, here is where you contradict yourself. If H^ inherits all
of its behavior from H and H (until it is contradicted) is a possible
halt decider (it has not be contradicted yet), then H could only
transition to its states entirely based on what H^ actually does.
If what H^ does is copy its input, then H must consider this as
a part of what H^ does. The next thing that H^ does from its state
qx is examine what H^2 would do on its input H^3.
Thus we have at least these necessary dependencies.
H depends on what H^ does which depends upon what H^2 does which
depends upon what H3 does.
Because we are assuming (until contradicted) that H is a halt decider
it must make an actual attempt at deciding, it must examine its input
and base its decision on what its input would do if this input was
executed by a UTM.
>
> You then compound this error by talking about what strings do. You
> really need to stop saying anything about what a string does. If you
> are assuming that H^ is or behaves line a universal TM (thereby making
> the idea of a string doing something at least metaphorically
> reasonable), that too is an error.
>
H examines what H^ actually would do if H^ was executed by a UTM.
If H determines that H^ would get stuck in infinite recursion then
H itself need not get stuck, H would simply transition to its final
state ((qn)).
>> The definition of the problem is infinitely recursive.
>> That does not necessarily entail that H^ would actually execute infinite recursion.
>>
>>> Oddly, to explain why H^ does not get to either qy or qn you write
>>>
>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
>>
>> The potential halt decider and every instance of its input are all defined
>> to have exactly the same behavior.
>
> Does this remark have anything to do with your incorrect use of Linz's
> notation? Those two lines, which you keep writing to show the "infinite
> recursion", actually state the opposite.
For simplicity of communication I am assuming that all labeled
machines are finite string Turing Machine Descriptions capable of
being executed by a UTM. This is like a David Hilbert formalist
approach where the formal language is Turing Machine descriptions.
Every instance of H^ executed by a UTM:
(1) Begins at its start state q0 with input w^
(2) Copies this input w^ to w^2 and transitions to its qx state
(3) Begins evaluating w^ w^2 at state qx
When H^ is executed by a UTM it performs these same steps.
When H^ is at its qx state its configuration looks like this: Ĥ qx [Ĥ2] [Ĥ3] ⊢*
Because [H^] is derived from H it must also determine what [Ĥ2] would do on
its input [Ĥ3] as if [Ĥ2]/[Ĥ3] was being executed on a UTM.
The fact that H^ inherits from H mandates these steps.
We have at least these necessary dependencies:
H depends on what H^ does which depends upon what H^2 does which depends upon what H3 does.
> Some correction of this error
> would be appreciated. Either that or you could explain why you think
> those two lines support your case rather than directly refute it. That
> would allow me to see what it is you've misunderstood about these two
> simple lines.
>
I think that I may have been clear enough now that you will understand that I am correct.
>> This is the part that makes the inherent definition of the problem
>> infinitely recursive:
>>
>> Every instance of the above definition would begin at q0 copy its
>> input and then transition to qx.
>
> The above is not a definition. H^'s definition in given only in words
> and diagrams in Linz. The two lines you are not understand say
> something (but not everything) about what H^ *does* in some particular
> cases. It does *not* say (because that would be wrong) what you claim.
>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞
>>> q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
This says that every instance of H^ (executed by a UTM)
begins at its start state,
copies its input and
then transitions to qx where it begins evaluating ŵ ŵ.
>
>> If H^ would copy its input H^2 to H^3,
>
> Don't keep inventing new, bad, notations. There is no need to keep
> numbering strings, and you should not label them with a capital letter.
> H^2 looks like a machine, not a string. If you stick with writing out
> configurations there can be no confusion.
As explained above I am using David Hilbert formalist approach to
eliminate the extraneous complexity of distinguishing between TM
and TMDs. Everything is a TMD, and H is executed by a UTM.
>
> This is the initial configuration of H^, written out properly:
>
> q0 [H^]
>
> q0 is the state of the machine, [H^] is the encoding of H^. By the
> definition of H^, the following happens:
>
> q0 [H^] |-* qx [H^] [H^]
>
That is a reasonable approach that eliminates verbosity.
> There is no need to keep writing H^ under the |- symbol since it's the
> only machine whose traces we will be writing.
Actually I have switched to examining H evaluating [H^] [H^]
otherwise we are only proving that an otherwise correct halt
decider can be broken by appending infinite loops to its halt states.
> qx is the state of H^
> that corresponds to the initial state of H (and also of H'). This line
> says "after copying the input string, H^ behaves exactly like H'".
>
Yes
> Also form the definition of H^ we may go on to say
>
> q0 [H^] |-* qx [H^] [H^] |-* qy oo (that's an infinity symbol)
> q0 [H^] |-* qx [H^] [H^] |-* qn
>
> This says that H^ goes on to transition into either state qy or qn.
> This follows from the fact the H^ is now behaving like H' and H' is
> defined to do this.
>
Not quite.
>> then H^2 would also copy its input H^3 to H^4
>> on and on...
>
> H^2 is a string, confusingly named in a way that makes it look like a
> machine. It does not copy anything. Part of the reason you keep making
> these category errors is that you have no good notation to write what is
> going on.
>
Not really H (no category error) must evaluate what [H^] would do one its
input [H^] as if [H^] was executed on a UTM. So that we can keep track of
the dependency chain I append subscripts to some of these TMDs.
H is evaluating what [H^] would do on its input [H^2] if [H^] was executed on a UTM.
The first thing that [H^] would do is copy its input [H^2] to [H^3].
> I know as well as anyone that what you write as H^2 (and I write as
> [H^]) is the encoding of a machine, but encodings -- even of machines --
> can't do anything. They can be interpreted by a UTM, but it is still
> the UTM that is doing things, changing state and writing symbols and so
> on.
>
All this is really just a general purpose computer executing a program.
So If the program (TMD) specifies an infinite loop then the computer
(UTM) would faithfully execute this infinite loop.
> From what you write below it's clear that you talk of strings doing
> things because you can think of no other way that H could decide halting
> but to interpret (or run or evaluate) its input string. However, that
> is one thing you can *not* assume about H (or the H' and H^ derived from
> it).
>
That is not what I am saying at all. I am saying that H must determine
what [H^][H^] {would do} if it was executed on a UTM. This is not the same
thing as saying that H determines what H^ {does}. {would do} and {does}
are different things. H must determine what H^ {would do} within the
premise that (until contradicted) that H is a halt decider.
>>> which says exactly what you deny. Those two lines happen to be correct
>>> and they state that H^ transitions into either state qn or state qy in a
>>> finite number of steps.
>>>
>>> There are, of course, lots of other errors. (3) and (4) talk about
>>> strings doing things. It might be poetry, but it's not mathematics.
>>
>> H^ evaluates what H^2 would do even if H^2 actually does nothing besides
>> just sit there. If H^2 was executed by a UTM it would copy its input.
>> H^ must decide what H^2 would do if it was executed by a UTM.
>
> No. You may not assume that H^ evaluates what H^2 would do. Any
> argument that relies on such an unwarranted assumption must be
> rejected.
I am not assuming that, it is an aspect of the foundational premise
that H is (until contradicted) a halt decider. All halt deciders must
necessarily determine what their input {would do}. We are not allowed
to drop that foundational premise until it is contradicted.
>
>>> You then go on to eliminate something that does no exist by showing a
>>> machine configuration that has nothing to do with the halting problem.
>>> Then you assert that the notation you clearly don't understand:
>>>
>>> q0 ŵ ŵ2 ⊢* Ĥ qy ∞
>>> q0 ŵ ŵ2 ⊢* Ĥ qn
>>>
>>> says that H^ *will* (in this case) transition to either state qy or qn
>>> in a finite number of steps. But if you applied the (admittedly
>>> incorrect) argument you did a few lines previously you'd see it applies
>>> to this configuration as well. You are not even consistently wrong.
>>
>> There is no infinitely recursive evaluation sequence defined in that
>> machine.
>
> It does not matter. This configuration is irrelevant. You are fixing a
> non-extent problem in some computation by presenting a new computation
> that does not occur. You happen to be wrong about this new computation
> as well, but since it does not matter, we should not waste time on it.
>
> What matters is what happens in *this* configuration:
>
> q0 [H^]
>
> not what happens in this new one you've pulled out of a hat:
>
> q0 [H^] [H^]
An execution trace of what H^ would when when executed by a UTM:
q0 [H^] ⊢* Ĥ qx [H^][H^]
>
> <snip>
>> The two key errors that you claimed and I responded to are not errors at all.
>> Let's focus on the infinite recursion aspect.
>
> Absolutely. Nothing else matter after you make your unwarranted
> assumption about what H^ does, but it would help if you understood the
> notation you keep using since you keep contradicting your words with the
> symbols you write.
>
I have spent over three hours on this single reply.
The second sentence below may take more than on hour to fully understand.
Halt Decider definition:
(1) A Halt Decider decides whether or not its input TMD would halt on its
input (as if this input TMD was executed on a UTM).
(2) This requires the halt decider to evaluate the chain-of-inference
leading to the halting or non halting behavior of the TMD.
This same Halt Decider definition applies recursively to every TMD in the inference chain.
Copyright 2015,2016,2017,2018 Pete Olcott
--
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-03 23:49 +0000 |
| Message-ID | <87k1vtzla4.fsf@bsb.me.uk> |
| In reply to | #171798 |
Pete Olcott <Pete@NoEmail.address> writes: > On 2/3/2018 7:37 AM, Ben Bacarisse wrote: >> Pete Olcott <Pete@NoEmail.address> writes: <snip> >>> Whether or not H^ actually executes infinite recursion is a different >>> question. >> >> Actually it's the key question and the key to your error. You keep >> saying (and you say it again below) that H^ really does execute >> indefinitely rather than transitioning to qy or qn in a finite number of > > No I do not say this. I have said it before, I have retracted that now. > Since I just retracted that above you must not be paying enough > attention. Yes, it did look a bit like a retraction, but at no point did you concede the key point. Saying "whether or not H^ actually executes infinite recursion is a different question" just sounded like hedging unless you state that H^ will *never* get stuck in a loop (before the loop at the very end) and will, instead, *always* get to state qy or qn. This is the key point and I would be very happy to see you that really do now accept it. Could you be clear and state unequivocally that you agree that H^ always gets to state qy or state qn in a finite number of steps? This point is really the only one that matters. All the other errors are just details in comparison. BTW, when did you last edit the blog post http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ ? It's still wrong, but it's less wrong than I remember it being, despite being dated Jan 18. <text removed> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-02-03 16:03 -0800 |
| Message-ID | <049a5d28-b839-44b2-8cb3-1f199919dd23@googlegroups.com> |
| In reply to | #171813 |
On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: > Pete Olcott <Pete> writes: > > > On 2/3/2018 7:37 AM, Ben Bacarisse wrote: > >> Pete Olcott <Pete> writes: > <snip> > >>> Whether or not H^ actually executes infinite recursion is a different > >>> question. > >> > >> Actually it's the key question and the key to your error. You keep > >> saying (and you say it again below) that H^ really does execute > >> indefinitely rather than transitioning to qy or qn in a finite number of > > > > No I do not say this. I have said it before, I have retracted that now. > > Since I just retracted that above you must not be paying enough > > attention. > > Yes, it did look a bit like a retraction, but at no point did you > concede the key point. Saying "whether or not H^ actually executes > infinite recursion is a different question" just sounded like hedging > unless you state that H^ will *never* get stuck in a loop (before the > loop at the very end) and will, instead, *always* get to state qy > or qn. > > This is the key point and I would be very happy to see you that really > do now accept it. Could you be clear and state unequivocally that you > agree that H^ always gets to state qy or state qn in a finite number of > steps? > > This point is really the only one that matters. All the other errors > are just details in comparison. > > BTW, when did you last edit the blog post > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > > ? It's still wrong, but it's less wrong than I remember it being, > despite being dated Jan 18. > > <text removed> > -- > Ben. I spent over three hours very carefully responding to your objections and yet again you form your rebuttal without even looking at what I said. A Halt Decider must examine the execution trace of its input TMD to determine whether or not this TMD (if executed by a UTM) would halt or fail to halt on its input. What is your rebuttal?
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-04 00:44 +0000 |
| Message-ID | <87372hziqk.fsf@bsb.me.uk> |
| In reply to | #171815 |
peteolcott <peterolcott2@gmail.com> writes: > On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: >> Pete Olcott <Pete> writes: >> >> > On 2/3/2018 7:37 AM, Ben Bacarisse wrote: >> >> Pete Olcott <Pete> writes: >> <snip> >> >>> Whether or not H^ actually executes infinite recursion is a different >> >>> question. >> >> >> >> Actually it's the key question and the key to your error. You keep >> >> saying (and you say it again below) that H^ really does execute >> >> indefinitely rather than transitioning to qy or qn in a finite number of >> > >> > No I do not say this. I have said it before, I have retracted that now. >> > Since I just retracted that above you must not be paying enough >> > attention. >> >> Yes, it did look a bit like a retraction, but at no point did you >> concede the key point. Saying "whether or not H^ actually executes >> infinite recursion is a different question" just sounded like hedging >> unless you state that H^ will *never* get stuck in a loop (before the >> loop at the very end) and will, instead, *always* get to state qy >> or qn. >> >> This is the key point and I would be very happy to see you that really >> do now accept it. Could you be clear and state unequivocally that you >> agree that H^ always gets to state qy or state qn in a finite number of >> steps? >> >> This point is really the only one that matters. All the other errors >> are just details in comparison. >> >> BTW, when did you last edit the blog post >> >> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >> >> ? It's still wrong, but it's less wrong than I remember it being, >> despite being dated Jan 18. >> >> <text removed> > > I spent over three hours very carefully responding to your objections > and yet again you form your rebuttal without even looking at what I > said. No, I read it all and spent a long time (but less than three hours) addressing it point by point, but eventually I decided to delete all but the key point because so many of my answers consisted of sentences that started, "if you accept the main point above...". We can both end up spending a lot of time on small points that don't matter next to the big ones. All your other errors are incidental if you do not accept this key point. If you accept it, I will gladly go back and comment on anything else that still matters, but I can't see that there will be much left to discuss. If you don't accept it, I'm not sure how to make any more progress. Do you accept this key point or not? Does H^ always transition to state qy or qn, (in a finite number of steps) no matter what the input? > A Halt Decider must examine the execution trace of its input TMD to > determine whether or not this TMD (if executed by a UTM) would halt > or fail to halt on its input. > > What is your rebuttal? I would say that a halt decider must examine its input TMD to determine whether or not this TMD (if executed by a UTM) would halt or fail to halt on its input. (I'd rather tidy up the two "its input"s as well but let's just hope we both know which refers to which input.) My version is four words shorter and, crucially, I have not idea what you think you are adding with the extra words "... the execution trace of ...". They suggest you might be assuming something about how a decider must work rather that what its result must be, but maybe not. They may suggest that a halt decide must examine all of the trace (rather than just some of it) and the trouble with that is that the trace may not be finite. Can we agree on my words and if not, what is wrong with mine that is fixed by your four words? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-02-03 17:11 -0800 |
| Message-ID | <868287cc-e79e-4e73-819e-c203e8597621@googlegroups.com> |
| In reply to | #171820 |
On Saturday, February 3, 2018 at 6:44:22 PM UTC-6, Ben Bacarisse wrote: > peteolcott <peterolcott> writes: > > > On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: > >> Pete Olcott <Pete> writes: > >> > >> > On 2/3/2018 7:37 AM, Ben Bacarisse wrote: > >> >> Pete Olcott <Pete> writes: > >> <snip> > >> >>> Whether or not H^ actually executes infinite recursion is a different > >> >>> question. > >> >> > >> >> Actually it's the key question and the key to your error. You keep > >> >> saying (and you say it again below) that H^ really does execute > >> >> indefinitely rather than transitioning to qy or qn in a finite number of > >> > > >> > No I do not say this. I have said it before, I have retracted that now. > >> > Since I just retracted that above you must not be paying enough > >> > attention. > >> > >> Yes, it did look a bit like a retraction, but at no point did you > >> concede the key point. Saying "whether or not H^ actually executes > >> infinite recursion is a different question" just sounded like hedging > >> unless you state that H^ will *never* get stuck in a loop (before the > >> loop at the very end) and will, instead, *always* get to state qy > >> or qn. > >> > >> This is the key point and I would be very happy to see you that really > >> do now accept it. Could you be clear and state unequivocally that you > >> agree that H^ always gets to state qy or state qn in a finite number of > >> steps? > >> > >> This point is really the only one that matters. All the other errors > >> are just details in comparison. > >> > >> BTW, when did you last edit the blog post > >> > >> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > >> > >> ? It's still wrong, but it's less wrong than I remember it being, > >> despite being dated Jan 18. > >> > >> <text removed> > > > > I spent over three hours very carefully responding to your objections > > and yet again you form your rebuttal without even looking at what I > > said. > > No, I read it all and spent a long time (but less than three hours) > addressing it point by point, but eventually I decided to delete all but > the key point because so many of my answers consisted of sentences that > started, "if you accept the main point above...". We can both end up > spending a lot of time on small points that don't matter next to the big > ones. > OK good. > All your other errors are incidental if you do not accept this key > point. If you accept it, I will gladly go back and comment on anything > else that still matters, but I can't see that there will be much left to > discuss. If you don't accept it, I'm not sure how to make any more > progress. > > Do you accept this key point or not? Does H^ always transition to state > qy or qn, (in a finite number of steps) no matter what the input? That would of course depend on exactly how the unspecified states are encoded. The key issue here that you seem to fail to grasp is that from the states of H^ that are specified we can see that it is specified to examine an infinitely recursive set of inputs. I will explain more below. > > > A Halt Decider must examine the execution trace of its input TMD to > > determine whether or not this TMD (if executed by a UTM) would halt > > or fail to halt on its input. > > > > What is your rebuttal? > > I would say that a halt decider must examine its input TMD to determine > whether or not this TMD (if executed by a UTM) would halt or fail to > halt on its input. (I'd rather tidy up the two "its input"s as well but > let's just hope we both know which refers to which input.) > Get much more specific with this and you will see what I mean. As soon as you get 100% specific with this you will see what I am saying. It is the vague generalities that are preventing your comprehension. H would actually be able to see the entire execution trace of H^ including the unspecified steps, and it would have to base its decision of this whole execution trace. > My version is four words shorter and, crucially, I have not idea what > you think you are adding with the extra words "... the execution trace > of ...". > They suggest you might be assuming something about how a > decider must work rather that what its result must be, but maybe not. > They may suggest that a halt decide must examine all of the trace > (rather than just some of it) and the trouble with that is that the > trace may not be finite. Can we agree on my words and if not, what is > wrong with mine that is fixed by your four words? > > -- > Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-04 01:27 +0000 |
| Message-ID | <87r2q1y262.fsf@bsb.me.uk> |
| In reply to | #171824 |
peteolcott <peterolcott2@gmail.com> writes: > On Saturday, February 3, 2018 at 6:44:22 PM UTC-6, Ben Bacarisse wrote: >> peteolcott <peterolcott> writes: >> >> > On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: >> >> Pete Olcott <Pete> writes: >> >> >> >> > On 2/3/2018 7:37 AM, Ben Bacarisse wrote: >> >> >> Pete Olcott <Pete> writes: >> >> <snip> >> >> >>> Whether or not H^ actually executes infinite recursion is a different >> >> >>> question. >> >> >> >> >> >> Actually it's the key question and the key to your error. You keep >> >> >> saying (and you say it again below) that H^ really does execute >> >> >> indefinitely rather than transitioning to qy or qn in a finite number of >> >> > >> >> > No I do not say this. I have said it before, I have retracted that now. >> >> > Since I just retracted that above you must not be paying enough >> >> > attention. >> >> >> >> Yes, it did look a bit like a retraction, but at no point did you >> >> concede the key point. Saying "whether or not H^ actually executes >> >> infinite recursion is a different question" just sounded like hedging >> >> unless you state that H^ will *never* get stuck in a loop (before the >> >> loop at the very end) and will, instead, *always* get to state qy >> >> or qn. >> >> >> >> This is the key point and I would be very happy to see you that really >> >> do now accept it. Could you be clear and state unequivocally that you >> >> agree that H^ always gets to state qy or state qn in a finite number of >> >> steps? >> >> >> >> This point is really the only one that matters. All the other errors >> >> are just details in comparison. >> >> >> >> BTW, when did you last edit the blog post >> >> >> >> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >> >> >> >> ? It's still wrong, but it's less wrong than I remember it being, >> >> despite being dated Jan 18. >> >> >> >> <text removed> >> > >> > I spent over three hours very carefully responding to your objections >> > and yet again you form your rebuttal without even looking at what I >> > said. >> >> No, I read it all and spent a long time (but less than three hours) >> addressing it point by point, but eventually I decided to delete all but >> the key point because so many of my answers consisted of sentences that >> started, "if you accept the main point above...". We can both end up >> spending a lot of time on small points that don't matter next to the big >> ones. > > OK good. So what is your answer to that crucial question? Does H^ always transition to state qy or qn (in a finite number of steps) no matter what the input, or do you still maintain that H^ might never get to one of qy or qn? <text removed> (in an attempt to find out where you stand on this key issue.) -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Newberry <newberryxy@gmail.com> |
|---|---|
| Date | 2018-02-03 18:01 -0800 |
| Message-ID | <p55pht$mnh$1@dont-email.me> |
| In reply to | #171824 |
peteolcott wrote: > On Saturday, February 3, 2018 at 6:44:22 PM UTC-6, Ben Bacarisse wrote: >> peteolcott <peterolcott> writes: >> >>> On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: >>>> Pete Olcott <Pete> writes: >>>> >>>>> On 2/3/2018 7:37 AM, Ben Bacarisse wrote: >>>>>> Pete Olcott <Pete> writes: >>>> <snip> >>>>>>> Whether or not H^ actually executes infinite recursion is a different >>>>>>> question. >>>>>> >>>>>> Actually it's the key question and the key to your error. You keep >>>>>> saying (and you say it again below) that H^ really does execute >>>>>> indefinitely rather than transitioning to qy or qn in a finite number of >>>>> >>>>> No I do not say this. I have said it before, I have retracted that now. >>>>> Since I just retracted that above you must not be paying enough >>>>> attention. >>>> >>>> Yes, it did look a bit like a retraction, but at no point did you >>>> concede the key point. Saying "whether or not H^ actually executes >>>> infinite recursion is a different question" just sounded like hedging >>>> unless you state that H^ will *never* get stuck in a loop (before the >>>> loop at the very end) and will, instead, *always* get to state qy >>>> or qn. >>>> >>>> This is the key point and I would be very happy to see you that really >>>> do now accept it. Could you be clear and state unequivocally that you >>>> agree that H^ always gets to state qy or state qn in a finite number of >>>> steps? >>>> >>>> This point is really the only one that matters. All the other errors >>>> are just details in comparison. >>>> >>>> BTW, when did you last edit the blog post >>>> >>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ >>>> >>>> ? It's still wrong, but it's less wrong than I remember it being, >>>> despite being dated Jan 18. >>>> >>>> <text removed> >>> >>> I spent over three hours very carefully responding to your objections >>> and yet again you form your rebuttal without even looking at what I >>> said. >> >> No, I read it all and spent a long time (but less than three hours) >> addressing it point by point, but eventually I decided to delete all but >> the key point because so many of my answers consisted of sentences that >> started, "if you accept the main point above...". We can both end up >> spending a lot of time on small points that don't matter next to the big >> ones. >> > > OK good. > >> All your other errors are incidental if you do not accept this key >> point. If you accept it, I will gladly go back and comment on anything >> else that still matters, but I can't see that there will be much left to >> discuss. If you don't accept it, I'm not sure how to make any more >> progress. >> >> Do you accept this key point or not? Does H^ always transition to state >> qy or qn, (in a finite number of steps) no matter what the input? > > That would of course depend on exactly how the unspecified states are encoded. > The key issue here that you seem to fail to grasp is that from the states > of H^ that are specified we can see that it is specified to examine > an infinitely recursive set of inputs. I will explain more below. > >> >>> A Halt Decider must examine the execution trace of its input TMD to >>> determine whether or not this TMD (if executed by a UTM) would halt >>> or fail to halt on its input. >>> >>> What is your rebuttal? >> >> I would say that a halt decider must examine its input TMD to determine >> whether or not this TMD (if executed by a UTM) would halt or fail to >> halt on its input. (I'd rather tidy up the two "its input"s as well but >> let's just hope we both know which refers to which input.) >> > > Get much more specific with this and you will see what I mean. > As soon as you get 100% specific with this you will see what I am saying. > It is the vague generalities that are preventing your comprehension. > > H would actually be able to see the entire execution trace of H^ > including the unspecified steps, and it would have to base its > decision of this whole execution trace. There is a lot of confusion here. 1) First of all by "counter-example" in this context we obviously mean the self-referential, self-contradictory machine constructed from the postulated universal decider H, the "counter-example" having been contrived to say the opposite of what H says. 2) There does exist a bunch of sound, consistent machines that decide non-halting correctly in some cases such that these machines go into infinite recursion as you described when fed their own "counter-example." It is their way to avoid contradiction. 3) You CAN potentially conclude that the postulated universal decider H goes into infinite recursion. That of course contradicts the initial assumption, and thus proves that H cannot exist. It is nonsesnsical to claim that you can never reach a conclusion that contradicts the initial assumption. If it were so then you could never execute a proof by contradiction. You seem to think that the infinite recursion is the problem, and if you remove it the proof will not hold. Or that the proof by contradiction is invalid because it contradicts itself, or something like that. These ideas do not make hell of a lot of sense. >> My version is four words shorter and, crucially, I have not idea what >> you think you are adding with the extra words "... the execution trace >> of ...". >> They suggest you might be assuming something about how a >> decider must work rather that what its result must be, but maybe not. >> They may suggest that a halt decide must examine all of the trace >> (rather than just some of it) and the trouble with that is that the >> trace may not be finite. Can we agree on my words and if not, what is >> wrong with mine that is fixed by your four words? >> >> -- >> Ben. >
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-02-03 20:44 -0800 |
| Message-ID | <13f87ba8-ffff-44c0-9296-329d2fd20e3a@googlegroups.com> |
| In reply to | #171828 |
On Saturday, February 3, 2018 at 8:01:35 PM UTC-6, Newberry wrote: > peteolcott wrote: > > On Saturday, February 3, 2018 at 6:44:22 PM UTC-6, Ben Bacarisse wrote: > >> peteolcott <peterolcott> writes: > >> > >>> On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: > >>>> Pete Olcott <Pete> writes: > >>>> > >>>>> On 2/3/2018 7:37 AM, Ben Bacarisse wrote: > >>>>>> Pete Olcott <Pete> writes: > >>>> <snip> > >>>>>>> Whether or not H^ actually executes infinite recursion is a different > >>>>>>> question. > >>>>>> > >>>>>> Actually it's the key question and the key to your error. You keep > >>>>>> saying (and you say it again below) that H^ really does execute > >>>>>> indefinitely rather than transitioning to qy or qn in a finite number of > >>>>> > >>>>> No I do not say this. I have said it before, I have retracted that now. > >>>>> Since I just retracted that above you must not be paying enough > >>>>> attention. > >>>> > >>>> Yes, it did look a bit like a retraction, but at no point did you > >>>> concede the key point. Saying "whether or not H^ actually executes > >>>> infinite recursion is a different question" just sounded like hedging > >>>> unless you state that H^ will *never* get stuck in a loop (before the > >>>> loop at the very end) and will, instead, *always* get to state qy > >>>> or qn. > >>>> > >>>> This is the key point and I would be very happy to see you that really > >>>> do now accept it. Could you be clear and state unequivocally that you > >>>> agree that H^ always gets to state qy or state qn in a finite number of > >>>> steps? > >>>> > >>>> This point is really the only one that matters. All the other errors > >>>> are just details in comparison. > >>>> > >>>> BTW, when did you last edit the blog post > >>>> > >>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > >>>> > >>>> ? It's still wrong, but it's less wrong than I remember it being, > >>>> despite being dated Jan 18. > >>>> > >>>> <text removed> > >>> > >>> I spent over three hours very carefully responding to your objections > >>> and yet again you form your rebuttal without even looking at what I > >>> said. > >> > >> No, I read it all and spent a long time (but less than three hours) > >> addressing it point by point, but eventually I decided to delete all but > >> the key point because so many of my answers consisted of sentences that > >> started, "if you accept the main point above...". We can both end up > >> spending a lot of time on small points that don't matter next to the big > >> ones. > >> > > > > OK good. > > > >> All your other errors are incidental if you do not accept this key > >> point. If you accept it, I will gladly go back and comment on anything > >> else that still matters, but I can't see that there will be much left to > >> discuss. If you don't accept it, I'm not sure how to make any more > >> progress. > >> > >> Do you accept this key point or not? Does H^ always transition to state > >> qy or qn, (in a finite number of steps) no matter what the input? > > > > That would of course depend on exactly how the unspecified states are encoded. > > The key issue here that you seem to fail to grasp is that from the states > > of H^ that are specified we can see that it is specified to examine > > an infinitely recursive set of inputs. I will explain more below. > > > >> > >>> A Halt Decider must examine the execution trace of its input TMD to > >>> determine whether or not this TMD (if executed by a UTM) would halt > >>> or fail to halt on its input. > >>> > >>> What is your rebuttal? > >> > >> I would say that a halt decider must examine its input TMD to determine > >> whether or not this TMD (if executed by a UTM) would halt or fail to > >> halt on its input. (I'd rather tidy up the two "its input"s as well but > >> let's just hope we both know which refers to which input.) > >> > > > > Get much more specific with this and you will see what I mean. > > As soon as you get 100% specific with this you will see what I am saying. > > It is the vague generalities that are preventing your comprehension. > > > > H would actually be able to see the entire execution trace of H^ > > including the unspecified steps, and it would have to base its > > decision of this whole execution trace. > > There is a lot of confusion here. > > 1) First of all by "counter-example" in this context we obviously mean > the self-referential, self-contradictory machine constructed from the > postulated universal decider H, the "counter-example" having been > contrived to say the opposite of what H says. > And anyone not seeing this is dishonestly disingenuous. > 2) There does exist a bunch of sound, consistent machines that decide > non-halting correctly in some cases such that these machines go into > infinite recursion as you described when fed their own > "counter-example." It is their way to avoid contradiction. > > 3) You CAN potentially conclude that the postulated universal decider H > goes into infinite recursion. That of course contradicts the initial > assumption, and thus proves that H cannot exist. It is nonsesnsical to > claim that you can never reach a conclusion that contradicts the initial > assumption. If it were so then you could never execute a proof by > contradiction. > > You seem to think that the infinite recursion is the problem, and if you > remove it the proof will not hold. Or that the proof by contradiction is > invalid because it contradicts itself, or something like that. These > ideas do not make hell of a lot of sense. The sense of infinite recursion that invalidates the counter example is if something analogous to requiring a machine to count the number of characters in an infinite string is required to be accomplished in finite time then the problem definition itself is incorrect thus the lack of a solution is an error with the question, not the lack of a correct solution. > > >> My version is four words shorter and, crucially, I have not idea what > >> you think you are adding with the extra words "... the execution trace > >> of ...". > >> They suggest you might be assuming something about how a > >> decider must work rather that what its result must be, but maybe not. > >> They may suggest that a halt decide must examine all of the trace > >> (rather than just some of it) and the trouble with that is that the > >> trace may not be finite. Can we agree on my words and if not, what is > >> wrong with mine that is fixed by your four words? > >> > >> -- > >> Ben. > >
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-04 02:32 -0800 |
| Message-ID | <9d3673e4-5ac9-4b53-8070-10f90a0f982b@googlegroups.com> |
| In reply to | #171839 |
On Sunday, February 4, 2018 at 2:44:20 PM UTC+10, peteolcott wrote: > On Saturday, February 3, 2018 at 8:01:35 PM UTC-6, Newberry wrote: > > peteolcott wrote: > > > On Saturday, February 3, 2018 at 6:44:22 PM UTC-6, Ben Bacarisse wrote: > > >> peteolcott <peterolcott> writes: > > >> > > >>> On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: > > >>>> Pete Olcott <Pete> writes: > > >>>> > > >>>>> On 2/3/2018 7:37 AM, Ben Bacarisse wrote: > > >>>>>> Pete Olcott <Pete> writes: > > >>>> <snip> > > >>>>>>> Whether or not H^ actually executes infinite recursion is a different > > >>>>>>> question. > > >>>>>> > > >>>>>> Actually it's the key question and the key to your error. You keep > > >>>>>> saying (and you say it again below) that H^ really does execute > > >>>>>> indefinitely rather than transitioning to qy or qn in a finite number of > > >>>>> > > >>>>> No I do not say this. I have said it before, I have retracted that now. > > >>>>> Since I just retracted that above you must not be paying enough > > >>>>> attention. > > >>>> > > >>>> Yes, it did look a bit like a retraction, but at no point did you > > >>>> concede the key point. Saying "whether or not H^ actually executes > > >>>> infinite recursion is a different question" just sounded like hedging > > >>>> unless you state that H^ will *never* get stuck in a loop (before the > > >>>> loop at the very end) and will, instead, *always* get to state qy > > >>>> or qn. > > >>>> > > >>>> This is the key point and I would be very happy to see you that really > > >>>> do now accept it. Could you be clear and state unequivocally that you > > >>>> agree that H^ always gets to state qy or state qn in a finite number of > > >>>> steps? > > >>>> > > >>>> This point is really the only one that matters. All the other errors > > >>>> are just details in comparison. > > >>>> > > >>>> BTW, when did you last edit the blog post > > >>>> > > >>>> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > > >>>> > > >>>> ? It's still wrong, but it's less wrong than I remember it being, > > >>>> despite being dated Jan 18. > > >>>> > > >>>> <text removed> > > >>> > > >>> I spent over three hours very carefully responding to your objections > > >>> and yet again you form your rebuttal without even looking at what I > > >>> said. > > >> > > >> No, I read it all and spent a long time (but less than three hours) > > >> addressing it point by point, but eventually I decided to delete all but > > >> the key point because so many of my answers consisted of sentences that > > >> started, "if you accept the main point above...". We can both end up > > >> spending a lot of time on small points that don't matter next to the big > > >> ones. > > >> > > > > > > OK good. > > > > > >> All your other errors are incidental if you do not accept this key > > >> point. If you accept it, I will gladly go back and comment on anything > > >> else that still matters, but I can't see that there will be much left to > > >> discuss. If you don't accept it, I'm not sure how to make any more > > >> progress. > > >> > > >> Do you accept this key point or not? Does H^ always transition to state > > >> qy or qn, (in a finite number of steps) no matter what the input? > > > > > > That would of course depend on exactly how the unspecified states are encoded. > > > The key issue here that you seem to fail to grasp is that from the states > > > of H^ that are specified we can see that it is specified to examine > > > an infinitely recursive set of inputs. I will explain more below. > > > > > >> > > >>> A Halt Decider must examine the execution trace of its input TMD to > > >>> determine whether or not this TMD (if executed by a UTM) would halt > > >>> or fail to halt on its input. > > >>> > > >>> What is your rebuttal? > > >> > > >> I would say that a halt decider must examine its input TMD to determine > > >> whether or not this TMD (if executed by a UTM) would halt or fail to > > >> halt on its input. (I'd rather tidy up the two "its input"s as well but > > >> let's just hope we both know which refers to which input.) > > >> > > > > > > Get much more specific with this and you will see what I mean. > > > As soon as you get 100% specific with this you will see what I am saying. > > > It is the vague generalities that are preventing your comprehension. > > > > > > H would actually be able to see the entire execution trace of H^ > > > including the unspecified steps, and it would have to base its > > > decision of this whole execution trace. > > > > There is a lot of confusion here. > > > > 1) First of all by "counter-example" in this context we obviously mean > > the self-referential, self-contradictory machine constructed from the > > postulated universal decider H, the "counter-example" having been > > contrived to say the opposite of what H says. > > > > And anyone not seeing this is dishonestly disingenuous. Add 2 turing states to HALT (YES)---->(toggle)<----->(toggle) > > > 2) There does exist a bunch of sound, consistent machines that decide > > non-halting correctly in some cases such that these machines go into > > infinite recursion as you described when fed their own > > "counter-example." It is their way to avoid contradiction. You still get HOLES in the HALT TABLE H 1 2 3 4 1 0 0 0 0 2 1 1 [ ] <-------------- BLANK! 3 1 1 1 1 > > > > 3) You CAN potentially conclude that the postulated universal decider H > > goes into infinite recursion. SEE ABOVE! > > That of course contradicts the initial > > assumption, and thus proves that H cannot exist. It is nonsesnsical to > > claim that you can never reach a conclusion that contradicts the initial > > assumption. If it were so then you could never execute a proof by > > contradiction. > > > > You seem to think that the infinite recursion is the problem, and if you > > remove it the proof will not hold. Or that the proof by contradiction is > > invalid because it contradicts itself, or something like that. These > > ideas do not make hell of a lot of sense. > > The sense of infinite recursion that invalidates the counter example You have to AGREE with the ASSUMPTION before you ARGUE the counterexample > is if something analogous to requiring a machine to count the number > of characters in an infinite string is required to be accomplished in > finite time then the problem definition itself is incorrect thus the > lack of a solution is an error with the question, not the lack of a > correct solution. Yeh the assumption is contradicted. PETE STATE THE ASSUMPTION OF THE PROOF!
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-03 16:47 -0800 |
| Message-ID | <90c09d80-f8ff-4e2d-bc38-d2c7fb8b1967@googlegroups.com> |
| In reply to | #171815 |
On Sunday, February 4, 2018 at 10:03:44 AM UTC+10, peteolcott wrote: > On Saturday, February 3, 2018 at 5:49:36 PM UTC-6, Ben Bacarisse wrote: > > Pete Olcott <Pete> writes: > > > > > On 2/3/2018 7:37 AM, Ben Bacarisse wrote: > > >> Pete Olcott <Pete> writes: > > <snip> > > >>> Whether or not H^ actually executes infinite recursion is a different > > >>> question. > > >> > > >> Actually it's the key question and the key to your error. You keep > > >> saying (and you say it again below) that H^ really does execute > > >> indefinitely rather than transitioning to qy or qn in a finite number of > > > > > > No I do not say this. I have said it before, I have retracted that now. > > > Since I just retracted that above you must not be paying enough > > > attention. > > > > Yes, it did look a bit like a retraction, but at no point did you > > concede the key point. Saying "whether or not H^ actually executes > > infinite recursion is a different question" just sounded like hedging > > unless you state that H^ will *never* get stuck in a loop (before the > > loop at the very end) and will, instead, *always* get to state qy > > or qn. > > > > This is the key point and I would be very happy to see you that really > > do now accept it. Could you be clear and state unequivocally that you > > agree that H^ always gets to state qy or state qn in a finite number of > > steps? > > > > This point is really the only one that matters. All the other errors > > are just details in comparison. > > > > BTW, when did you last edit the blog post > > > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ > > > > ? It's still wrong, but it's less wrong than I remember it being, > > despite being dated Jan 18. > > > > <text removed> > > -- > > Ben. > > I spent over three hours very carefully responding to your objections > and yet again you form your rebuttal without even looking at what I said. > > A Halt Decider must examine the execution trace of its input TMD to > determine whether or not this TMD (if executed by a UTM) would halt > or fail to halt on its input. [WRONG!] A UTM(p i) must execute p(i) HALT(p i) just uses a similar/same program numbering > > What is your rebuttal? HALT is SPECIFIED to ANALYSE_ONLY its input!
[toc] | [prev] | [next] | [standalone]
| From | Peter Percival <peterxpercival@hotmail.com> |
|---|---|
| Date | 2018-02-02 14:12 +0000 |
| Message-ID | <p51rjl$h77$1@news.albasani.net> |
| In reply to | #171672 |
Pete Olcott wrote: > > OK F is not expressive enough to have a provability predicate so I will > use H. > > (G1) H ⊢ GH ↔ ¬ProvF(⌈GH⌉). > (G2) H ⊢ GH ↔ ¬ProvF(GH). > G2 is precisely analogous to G1 such that showing G2 is erroneous shows > that G1 is erroneous. --- I take it that ProvF is a provability predicate for some calculus, that GH is a formula in that calculus, and that ⌈GH⌉ is that formula's Gödel number. ProvF is unusual in that it takes both formulae and numbers as its argument. Could you outline a calculus in which that works? Could you, in particular, define ProvF? Or, if ProvF is a primitive could you say what axioms govern it? > G1 can include all of the original proof because H includes F as a subset. > G2 can be expressed 100,000-fold more simply thus not totally obscuring > key details. > >
[toc] | [prev] | [next] | [standalone]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-01-31 19:27 -0600 |
| Message-ID | <9ZydnX1I3peQ8O_HnZ2dnUU7-fHNnZ2d@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. > > 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. That assumption provide itself to be false. Once an assumption is proven to be false that assumption no longer holds. >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). If we assume that a machine TM1 defined to count the tape head movements of another machine TM2 halts, and this machine is instructed to count the tape head movements of another machine TM2 that does not halt, then our assumption is simply proven to be incorrect. If we assume that a finite string evaluation sequence is finite, yet this finite string evaluation sequence specifies infinite recursion then our assumption that the finite string evaluation sequence is finite is proven to be incorrect. > >>> 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. You know that is a lie. Quit lying. H^ must examine what w^ does this requires an examination of what w^2 does which requires an examination of what w^3 does... otherwise w^2 would simply transition to ((qn)) based on NULL input which would cause w^ to transition to (qy) which would cause H^ to transition to ((qn)) Thus H^ would correctly decide halting for w^ w^2. In either case the HP proof counter-example fails to be a counter-example. > > 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. > No you have simply not devoted a single-minded focus sufficiently to see that this is not the case. -- *∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-02-01 02:13 +0000 |
| Message-ID | <87po5pa245.fsf@bsb.me.uk> |
| In reply to | #171550 |
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. >> >> 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. > > That assumption provide itself to be false. Once an assumption is > proven to be false that assumption no longer holds. Exactly!! Bells ring out over the land. The people rejoice. The long winter of ignorance is over. (You do know how a proof be contradiction works, yes?) <snip> >>>> 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. > > You know that is a lie. Quit lying. No you appear not to know what the notation you are using means. If you did know you would write what you are claiming using that notation, but instead you keep writing what I am saying. It would be very much better if you would stop calling things you disagree with lies. Even convinced as you are that you know what that notation means, there is no reason to suppose that I am lying about what I think it means. > H^ must examine what w^ does > this requires an examination of what w^2 does > which requires an examination of what w^3 does... That is not what the notation says. The notation says what I keep telling you. It's not ambiguous. There is no room for misunderstanding. The |- with the * and the machine name are all quite clear. You keep saying (in symbols) that H^ always transitions from state qx to either state qy or state qn in a finite number of steps. Then you keep denying that in words despite saying it in symbols again and again. > otherwise w^2 would simply transition to ((qn)) based on NULL input > which would cause w^ to transition to (qy) > which would cause H^ to transition to ((qn)) > > Thus H^ would correctly decide halting for w^ w^2. > > In either case the HP proof counter-example fails to be a > counter-example. There is no counter-example. This is a proof by contradiction and you have agreed above that the assumption being posited for rejection must indeed be rejected. (You have an invalid argument for that rejection, but I am not going to quibble about that -- we both appear to agree now that assuming that H is a halt decider leads to a contradiction.) >> 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. > > No you have simply not devoted a single-minded focus sufficiently to > see that this is not the case. An educated reader can work out what the notation says in a few minutes. You keep writing two lines that say exactly what you are trying to deny. However long you have not spent on it you have not spent enough time to understand the symbol you are throwing about. It will vary from person to person how many hours are needed, but since it's not a complicated notation it might be worth your tying. Or would could keep writing out what I am saying in symbols whilst denying it in words. That looks bonkers to educated onlookers, but it suits me down to the ground. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-02-03 17:00 -0800 |
| Message-ID | <dae78f72-f547-4c6b-8152-f7ccb17959a1@googlegroups.com> |
| In reply to | #171144 |
>
> 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)).
>
> 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
>
> q0 to qx it copies its input ŵ to ŵ2
> after qx it evaluates its input ŵ ŵ2
>
> What would TMD ŵ do on its input ŵ2?
>
> q0 to qx ŵ would copy ŵ2 to ŵ3
> after qx ŵ would evaluate what ŵ2 do on its input ŵ3
> on and on infinitely recursive...
WRONG! (qx) is the start of the halt function
GIVEN scope(H)
H^ (w^)
--> H' (w^ w^)
--> H (w^ w^) ---->tail end of H'
--> if( w^(w^) ) halts ----> ...
OR
--> if( w^(w^) ) never halts ----> ...
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
from (qx) its possible to do an ANALYSIS on w^(w^)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[toc] | [prev] | [standalone]
Page 6 of 6 — ← Prev page 1 2 3 4 5 [6]
Back to top | Article view | sci.logic
csiph-web