Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #171063 > unrolled thread
| Started by | George Greene <greeneg@email.unc.edu> |
|---|---|
| First post | 2018-01-25 20:26 -0800 |
| Last post | 2018-02-03 17:00 -0800 |
| Articles | 20 on this page of 118 — 9 participants |
Back to article view | Back to sci.logic
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-25 20:26 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-25 21:49 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-26 04:10 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-26 11:37 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-26 15:12 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-26 05:34 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-26 20:33 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-27 05:05 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-27 06:57 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-27 13:53 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 20:24 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-27 13:03 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-27 21:58 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-29 19:02 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-29 20:11 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 08:49 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 09:43 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 17:07 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 17:41 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 18:40 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 19:17 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:20 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-30 21:21 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-29 21:21 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-30 08:58 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 03:16 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:14 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-30 22:37 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 10:53 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-31 19:38 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:42 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 18:08 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-31 21:57 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 16:21 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 01:44 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:11 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 01:54 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:15 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 19:36 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 21:13 +0000
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 21:30 +0000
Re: Infinitely Recursive input on HP Proofs Andy Walker <anw@cuboid.co.uk> - 2018-02-03 18:17 +0000
Re: Infinitely Recursive input on HP Proofs Andy Walker <anw@cuboid.co.uk> - 2018-02-03 18:42 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 12:46 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-03 20:53 -0600
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 19:51 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 18:56 -0600
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 17:22 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-05 20:45 -0600
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 21:45 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-06 15:34 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 08:02 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:51 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 10:23 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 01:52 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 17:19 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-06 17:59 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 19:02 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-07 20:57 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 22:39 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-06 23:14 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:45 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-06 22:28 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:31 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-06 17:54 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 02:13 +0000
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 03:49 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-06 22:48 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-07 16:27 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-07 23:22 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-08 21:05 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-08 18:44 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-09 11:08 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-11 08:44 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-11 08:47 -0800
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-11 17:55 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-12 20:39 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:41 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-08 03:43 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-06 18:56 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-07 20:50 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-02-06 20:13 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-05 17:45 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-04 17:01 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 16:44 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-05 17:42 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-05 18:09 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-05 21:50 -0800
Re: Infinitely Recursive input on HP Proofs "Shobe, Martin" <martin.shobe@yahoo.com> - 2018-01-31 19:57 -0600
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-02-01 11:02 -0800
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 19:10 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 01:51 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 19:24 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 17:34 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 02:04 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:31 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-01 19:43 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-02 21:38 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-02 17:54 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-02 16:08 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 00:51 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-03 00:38 -0600
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-02 23:05 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 13:37 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-02-03 14:27 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-03 23:49 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 16:03 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 00:44 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 17:11 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-04 01:27 +0000
Re: Infinitely Recursive input on HP Proofs Newberry <newberryxy@gmail.com> - 2018-02-03 18:01 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-02-03 20:44 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-04 02:32 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-03 16:47 -0800
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-02-02 14:12 +0000
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2018-01-31 19:27 -0600
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-01 02:13 +0000
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-02-03 17:00 -0800
Page 1 of 6 [1] 2 3 4 5 6 Next page →
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-25 20:26 -0800 |
| Subject | Re: 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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | Pete Olcott <Pete@NoEmail.address> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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]
| From | grahamcooper7@gmail.com |
|---|---|
| Date | 2018-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]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-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