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 20 on this page of 118 — 9 participants

Back to article view | Back to sci.logic

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


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 1 of 6  [1] 2 3 4 5 6  Next page →


#171063 — Re: Infinitely Recursive input on HP Proofs

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-25 20:26 -0800
SubjectRe: Infinitely Recursive input on HP Proofs
Message-ID<2e1cdeec-20e3-4daf-847e-3ace1d409bbd@googlegroups.com>
Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
start a new thread ABOUT THOSE and stop talking in this one??

[toc] | [next] | [standalone]


#171072

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-25 21:49 -0800
Message-ID<f0574e29-2f51-453d-9e17-fdef3d0accd0@googlegroups.com>
In reply to#171063
On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> start a new thread ABOUT THOSE and stop talking in this one??

The only "rebuttal" talked about TMs calling other TMs and TMs 
returning values. Everyone that knows TMs knows that this is not 
the way that they work. 

Since I have already spent many years and thousands of hours on this 
since 2004, I know that I must utterly abandon talking about TM's 
as any higher level abstraction. 

http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ 

The top 1/3 of the page up to and including the first yellow highlighted
text is a mandatory prerequisite. Every single detail is utterly required.
It cannot be generalized or summarized at all. 

Don't lie and say that anyone has ever even entered the ballpark of 
providing any rebuttal what-so-ever. No one has even taken the very 
first step of understanding my initial basis. 

Anyone with a BSCS should be able to attain a 100% understanding
of the linked 1/3 page in less than five minutes. 

[toc] | [prev] | [next] | [standalone]


#171089

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-26 04:10 -0800
Message-ID<8e011275-bf3f-4598-a997-60476e235f5e@googlegroups.com>
In reply to#171072
On Friday, January 26, 2018 at 12:49:43 AM UTC-5, peteolcott wrote:
> On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> > Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> > start a new thread ABOUT THOSE and stop talking in this one??
> 
> The only "rebuttal" talked about TMs calling other TMs and TMs 
> returning values. Everyone that knows TMs knows that this is not 
> the way that they work. 

I repeat, this everyone DOES NOT INCLUDE YOU.
MY GOD, are you going to allege that BB, PP, and EVERY OTHER TEXTBOOK THAT EXPLAINS HOW one TM calls another is WRONG?  And yet you and "everyone" are still right, that "everyone" does not include all this?

YOUR OWN TREATMENT says that from a certain point, H^ BEHAVES LIKE H'.
EVEN IF YOU WON'T CONCEDE that that is "calling H' ", that STILL MEANS
THAT I AM RIGHT AND YOU ARE WRONG, and that STILL CONSTITUTES a rebuttal
of your claim that H^ (and H', by extension, since what H^ is doing after
doubling its input is, after all, only and exactly THE SAME thing that
H' WOULD be doing on that doubled input IF IT had been called with this
w^,w^ input) is "executing w^" and re-performing the copying!
J' *DOES*NOT* execute w^!  In the first place, w^ CAN"T be executed because IT
is not a TM!  It is the code-string of H^, so it is H^ that would be again
getting executed! for the Nth time, the TM itself NEEDS to be though of
AS SOFTWARE, NOT hardware, in this AND ALL situations!  If you want to speak
AT A HIGHER LEVEL OF ABSTRACTION, as you wrongly claim you don't, then yes,
OF COURSE, ONE COULD say by overloading/extension that one can "execute a string" by INTERPRETING IT AS A CODE FOR A TM PROGRAM and emulating THAT tm
as opposed to behaving some other way, BUT EVEN IF WE CONCEDE THAT THAT IS
HAPPENING, *again*, the FIRST thing H' does IS NOT emulate the execution of
w^=H^ -- the FIRST thing H' does IS CALL H!  That is NOT just according to ME!
YOUR OWN TREATMENT AND DIAGRAM shows the program for H' *BEGINNING*WITH*
the program FOR *H*!!  So NOTHING HAS BEGUN TO RE-COPY ANY INPUT YET!
After doubling its input
H^ EMULATES H', WHICH IN TURN BEGINS by emulating *H*.
SO THE ONLY way any input is going to get re-copied is
IF H
decides to emulate w^=H^.  WHICH IT WON'T, because H is defined
AS ALWAYS HALTING, and H DOESN'T KNOW YET whether H^(w^) WILL OR WON'T
halt!  H DOES NOT DARE actually INVOKE or emulate H^ on w^ because IF it
should turn out that that loops, H WILL NEVER RETURN TO TELL YOU!
H will be STUCK IN THE SAME loop that H^(w^) is in!
SO
H
DOESN'T
*DO*
*THAT*,
*D*U*M*B*A*S*S*.

[toc] | [prev] | [next] | [standalone]


#171096

FromPete Olcott <Pete@NoEmail.address>
Date2018-01-26 11:37 -0600
Message-ID<A6-dncbHSYLy-vbHnZ2dnUU7-VfNnZ2d@giganews.com>
In reply to#171089
On 1/26/2018 6:10 AM, George Greene wrote:
> On Friday, January 26, 2018 at 12:49:43 AM UTC-5, peteolcott wrote:
>> On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
>>> Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
>>> start a new thread ABOUT THOSE and stop talking in this one??
>>
>> The only "rebuttal" talked about TMs calling other TMs and TMs
>> returning values. Everyone that knows TMs knows that this is not
>> the way that they work.
> 
> I repeat, this everyone DOES NOT INCLUDE YOU.
> MY GOD, are you going to allege that BB, PP, and EVERY OTHER TEXTBOOK THAT EXPLAINS HOW one TM calls another is WRONG?  And yet you and "everyone" are still right, that "everyone" does not include all this?
> 
> YOUR OWN TREATMENT says that from a certain point, H^ BEHAVES LIKE H'.

That is not my own treatment that is the author's explanation that I
quoted to confirm that he was talking about H^ and not H'

> EVEN IF YOU WON'T CONCEDE that that is "calling H' ", that STILL MEANS

TMs do not call other TMs that is not the way that they work.
You either know this and are lying or do not have an MSCS.

> THAT I AM RIGHT AND YOU ARE WRONG, and that STILL CONSTITUTES a rebuttal
> of your claim that H^ (and H', by extension, since what H^ is doing after
> doubling its input is, after all, only and exactly THE SAME thing that
> H' WOULD be doing on that doubled input IF IT had been called with this
> w^,w^ input) is "executing w^" and re-performing the copying!

That sounds reasonable.

> J' *DOES*NOT* execute w^!  In the first place, w^ CAN"T be executed because IT

There is no J'

> is not a TM!  It is the code-string of H^, so it is H^ that would be again

A UTM could execute it, if H^ is a UTM then w^ could be executed.

> getting executed! for the Nth time, the TM itself NEEDS to be though of
> AS SOFTWARE, NOT hardware, in this AND ALL situations!  If you want to speak

This aspect makes no difference. The aspect that makes a difference
is glossing over key details such as the details of state transitions.

> AT A HIGHER LEVEL OF ABSTRACTION, as you wrongly claim you don't, then yes,
> OF COURSE, ONE COULD say by overloading/extension that one can "execute a string" by INTERPRETING IT AS A CODE FOR A TM PROGRAM and emulating THAT tm
> as opposed to behaving some other way, BUT EVEN IF WE CONCEDE THAT THAT IS

UTMs can already execute TMDs and this is not a high level abstraction.
We still have reading a tape element, writing a tape element, moving
the tape head, transitioning to another state.

> HAPPENING, *again*, the FIRST thing H' does IS NOT emulate the execution of
> w^=H^ -- the FIRST thing H' does IS CALL H!  That is NOT just according to ME!

No TM ever calls another TM this is a high level abstraction figure of
speech. It is still always only a matter of moving the tape head
reading / writing tape elements and transitioning to a next state based
on the current state and the currently read tape element.

> YOUR OWN TREATMENT AND DIAGRAM shows the program for H' *BEGINNING*WITH*
> the program FOR *H*!!  So NOTHING HAS BEGUN TO RE-COPY ANY INPUT YET!

No it does not that is a flat out falsehood.
My diagram defines H^ showing that its initial tape element is the
first character of w^.

http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/

> After doubling its input
> H^ EMULATES H', WHICH IN TURN BEGINS by emulating *H*.

H^ never emulates H' it has its own set of states some of which
correspond to H's states.

> SO THE ONLY way any input is going to get re-copied is
> IF H
> decides to emulate w^=H^.  

Now we are finally getting to the interesting part. With all of your
dodges it seemed like you wanted to avoid talking about the interesting
part.

It is true that the only way that w^ is actually going to be recopied
is if H^ actually executes the TMD w^. H^ could do this if H^ is a UTM.

> WHICH IT WON'T, because H is defined
> AS ALWAYS HALTING, and H DOESN'T KNOW YET whether H^(w^) WILL OR WON'T
> halt!  H DOES NOT DARE actually INVOKE or emulate H^ on w^ because IF it
> should turn out that that loops, H WILL NEVER RETURN TO TELL YOU!
> H will be STUCK IN THE SAME loop that H^(w^) is in!
> SO
> H
> DOESN'T
> *DO*
> *THAT*,
> *D*U*M*B*A*S*S*.
> 

That whole last paragraph was correct except that I am a genius
rather than a dumbass.

H^ is supposed to evaluate w^ and decide Halting or non Halting
for w^. The problem that I first discovered August 2016,
(after spending about 3000 hours on this since 2004) is that
the detailed step by step analysis of H^ analyzing w^ indicates
that the evaluation sequence itself has an infinite length.

This point is very very subtle. I would have never noticed it
if I did not detect the same problem with the Liar Paradox.

The evaluation of the Liar Paradox and the HP proof counter-example
both specify an infinitely recursive evaluation sequence.

My Facebook friend Scott Brizel got me looking at the Truth teller
paradox in July 20, 2016. This was the key that lead to all of my
other insights.

"This sentence is True" lacks the paradoxical adaptation of the
Liar Paradox and the HP proof, yet still cannot be evaluated to
either True of False.

"This sentence is True"
What is it True about?
It is True about being True.
What is it "True about being True" about?
It is True about being True about being True.

The HP proof has this same infinite recursion before it even gets
to states (qy) or (qn).

It is not the modified (qy)--->(qa) infinite loop that makes it
undecidable.

The evaluation sequence of H^ is stuck in infinite recursion  between
states (qx) and (q0) and thus never reaches either state (qy) or (qn).

Every HP proof has this same problem.

Between (q0) and (qx) H^ copies its input w^ to w^2
After (qx) H^ evaluates what w^ would do on its input w^2.

Between (q0) and (qx) w^ would copy its input w^2 to w^3
After (qx) w^ would evaluate what w^2 would do on its input w^3.

Between (q0) and (qx) w^2 would copy its input w^3 to w^4
After (qx) w^2 would evaluate what w^3 would do on its input w^4.

It might be easier to see this as a math problem rather than a computer science problem:

If we go straight out David Hilbert on this:
    "statements of mathematics and logic can be
    considered to be statements about the consequences
    of certain string manipulation rules."

Then we have this Math version of the Halting Problem
∃x ∈ Turing_Machine_Descriptions
∀y ∈ Turing_Machine_Descriptions
∀z ∈ Finite_Strings Halts(x, y, z)

Specifying the syntax of self-reference semantics:
The <ASSIGN_ALIAS> operator: "≡"
LHS is assigned as an alias name for the RHS
LHS ≡ RHS
The LHS is logically equivalent to the RHS ONLY Because
the LHS is merely an alias name for the RHS

When we evaluate the following expression of
HOL (with self-reference semantics):
H^ ≡ Halts(H^)

The translation of this expression into a directed acyclic
graph indicates that this expression is recursive and yet
lacks any recursion termination condition.
00 Halts (00)

"5 > 3" is translated into to directed acyclic graph
00 Greater_Than
01 Five
02 Three


Copyright 2016, 2017, 2018 Pete Olcott

-- 
*∀X True(X) ↔ ∃Γ ⊆ Axioms Provable(Γ, X) *

[toc] | [prev] | [next] | [standalone]


#171124

Fromgrahamcooper7@gmail.com
Date2018-01-26 15:12 -0800
Message-ID<9d2b63a5-d2bf-4375-9fd9-edebcbd21fc3@googlegroups.com>
In reply to#171096
On Saturday, January 27, 2018 at 4:37:58 AM UTC+11, Pete Olcott wrote:
> On 1/26/2018 6:10 AM, George Greene wrote:
> > On Friday, January 26, 2018 at 12:49:43 AM UTC-5, peteolcott wrote:
> >> On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> >>> Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> >>> start a new thread ABOUT THOSE and stop talking in this one??
> >>
> >> The only "rebuttal" talked about TMs calling other TMs and TMs
> >> returning values. Everyone that knows TMs knows that this is not
> >> the way that they work.
> > 
> > I repeat, this everyone DOES NOT INCLUDE YOU.
> > MY GOD, are you going to allege that BB, PP, and EVERY OTHER TEXTBOOK THAT EXPLAINS HOW one TM calls another is WRONG?  And yet you and "everyone" are still right, that "everyone" does not include all this?
> > 
> > YOUR OWN TREATMENT says that from a certain point, H^ BEHAVES LIKE H'.
> 
> That is not my own treatment that is the author's explanation that I
> quoted to confirm that he was talking about H^ and not H'
> 
> > EVEN IF YOU WON'T CONCEDE that that is "calling H' ", that STILL MEANS
> 
> TMs do not call other TMs that is not the way that they work.
> You either know this and are lying or do not have an MSCS.
> 
> > THAT I AM RIGHT AND YOU ARE WRONG, and that STILL CONSTITUTES a rebuttal
> > of your claim that H^ (and H', by extension, since what H^ is doing after
> > doubling its input is, after all, only and exactly THE SAME thing that
> > H' WOULD be doing on that doubled input IF IT had been called with this
> > w^,w^ input) is "executing w^" and re-performing the copying!
> 
> That sounds reasonable.
> 
> > J' *DOES*NOT* execute w^!  In the first place, w^ CAN"T be executed because IT
> 
> There is no J'
> 
> > is not a TM!  It is the code-string of H^, so it is H^ that would be again
> 
> A UTM could execute it, if H^ is a UTM then w^ could be executed.
> 
> > getting executed! for the Nth time, the TM itself NEEDS to be though of
> > AS SOFTWARE, NOT hardware, in this AND ALL situations!  If you want to speak
> 
> This aspect makes no difference. The aspect that makes a difference
> is glossing over key details such as the details of state transitions.
> 
> > AT A HIGHER LEVEL OF ABSTRACTION, as you wrongly claim you don't, then yes,
> > OF COURSE, ONE COULD say by overloading/extension that one can "execute a string" by INTERPRETING IT AS A CODE FOR A TM PROGRAM and emulating THAT tm
> > as opposed to behaving some other way, BUT EVEN IF WE CONCEDE THAT THAT IS
> 
> UTMs can already execute TMDs and this is not a high level abstraction.
> We still have reading a tape element, writing a tape element, moving
> the tape head, transitioning to another state.
> 
> > HAPPENING, *again*, the FIRST thing H' does IS NOT emulate the execution of
> > w^=H^ -- the FIRST thing H' does IS CALL H!  That is NOT just according to ME!
> 
> No TM ever calls another TM this is a high level abstraction figure of
> speech. It is still always only a matter of moving the tape head
> reading / writing tape elements and transitioning to a next state based
> on the current state and the currently read tape element.
> 
> > YOUR OWN TREATMENT AND DIAGRAM shows the program for H' *BEGINNING*WITH*
> > the program FOR *H*!!  So NOTHING HAS BEGUN TO RE-COPY ANY INPUT YET!
> 
> No it does not that is a flat out falsehood.
> My diagram defines H^ showing that its initial tape element is the
> first character of w^.
> 
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> 
> > After doubling its input
> > H^ EMULATES H', WHICH IN TURN BEGINS by emulating *H*.
> 
> H^ never emulates H' it has its own set of states some of which
> correspond to H's states.
> 
> > SO THE ONLY way any input is going to get re-copied is
> > IF H
> > decides to emulate w^=H^.  
> 
> Now we are finally getting to the interesting part. With all of your
> dodges it seemed like you wanted to avoid talking about the interesting
> part.
> 
> It is true that the only way that w^ is actually going to be recopied
> is if H^ actually executes the TMD w^. H^ could do this if H^ is a UTM.
> 
> > WHICH IT WON'T, because H is defined
> > AS ALWAYS HALTING, and H DOESN'T KNOW YET whether H^(w^) WILL OR WON'T
> > halt!  H DOES NOT DARE actually INVOKE or emulate H^ on w^ because IF it
> > should turn out that that loops, H WILL NEVER RETURN TO TELL YOU!
> > H will be STUCK IN THE SAME loop that H^(w^) is in!
> > SO
> > H
> > DOESN'T
> > *DO*
> > *THAT*,
> > *D*U*M*B*A*S*S*.
> > 
> 
> That whole last paragraph was correct except that I am a genius
> rather than a dumbass.
> 
> H^ is supposed to evaluate w^ and decide Halting or non Halting
> for w^. The problem that I first discovered August 2016,
> (after spending about 3000 hours on this since 2004) is that
> the detailed step by step analysis of H^ analyzing w^ indicates
> that the evaluation sequence itself has an infinite length.
> 
> This point is very very subtle. I would have never noticed it
> if I did not detect the same problem with the Liar Paradox.
> 
> The evaluation of the Liar Paradox and the HP proof counter-example
> both specify an infinitely recursive evaluation sequence.
> 
> My Facebook friend Scott Brizel got me looking at the Truth teller
> paradox in July 20, 2016. This was the key that lead to all of my
> other insights.
> 
> "This sentence is True" lacks the paradoxical adaptation of the
> Liar Paradox and the HP proof, yet still cannot be evaluated to
> either True of False.
> 
> "This sentence is True"
> What is it True about?
> It is True about being True.
> What is it "True about being True" about?
> It is True about being True about being True.
> 
> The HP proof has this same infinite recursion before it even gets
> to states (qy) or (qn).



H' has the same infinite recursion ASSUMING H exists.



H' if H(i,i) then goto H'




You DOUBLE PROVED HP by Syntactic Analysis of the Corrolory of the Hypothesis

rather than just showing a Contradiction.




H 1 2 3   <---- input tape
1
2
3

^
|
TM



All TMs halt==1 or never halt==0

NO TM can populate all H values






We dont mind H' NOT EXISTING!   That was the PROOF by CONTRADICTION!

[toc] | [prev] | [next] | [standalone]


#171091

Fromgrahamcooper7@gmail.com
Date2018-01-26 05:34 -0800
Message-ID<0350f82c-23a8-40fc-afdc-912788c358df@googlegroups.com>
In reply to#171072
On Friday, January 26, 2018 at 4:49:43 PM UTC+11, peteolcott wrote:
> On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> > Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> > start a new thread ABOUT THOSE and stop talking in this one??
> 
> The only "rebuttal" talked about TMs calling other TMs and TMs 
> returning values. Everyone that knows TMs knows that this is not 
> the way that they work. 
> 
> Since I have already spent many years and thousands of hours on this 
> since 2004, I know that I must utterly abandon talking about TM's 
> as any higher level abstraction. 
> 
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ 
> 
> The top 1/3 of the page up to and including the first yellow highlighted
> text is a mandatory prerequisite. Every single detail is utterly required.
> It cannot be generalized or summarized at all. 
> 
> Don't lie and say that anyone has ever even entered the ballpark of 
> providing any rebuttal what-so-ever. No one has even taken the very 
> first step of understanding my initial basis. 
> 
> Anyone with a BSCS should be able to attain a 100% understanding
> of the linked 1/3 page in less than five minutes.



Do we have to click on the link too?



Refutation of Halting Problem Proof
 

http://liarparadox.org/HP_Infinite_Recursion.pdf
 The following is based on the material from the above link:




the point is: HP is not solvable


H inputs a TM number and 1 more number to go on the tape


H 1 2 3 <--- tape
1
2
3

^
|
TM


If EVERY TM halts OR never halts

then there EXISTS in some platonic way, a 1 or 0 for the FULL TABLE !


H 1 3 4
1 0 0 0
2 1 1 1
3 1 0 0


TM1 is a dud!
TM2 works
TM3 works on some inputs


The problem is no H exists as a Turing Machine to compute those values




So you cant argue HALT() function exists!


So what is your argument, HALT() doesn't exist or HALT() isn't specified.


[toc] | [prev] | [next] | [standalone]


#171144

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-26 20:33 -0800
Message-ID<9feba92e-4de4-499b-b402-08cee38272c1@googlegroups.com>
In reply to#171091
On Friday, January 26, 2018 at 7:34:47 AM UTC-6, graham...@gmail.com wrote:
> On Friday, January 26, 2018 at 4:49:43 PM UTC+11, peteolcott wrote:
> > On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> > > Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> > > start a new thread ABOUT THOSE and stop talking in this one??
> > 
> > The only "rebuttal" talked about TMs calling other TMs and TMs 
> > returning values. Everyone that knows TMs knows that this is not 
> > the way that they work. 
> > 
> > Since I have already spent many years and thousands of hours on this 
> > since 2004, I know that I must utterly abandon talking about TM's 
> > as any higher level abstraction. 
> > 
> > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ 
> > 
> > The top 1/3 of the page up to and including the first yellow highlighted
> > text is a mandatory prerequisite. Every single detail is utterly required.
> > It cannot be generalized or summarized at all. 
> > 
> > Don't lie and say that anyone has ever even entered the ballpark of 
> > providing any rebuttal what-so-ever. No one has even taken the very 
> > first step of understanding my initial basis. 
> > 
> > Anyone with a BSCS should be able to attain a 100% understanding
> > of the linked 1/3 page in less than five minutes.
> 
> 
> 
> Do we have to click on the link too?
> 

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... 

[toc] | [prev] | [next] | [standalone]


#171158

Fromgrahamcooper7@gmail.com
Date2018-01-27 05:05 -0800
Message-ID<27a0a5a9-1594-442b-be86-6ea3311e2da1@googlegroups.com>
In reply to#171144
On Saturday, January 27, 2018 at 2:33:44 PM UTC+10, peteolcott wrote:
> On Friday, January 26, 2018 at 7:34:47 AM UTC-6, graham...@gmail.com wrote:
> > On Friday, January 26, 2018 at 4:49:43 PM UTC+11, peteolcott wrote:
> > > On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> > > > Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> > > > start a new thread ABOUT THOSE and stop talking in this one??
> > > 
> > > The only "rebuttal" talked about TMs calling other TMs and TMs 
> > > returning values. Everyone that knows TMs knows that this is not 
> > > the way that they work. 
> > > 
> > > Since I have already spent many years and thousands of hours on this 
> > > since 2004, I know that I must utterly abandon talking about TM's 
> > > as any higher level abstraction. 
> > > 
> > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ 
> > > 
> > > The top 1/3 of the page up to and including the first yellow highlighted
> > > text is a mandatory prerequisite. Every single detail is utterly required.
> > > It cannot be generalized or summarized at all. 
> > > 
> > > Don't lie and say that anyone has ever even entered the ballpark of 
> > > providing any rebuttal what-so-ever. No one has even taken the very 
> > > first step of understanding my initial basis. 
> > > 
> > > Anyone with a BSCS should be able to attain a 100% understanding
> > > of the linked 1/3 page in less than five minutes.
> > 
> > 
> > 
> > Do we have to click on the link too?
> > 
> 
> 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...




Are you talking about LOOPS(X) ?


HALT(T,i) = 1  ....... iff t(i) halts


function loops(T)
   if !halt(T,T) then EXIT
   GOTO LOOPS



halt(loops,loops) gets the wrong answer ... or keeps recursing


Thats all the proof is!






----------------- in DETAIL -------------------


TM-add( a b ) 

--------------------------
0000011011100000
--------------------------

v

--------------------------
0000011111110000
--------------------------


OK?   2+3=5





Now we can CONSTRUCT TM-twice(a)



TM-duplicate

---------------------------
0000001110000000000
---------------------------

v

---------------------------
0000001110111000000
---------------------------



CONNECT the FINAL STATE of TM-duplicate

to the START STATE of TM-add()




TM-add

v


---------------------------
000000111111000000
---------------------------




twice(a) = add(duplicate(a))

twice(3) = add(duplicate(3))

twice(3) = add(3 3)

twice(3) = 6





OK?   You have to PREPEND some TURING STATES to HALT to get LOOPS


THEN... you ADD MORE TURING STATES in place of the HALT FINAL STATE ?






DUPLICATE --->[F]=[S]-----HALT-----[F]=[S]-----SWITCH----[F]



Then SWITCH is ANOTHER SIMPLE TURING MACHINE that changes 0 to 1 and 1 to 0.




SIMPLE TURING MACHINE ---> HALT ---> SIMPLE TURING MACHINE



it is inevitable...

[toc] | [prev] | [next] | [standalone]


#171174

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-27 06:57 -0800
Message-ID<0e888b85-ed58-4917-a5ab-57e66fff5d1a@googlegroups.com>
In reply to#171158
On Saturday, January 27, 2018 at 7:05:23 AM UTC-6, graham...@gmail.com wrote:
> On Saturday, January 27, 2018 at 2:33:44 PM UTC+10, peteolcott wrote:
> > On Friday, January 26, 2018 at 7:34:47 AM UTC-6, graham...@gmail.com wrote:
> > > On Friday, January 26, 2018 at 4:49:43 PM UTC+11, peteolcott wrote:
> > > > On Thursday, January 25, 2018 at 10:26:55 PM UTC-6, George Greene wrote:
> > > > > Since the title of this thread is clearly false and has been clearly rebutted, and the current replies are about other subjects altogether, could somebody please
> > > > > start a new thread ABOUT THOSE and stop talking in this one??
> > > > 
> > > > The only "rebuttal" talked about TMs calling other TMs and TMs 
> > > > returning values. Everyone that knows TMs knows that this is not 
> > > > the way that they work. 
> > > > 
> > > > Since I have already spent many years and thousands of hours on this 
> > > > since 2004, I know that I must utterly abandon talking about TM's 
> > > > as any higher level abstraction. 
> > > > 
> > > > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ 
> > > > 
> > > > The top 1/3 of the page up to and including the first yellow highlighted
> > > > text is a mandatory prerequisite. Every single detail is utterly required.
> > > > It cannot be generalized or summarized at all. 
> > > > 
> > > > Don't lie and say that anyone has ever even entered the ballpark of 
> > > > providing any rebuttal what-so-ever. No one has even taken the very 
> > > > first step of understanding my initial basis. 
> > > > 
> > > > Anyone with a BSCS should be able to attain a 100% understanding
> > > > of the linked 1/3 page in less than five minutes.
> > > 
> > > 
> > > 
> > > Do we have to click on the link too?
> > > 
> > 
> > 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...
> 
> 
> 
> 
> Are you talking about LOOPS(X) ?
> 

http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/

No I am only taking about the above machine. There is no LOOPS(X). 
There is a state transition to (qy).

[toc] | [prev] | [next] | [standalone]


#171202

Fromgrahamcooper7@gmail.com
Date2018-01-27 13:53 -0800
Message-ID<90061536-49e0-46a9-bf2d-f13b388d4c39@googlegroups.com>
In reply to#171174
On Sunday, January 28, 2018 at 12:58:02 AM UTC+10, peteolcott wrote:
>
> > Are you talking about LOOPS(X) ?
> > 
> 
> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> 
> No I am only taking about the above machine. There is no LOOPS(X). 
> There is a state transition to (qy).




Its almost the same!


HALT


[START]-----> [YES]
 |
 |
 |
 v
[NO]





H'

[S]----->[YES]---->(toggle)<---->(toggle)
 |
 |
 |
 v
[NO] ... (STOPS)




H^

[S]
 |
 |  --------   
 |  00110000 -----> 001101100
 |  --------
 |
 |
 V
[S]----->[YES]---->(toggle)<---->(toggle)
 |
 |
 |
 v
[NO] ... (STOPS)






DUPLICATE
   |
   |
   |
  HALT ------> TOGGLE
   |
   |
   |
   V
  STOP




then FROM HALT

you get LOOPS




just like FROM ADD

you get TWICE

[toc] | [prev] | [next] | [standalone]


#171196

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-01-27 20:24 +0000
Message-ID<87efmbhwxi.fsf@bsb.me.uk>
In reply to#171144
peteolcott <peterolcott2@gmail.com> writes:
<snip>
> No you only need to trace the evaluation sequence of H^ to see that
> it gets stuck in infinite recursion after state (qx). It never even 
> reaches state (qy) or ((qn)). 
>
> 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

(Since you want to be formal, you should know that this is not the
definition of TM.  What's more, by naming the input w^ you are showing a
particular trace of H^.  It would be clearer to show the general form of
traces of H^ and then discuss the specific case of q0 w^.)

> q0 to qx it copies its input ŵ to ŵ2
> after qx it evaluates its input ŵ ŵ2

No.  You do not know exactly what H^ does from state qx onward.  You
certainly can't say it "evaluates" its input.  That's a vague term but
whatever it means you can't be right because all you know about H^ from
this point in is that it behaves like H' (and thus like H until the very
end of the trace).

You have made an unwarranted assumption about what H^ does from state q0
onwards and are ignoring the only thing you *can* know about that part
of the trace.  Because H is supposedly a decider (what it decides does
not even matter at this point) we know that the trace absolutely does
eventually lead to state qy or state qn (as, indeed, you wrote above).

The one thing that *can't* happen is "looping" before H^ gets to qy or
qn and of course we know exactly what happens *then* because of how H^
was constructed.

> 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...

This is the only thing we know can't happen!

Of course we can get such looping for some machines, specifically those
that do meet your unwarranted assumption.  But they are ruled by the
first line of this proof which should be "Assume H is a halting
decider".  No machine that "evaluates" its input (by which I think you
mean that it runs the machine description it's given) can be a halting
decider, and any machine that is a decider will eventually halt so H^
must transition from qx to either qy or qn at some point.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#171199

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-27 13:03 -0800
Message-ID<283dd089-35ff-4b05-a1e8-a8a8373a59c0@googlegroups.com>
In reply to#171196
On Saturday, January 27, 2018 at 2:24:45 PM UTC-6, Ben Bacarisse wrote:
> peteolcott writes:
> <snip>
> > No you only need to trace the evaluation sequence of H^ to see that
> > it gets stuck in infinite recursion after state (qx). It never even 
> > reaches state (qy) or ((qn)). 
> >
> > 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
> 
> (Since you want to be formal, you should know that this is not the
> definition of TM.  What's more, by naming the input w^ you are showing a
> particular trace of H^.  It would be clearer to show the general form of
> traces of H^ and then discuss the specific case of q0 w^.)

I am merely compressing the Linz steps for simplicity. 
After he has pieces everything together he ends up with H^ w^. 

> 
> > q0 to qx it copies its input ŵ to ŵ2
> > after qx it evaluates its input ŵ ŵ2
> 
> No.  You do not know exactly what H^ does from state qx onward.  You
> certainly can't say it "evaluates" its input.  

From a David Hilbert Formalism pure math POV the entire process 
is the evaluation of finite strings H^ w^. 

> That's a vague term but
> whatever it means you can't be right because all you know about H^ from
> this point in is that it behaves like H' (and thus like H until the very
> end of the trace).
> 

From a pure math POV it is not vague at all. 

> You have made an unwarranted assumption about what H^ does from state q0
> onwards 

Not at all the authors defines exactly what happens between states
q0 and qx, H^ copies w^.

> and are ignoring the only thing you *can* know about that part
> of the trace.  Because H is supposedly a decider (what it decides does
> not even matter at this point) we know that the trace absolutely does
> eventually lead to state qy or state qn (as, indeed, you wrote above).

Because the mathematical formalism of the evaluation of the finite
string pair H^ w^ specifies a mathematical evaluation that is infinitely recursive. This mathematical evalution of these finite strings never
reaches either state qn or qy. 

> 
> The one thing that *can't* happen is "looping" before H^ gets to qy or
> qn and of course we know exactly what happens *then* because of how H^
> was constructed.

Like myself and many thousands of people before me you still fail to
notice the infinite recursion of the mathematical evaluation of the
finite strings H^ and w^, after state qx. 

> 
> > 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...
> 
> This is the only thing we know can't happen!

From a mathematical formalism POV it must necessarily happen because it 
is defined to happen. 

> 
> Of course we can get such looping for some machines, specifically those
> that do meet your unwarranted assumption.  But they are ruled by the
> first line of this proof which should be "Assume H is a halting
> decider".  

Further assume the self-contradictory premise that it can process an
infinite number of input strings in finite time. It is not that H^ cannot
decide w^. It is that the combination of H^ and w^ create an infinitely 
recursive evaluation sequence, such that what W^ is required to do
is evaluate an infinite set of inputs. 

There is no correct formulation of the HP counter-example that derives
the HP proof conclusion. If we ask a program to count to infinity we
should not be surprised that it never gets done. 


> No machine that "evaluates" its input (by which I think you
> mean that it runs the machine description it's given) can be a halting
> decider, and any machine that is a decider will eventually halt so H^
> must transition from qx to either qy or qn at some point.
> 
> -- 
> Ben.

From a David Hilbert formalist POV the HP is merely the evaluation
of finite strings.

[toc] | [prev] | [next] | [standalone]


#171204

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2018-01-27 21:58 +0000
Message-ID<87o9lfge0i.fsf@bsb.me.uk>
In reply to#171199
I'm going to reply only the main point -- the error in your argument.
It's too easy for Usenet threads to get side tracked by all the other
things you say...

peteolcott <peterolcott2@gmail.com> writes:

> On Saturday, January 27, 2018 at 2:24:45 PM UTC-6, Ben Bacarisse wrote:
>> peteolcott writes:
>> <snip>
>> > No you only need to trace the evaluation sequence of H^ to see that
>> > it gets stuck in infinite recursion after state (qx). It never even 
>> > reaches state (qy) or ((qn)).

This is wrong by the assumption made at the start of the proof -- that H
decides halting (the fact that it decides anything is enough).  The
first time round I missed this clearly erroneous statement but I make
the same point later on:

>> > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
>> >
>> > Definition of Turing Machine Ĥ (state transition sequence)
>> > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞  
>> > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
<remove side issue>
>> > q0 to qx it copies its input ŵ to ŵ2
>> > after qx it evaluates its input ŵ ŵ2
>> 
>> No.  You do not know exactly what H^ does from state qx onward.  You
>> certainly can't say it "evaluates" its input.  
>
> From a David Hilbert Formalism pure math POV the entire process 
> is the evaluation of finite strings H^ w^.

You are not allowed to change the formalism.  H^ is a TM and it's action
is determined by it's state transition function.  To see your error you
must stick with Turning machines and their actions.

But in *any* formalism you may not assume what H^ does from state qx on.
Any arguments that does so is flawed.  You wanted to know where the
error is.  It is here.

The only valid assumptions about H^'s behaviour are those you can derive
from the assumption in the argument: that H decides halting.  From that
premise we know that all traces of H^ take the machine from state qx to
either qy or qn.

The looping you describe is not possible for any H^ derived from a
decider H.  You can *not* assume that H^ "evaluates it input" and you
*must* assume that H^ always transitions from qx to either qy or qn.

<snip lots of things that could side track the thread>
-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#171291

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-29 19:02 -0800
Message-ID<d0d89c98-f349-4111-8ead-596cd8ce6836@googlegroups.com>
In reply to#171204
On Saturday, January 27, 2018 at 3:58:40 PM UTC-6, Ben Bacarisse wrote:
> I'm going to reply only the main point -- the error in your argument.
> It's too easy for Usenet threads to get side tracked by all the other
> things you say...
> 
> peteolcott writes:
> 
> > On Saturday, January 27, 2018 at 2:24:45 PM UTC-6, Ben Bacarisse wrote:
> >> peteolcott writes:
> >> <snip>
> >> > No you only need to trace the evaluation sequence of H^ to see that
> >> > it gets stuck in infinite recursion after state (qx). It never even 
> >> > reaches state (qy) or ((qn)).
> 
> This is wrong by the assumption made at the start of the proof -- that H
> decides halting (the fact that it decides anything is enough).  The
> first time round I missed this clearly erroneous statement but I make
> the same point later on:
> 
> >> > http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/
> >> >
> >> > Definition of Turing Machine Ĥ (state transition sequence)
> >> > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qy ∞  
> >> > q0 ŵ ⊢* Ĥ qx ŵ ŵ ⊢* Ĥ qn
> <remove side issue>
> >> > q0 to qx it copies its input ŵ to ŵ2
> >> > after qx it evaluates its input ŵ ŵ2
> >> 
> >> No.  You do not know exactly what H^ does from state qx onward.  You
> >> certainly can't say it "evaluates" its input.  
> >
> > From a David Hilbert Formalism pure math POV the entire process 
> > is the evaluation of finite strings H^ w^.
> 
> You are not allowed to change the formalism.  H^ is a TM and it's action
> is determined by it's state transition function.  To see your error you
> must stick with Turning machines and their actions.
> 
> But in *any* formalism you may not assume what H^ does from state qx on.
> Any arguments that does so is flawed.  You wanted to know where the
> error is.  It is here.
> 
> The only valid assumptions about H^'s behaviour are those you can derive
> from the assumption in the argument: that H decides halting.  From that
> premise we know that all traces of H^ take the machine from state qx to
> either qy or qn.
> 

If we create a machine specification that counts the characters
of strings and a string of infinite length is provided as input 
we cannot expect this machine to halt on every input.

The same thing is occurring with the HP proof counter-example. H^ is 
not actually provided a single TM / input pair, it superficially 
seems that it is, but, deeper analysis indicates that H^ is actually 
provided with an infinitely recursive set of TM / input pairs. 

It took me at least 3,000 hours 12 years to see this so if you don't 
get it right away that is quite understandable. 

H^ can only decide if w^ halts on it input w^2
on the basis of w^2 halting on its input w^3...

This is far too subtle for anyone in the world to notice until now. 

> The looping you describe is not possible for any H^ derived from a
> decider H.  You can *not* assume that H^ "evaluates it input" and you
> *must* assume that H^ always transitions from qx to either qy or qn.
> 
> <snip lots of things that could side track the thread>
> -- 
> Ben.

[toc] | [prev] | [next] | [standalone]


#171298

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-01-29 20:11 -0800
Message-ID<21f407e0-cb5f-4e55-8129-4021d82f2c17@googlegroups.com>
In reply to#171291
On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote:
> If we create a machine specification that counts the characters
> of strings and a string of infinite length is provided as input 
> we cannot expect this machine to halt on every input.

Of course, but that truly does NOT MATTER under the paradigm we
are discussing.  We are talking about treating TMs as functions
with finite input (programs have to be finite). ONLY the behavior of the
machine ON finite inputs is being considered.

> 
> The same thing is occurring with the HP proof counter-example.

NO, IT ISN'T, DUMBASS.
H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string!
THEREFORE H' has a finite code-string (its code-string is just
H's code-string plus some extra code for reversing the outcome), and therefore
H^ has a finite code-string (it's just the code-string of H' with some code
for doubling the input prepended).

> H^ is  not actually provided a single TM / input pair, 

YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED
h^, since it is the code-string of H^.

THIS IS WHY you do NOT get to talk DOWN to
BB, PP, or GG about ANY of this stuff:
YOU
*DON'T*
KNOW!!


> it superficially seems that it is, but, deeper analysis indicates
> that H^

You are getting your annotations WRONG now -- do you mean H' ??
H^ is provided (CALLED) WITH ONE input-string, namely, ITS OWN CODE-STRING, w^,
WHICH IS CLEARLY defined-and-finite -- EVERY TM has a clearly defined
finite code-string.

Please STOP trying to pretend that you ALREADY know what is going on.

You still think a TM is hardware, apparently.
You're just wrong.
It's DESCRIBED AS hardware but the actual identity of the TM is in
what the definition calls "delta" -- THE TRANSITION MATRIX -- which
embodies AN ALGORITHM, i.e., a program or subroutine.

[toc] | [prev] | [next] | [standalone]


#171374

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-30 08:49 -0800
Message-ID<e52292be-ea78-4132-877b-9fb733e094e3@googlegroups.com>
In reply to#171298
On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote:
> On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote:
> > If we create a machine specification that counts the characters
> > of strings and a string of infinite length is provided as input 
> > we cannot expect this machine to halt on every input.
> 
> Of course, but that truly does NOT MATTER under the paradigm we
> are discussing.  We are talking about treating TMs as functions
> with finite input (programs have to be finite). ONLY the behavior of the
> machine ON finite inputs is being considered.
> 
> > 
> > The same thing is occurring with the HP proof counter-example.
> 
> NO, IT ISN'T, DUMBASS.
> H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string!

Yes they are both finite strings. When I said the same thing 
I meant analogous. 

If the definition of the requirements of the problem specify infinite 
recursion then this is analogous to specifying input of infinite
length. 

Even though the strings are finite an infinitely recursive evaluation 
sequence is specified in the same way that an infinitely recursive 
evaluation sequence is specified in the Liar Paradox and the same way 
that this Prolog specifies an infinitely recursive evaluation sequence: 

http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference.pdf

match a term against an uninstantiated subterm of itself:

equal(X, X).
?- equal(foo(Y), Y).


> THEREFORE H' has a finite code-string (its code-string is just
> H's code-string plus some extra code for reversing the outcome), and therefore
> H^ has a finite code-string (it's just the code-string of H' with some code
> for doubling the input prepended).
> 

Halting for H^ w^ w^2 can only be decided in terms of
halting for w^ w^2 w^3 ...

Everyone in the world missed this including myself until 2016. 
I have been working on this since 2004. 

> > H^ is  not actually provided a single TM / input pair, 
> 
> YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED
> h^, since it is the code-string of H^.
> 

Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does...
alternatively

H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. 
This causes w^ to transition to (qy) which causes H^ to correctly decide
halting by transitioning to ((qn)). 

So you either have infinite recursion, as an intrinsic part of the problem 
definition or H^ correctly decides halting for w^ w^2. 

Copyright 2016, 2017, 2018 Pete Olcott 

[toc] | [prev] | [next] | [standalone]


#171384

Fromgrahamcooper7@gmail.com
Date2018-01-30 09:43 -0800
Message-ID<5d35ac76-510c-4de6-b66b-25e05253403e@googlegroups.com>
In reply to#171374
On Wednesday, January 31, 2018 at 2:49:08 AM UTC+10, peteolcott wrote:
> On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote:
> > On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote:
> > > If we create a machine specification that counts the characters
> > > of strings and a string of infinite length is provided as input 
> > > we cannot expect this machine to halt on every input.
> > 
> > Of course, but that truly does NOT MATTER under the paradigm we
> > are discussing.  We are talking about treating TMs as functions
> > with finite input (programs have to be finite). ONLY the behavior of the
> > machine ON finite inputs is being considered.
> > 
> > > 
> > > The same thing is occurring with the HP proof counter-example.
> > 
> > NO, IT ISN'T, DUMBASS.
> > H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string!
> 
> Yes they are both finite strings. When I said the same thing 
> I meant analogous. 
> 
> If the definition of the requirements of the problem specify infinite 
> recursion then this is analogous to specifying input of infinite
> length. 
> 
> Even though the strings are finite an infinitely recursive evaluation 
> sequence is specified in the same way that an infinitely recursive 
> evaluation sequence is specified in the Liar Paradox and the same way 
> that this Prolog specifies an infinitely recursive evaluation sequence: 
> 
> http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference.pdf
> 
> match a term against an uninstantiated subterm of itself:
> 
> equal(X, X).
> ?- equal(foo(Y), Y).
> 
> 
> > THEREFORE H' has a finite code-string (its code-string is just
> > H's code-string plus some extra code for reversing the outcome), and therefore
> > H^ has a finite code-string (it's just the code-string of H' with some code
> > for doubling the input prepended).
> > 
> 
> Halting for H^ w^ w^2 can only be decided in terms of
> halting for w^ w^2 w^3 ...
> 
> Everyone in the world missed this including myself until 2016. 
> I have been working on this since 2004. 
> 
> > > H^ is  not actually provided a single TM / input pair, 
> > 
> > YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED
> > h^, since it is the code-string of H^.
> > 
> 
> Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does...
> alternatively
> 
> H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. 
> This causes w^ to transition to (qy) which causes H^ to correctly decide
> halting by transitioning to ((qn)). 
> 
> So you either have infinite recursion, as an intrinsic part of the problem 
> definition or H^ correctly decides halting for w^ w^2. 
> 
> Copyright 2016, 2017, 2018 Pete Olcott




if HALT has no infinite recursion, neither does H^



[HALT]----->[YES]
  |
  |
  |
  v
 [NO]




[DOUBLE THE TAPE]
  |
  |
  |
  v
[HALT]----->[YES]<---->[TOGGLE]
  |
  |
  |
  v
 [NO]





then you get a function


HALT( ...halt... ....... )


where the VALUES are opposite

[toc] | [prev] | [next] | [standalone]


#171388

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-30 17:07 -0800
Message-ID<7dc94483-df15-4adb-a689-a149fb75a4cf@googlegroups.com>
In reply to#171384
On Tuesday, January 30, 2018 at 11:43:38 AM UTC-6, graham...@gmail.com wrote:
> On Wednesday, January 31, 2018 at 2:49:08 AM UTC+10, peteolcott wrote:
> > On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote:
> > > On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote:
> > > > If we create a machine specification that counts the characters
> > > > of strings and a string of infinite length is provided as input 
> > > > we cannot expect this machine to halt on every input.
> > > 
> > > Of course, but that truly does NOT MATTER under the paradigm we
> > > are discussing.  We are talking about treating TMs as functions
> > > with finite input (programs have to be finite). ONLY the behavior of the
> > > machine ON finite inputs is being considered.
> > > 
> > > > 
> > > > The same thing is occurring with the HP proof counter-example.
> > > 
> > > NO, IT ISN'T, DUMBASS.
> > > H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string!
> > 
> > Yes they are both finite strings. When I said the same thing 
> > I meant analogous. 
> > 
> > If the definition of the requirements of the problem specify infinite 
> > recursion then this is analogous to specifying input of infinite
> > length. 
> > 
> > Even though the strings are finite an infinitely recursive evaluation 
> > sequence is specified in the same way that an infinitely recursive 
> > evaluation sequence is specified in the Liar Paradox and the same way 
> > that this Prolog specifies an infinitely recursive evaluation sequence: 
> > 
> > http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference.pdf
> > 
> > match a term against an uninstantiated subterm of itself:
> > 
> > equal(X, X).
> > ?- equal(foo(Y), Y).
> > 
> > 
> > > THEREFORE H' has a finite code-string (its code-string is just
> > > H's code-string plus some extra code for reversing the outcome), and therefore
> > > H^ has a finite code-string (it's just the code-string of H' with some code
> > > for doubling the input prepended).
> > > 
> > 
> > Halting for H^ w^ w^2 can only be decided in terms of
> > halting for w^ w^2 w^3 ...
> > 
> > Everyone in the world missed this including myself until 2016. 
> > I have been working on this since 2004. 
> > 
> > > > H^ is  not actually provided a single TM / input pair, 
> > > 
> > > YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED
> > > h^, since it is the code-string of H^.
> > > 
> > 
> > Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does...
> > alternatively
> > 
> > H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. 
> > This causes w^ to transition to (qy) which causes H^ to correctly decide
> > halting by transitioning to ((qn)). 
> > 
> > So you either have infinite recursion, as an intrinsic part of the problem 
> > definition or H^ correctly decides halting for w^ w^2. 
> > 
> > Copyright 2016, 2017, 2018 Pete Olcott
> 
> 
> 
> 
> if HALT has no infinite recursion, neither does H^
> 
> 
> 
> [HALT]----->[YES]
>   |
>   |
>   |
>   v
>  [NO]
> 
> 
> 
> 
> [DOUBLE THE TAPE]
>   |
>   |
>   |
>   v
> [HALT]----->[YES]<---->[TOGGLE]
>   |
>   |
>   |
>   v
>  [NO]
> 
> 

You are not going to be able to understand this as a computer 
science problem. The only way that this can be understood is 
as a David Hilbert finite strings math problem. 

Only a David Hilbert math problem knows the required mathematical
evaluation sequence of the finite strings after state qx. 

[toc] | [prev] | [next] | [standalone]


#171398

Fromgrahamcooper7@gmail.com
Date2018-01-30 17:41 -0800
Message-ID<702487da-7f10-4ff5-8243-664ccdfb3b33@googlegroups.com>
In reply to#171388
On Wednesday, January 31, 2018 at 11:07:27 AM UTC+10, peteolcott wrote:
> On Tuesday, January 30, 2018 at 11:43:38 AM UTC-6, graham...@gmail.com wrote:
> > On Wednesday, January 31, 2018 at 2:49:08 AM UTC+10, peteolcott wrote:
> > > On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote:
> > > > On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote:
> > > > > If we create a machine specification that counts the characters
> > > > > of strings and a string of infinite length is provided as input 
> > > > > we cannot expect this machine to halt on every input.
> > > > 
> > > > Of course, but that truly does NOT MATTER under the paradigm we
> > > > are discussing.  We are talking about treating TMs as functions
> > > > with finite input (programs have to be finite). ONLY the behavior of the
> > > > machine ON finite inputs is being considered.
> > > > 
> > > > > 
> > > > > The same thing is occurring with the HP proof counter-example.
> > > > 
> > > > NO, IT ISN'T, DUMBASS.
> > > > H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string!
> > > 
> > > Yes they are both finite strings. When I said the same thing 
> > > I meant analogous. 
> > > 
> > > If the definition of the requirements of the problem specify infinite 
> > > recursion then this is analogous to specifying input of infinite
> > > length. 
> > > 
> > > Even though the strings are finite an infinitely recursive evaluation 
> > > sequence is specified in the same way that an infinitely recursive 
> > > evaluation sequence is specified in the Liar Paradox and the same way 
> > > that this Prolog specifies an infinitely recursive evaluation sequence: 
> > > 
> > > http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference.pdf
> > > 
> > > match a term against an uninstantiated subterm of itself:
> > > 
> > > equal(X, X).
> > > ?- equal(foo(Y), Y).
> > > 
> > > 
> > > > THEREFORE H' has a finite code-string (its code-string is just
> > > > H's code-string plus some extra code for reversing the outcome), and therefore
> > > > H^ has a finite code-string (it's just the code-string of H' with some code
> > > > for doubling the input prepended).
> > > > 
> > > 
> > > Halting for H^ w^ w^2 can only be decided in terms of
> > > halting for w^ w^2 w^3 ...
> > > 
> > > Everyone in the world missed this including myself until 2016. 
> > > I have been working on this since 2004. 
> > > 
> > > > > H^ is  not actually provided a single TM / input pair, 
> > > > 
> > > > YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED
> > > > h^, since it is the code-string of H^.
> > > > 
> > > 
> > > Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does...
> > > alternatively
> > > 
> > > H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. 
> > > This causes w^ to transition to (qy) which causes H^ to correctly decide
> > > halting by transitioning to ((qn)). 
> > > 
> > > So you either have infinite recursion, as an intrinsic part of the problem 
> > > definition or H^ correctly decides halting for w^ w^2. 
> > > 
> > > Copyright 2016, 2017, 2018 Pete Olcott
> > 
> > 
> > 
> > 
> > if HALT has no infinite recursion, neither does H^
> > 
> > 
> > 
> > [HALT]----->[YES]
> >   |
> >   |
> >   |
> >   v
> >  [NO]
> > 
> > 
> > 
> > 
> > [DOUBLE THE TAPE]
> >   |
> >   |
> >   |
> >   v
> > [HALT]----->[YES]<---->[TOGGLE]
> >   |
> >   |
> >   |
> >   v
> >  [NO]
> > 
> > 
> 
> You are not going to be able to understand this as a computer 
> science problem. The only way that this can be understood is 
> as a David Hilbert finite strings math problem. 
> 
> Only a David Hilbert math problem knows the required mathematical
> evaluation sequence of the finite strings after state qx.



INPUT = 00001110000

q0 ~~~~> qx


TAPE = 000011101110000


qx ~~~~~> qYES
|
\
/
\
|
v

qNO





ASSUMPTION:   HALT [START] -> qYES or qNO TOO!

[toc] | [prev] | [next] | [standalone]


#171411

Frompeteolcott <peterolcott2@gmail.com>
Date2018-01-30 18:40 -0800
Message-ID<6085d32a-ab5c-4099-acc8-841827723747@googlegroups.com>
In reply to#171398
On Tuesday, January 30, 2018 at 7:41:04 PM UTC-6, graham...@gmail.com wrote:
> On Wednesday, January 31, 2018 at 11:07:27 AM UTC+10, peteolcott wrote:
> > On Tuesday, January 30, 2018 at 11:43:38 AM UTC-6, graham...@gmail.com wrote:
> > > On Wednesday, January 31, 2018 at 2:49:08 AM UTC+10, peteolcott wrote:
> > > > On Monday, January 29, 2018 at 10:11:03 PM UTC-6, George Greene wrote:
> > > > > On Monday, January 29, 2018 at 10:02:46 PM UTC-5, peteolcott wrote:
> > > > > > If we create a machine specification that counts the characters
> > > > > > of strings and a string of infinite length is provided as input 
> > > > > > we cannot expect this machine to halt on every input.
> > > > > 
> > > > > Of course, but that truly does NOT MATTER under the paradigm we
> > > > > are discussing.  We are talking about treating TMs as functions
> > > > > with finite input (programs have to be finite). ONLY the behavior of the
> > > > > machine ON finite inputs is being considered.
> > > > > 
> > > > > > 
> > > > > > The same thing is occurring with the HP proof counter-example.
> > > > > 
> > > > > NO, IT ISN'T, DUMBASS.
> > > > > H *IS*ASSUMED* to be a TM, so IT MUST HAVE A FINITE code-string!
> > > > 
> > > > Yes they are both finite strings. When I said the same thing 
> > > > I meant analogous. 
> > > > 
> > > > If the definition of the requirements of the problem specify infinite 
> > > > recursion then this is analogous to specifying input of infinite
> > > > length. 
> > > > 
> > > > Even though the strings are finite an infinitely recursive evaluation 
> > > > sequence is specified in the same way that an infinitely recursive 
> > > > evaluation sequence is specified in the Liar Paradox and the same way 
> > > > that this Prolog specifies an infinitely recursive evaluation sequence: 
> > > > 
> > > > http://liarparadox.org/Prolog_Detects_Pathological_Self_Reference.pdf
> > > > 
> > > > match a term against an uninstantiated subterm of itself:
> > > > 
> > > > equal(X, X).
> > > > ?- equal(foo(Y), Y).
> > > > 
> > > > 
> > > > > THEREFORE H' has a finite code-string (its code-string is just
> > > > > H's code-string plus some extra code for reversing the outcome), and therefore
> > > > > H^ has a finite code-string (it's just the code-string of H' with some code
> > > > > for doubling the input prepended).
> > > > > 
> > > > 
> > > > Halting for H^ w^ w^2 can only be decided in terms of
> > > > halting for w^ w^2 w^3 ...
> > > > 
> > > > Everyone in the world missed this including myself until 2016. 
> > > > I have been working on this since 2004. 
> > > > 
> > > > > > H^ is  not actually provided a single TM / input pair, 
> > > > > 
> > > > > YES, IT IS -- it is provided 2 copies of w^, which SHOULD HAVE BEEN CALLED
> > > > > h^, since it is the code-string of H^.
> > > > > 
> > > > 
> > > > Then H^ w^ w^2 must decide what w^ does on the basis of what w^2 W^3 does...
> > > > alternatively
> > > > 
> > > > H^ decides what w^ w^2 does and w^ decides that w^2 halts on NULL input. 
> > > > This causes w^ to transition to (qy) which causes H^ to correctly decide
> > > > halting by transitioning to ((qn)). 
> > > > 
> > > > So you either have infinite recursion, as an intrinsic part of the problem 
> > > > definition or H^ correctly decides halting for w^ w^2. 
> > > > 
> > > > Copyright 2016, 2017, 2018 Pete Olcott
> > > 
> > > 
> > > 
> > > 
> > > if HALT has no infinite recursion, neither does H^
> > > 
> > > 
> > > 
> > > [HALT]----->[YES]
> > >   |
> > >   |
> > >   |
> > >   v
> > >  [NO]
> > > 
> > > 
> > > 
> > > 
> > > [DOUBLE THE TAPE]
> > >   |
> > >   |
> > >   |
> > >   v
> > > [HALT]----->[YES]<---->[TOGGLE]
> > >   |
> > >   |
> > >   |
> > >   v
> > >  [NO]
> > > 
> > > 
> > 
> > You are not going to be able to understand this as a computer 
> > science problem. The only way that this can be understood is 
> > as a David Hilbert finite strings math problem. 
> > 
> > Only a David Hilbert math problem knows the required mathematical
> > evaluation sequence of the finite strings after state qx.
> 
> 
> 
> INPUT = 00001110000
> 
> q0 ~~~~> qx
> 
> 
> TAPE = 000011101110000
> 
> 
> qx ~~~~~> qYES
> |
> \
> /
> \
> |
> v
> 
> qNO
> 
> 
> 
> 
> 
> ASSUMPTION:   HALT [START] -> qYES or qNO TOO!

∃x ∈ Turing_Machines_Descriptions  
∀y ∈ Turing_Machine_Descriptions 
∀z ∈ Finite_Strings Halts(x, y, z) 
H ≡ Halts(H, H, H) // HOL with self-reference semantics 

// Prolog 
equal(X, X).
?- equal(foo(Y), Y).
Matching a term against an uninstantiated subterm of itself
is an example of infinite recursion. 

cyclic_term(@Term)
True if Term contains cycles, i.e. is an infinite term. See also acyclic_term/1 and section 2.17.59

H ≡ Halts(H, H, H) // HOL with self-reference semantics 
H as specified above is an infinite term

[toc] | [prev] | [next] | [standalone]


Page 1 of 6  [1] 2 3 4 5 6  Next page →

Back to top | Article view | sci.logic


csiph-web