Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > sci.logic > #171063 > unrolled thread

Re: Infinitely Recursive input on HP Proofs

Started byGeorge Greene <greeneg@email.unc.edu>
First post2018-01-25 20:26 -0800
Last post2018-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.


Contents

  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]


#171740

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-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]


#171758

FromPete Olcott <Pete@NoEmail.address>
Date2018-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]


#171759

Fromgrahamcooper7@gmail.com
Date2018-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]


#171767

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-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]


#171798

FromPete Olcott <Pete@NoEmail.address>
Date2018-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]


#171813

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-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]


#171815

Frompeteolcott <peterolcott2@gmail.com>
Date2018-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]


#171820

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-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]


#171824

Frompeteolcott <peterolcott2@gmail.com>
Date2018-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]


#171827

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-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]


#171828

FromNewberry <newberryxy@gmail.com>
Date2018-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]


#171839

Frompeteolcott <peterolcott2@gmail.com>
Date2018-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]


#171844

Fromgrahamcooper7@gmail.com
Date2018-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]


#171821

Fromgrahamcooper7@gmail.com
Date2018-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]


#171711

FromPeter Percival <peterxpercival@hotmail.com>
Date2018-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]


#171550

FromPete Olcott <Pete@NoEmail.address>
Date2018-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]


#171558

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-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]


#171823

Fromgrahamcooper7@gmail.com
Date2018-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