Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #11910 > unrolled thread
| Started by | peteolcott <peteolcott@gmail.com> |
|---|---|
| First post | 2017-03-11 13:13 -0800 |
| Last post | 2018-02-15 12:25 -0600 |
| Articles | 20 on this page of 118 — 9 participants |
Back to article view | Back to comp.theory
Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-11 13:13 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-12 11:25 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-12 10:58 -0700
Re: Infinitely Recursive input on HP Proofs Kaz Kylheku <336-986-7787@kylheku.com> - 2017-03-12 19:34 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-13 07:23 -0700
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 08:46 -0700
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 12:17 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-15 20:40 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 14:01 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 14:09 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-16 09:53 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 21:54 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-17 07:09 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-18 01:39 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-18 05:40 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-18 15:35 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-18 12:52 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-18 21:35 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-20 07:16 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-20 18:07 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-21 05:03 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-21 19:47 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-22 05:35 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-22 16:41 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-23 06:24 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-25 01:11 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-25 08:09 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-25 21:58 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-27 06:18 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-27 22:20 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-28 15:33 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-29 01:29 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-25 19:57 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-26 23:53 +0100
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-13 03:14 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-13 07:23 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-15 17:12 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 13:56 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 03:23 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peteolcott@gmail.com> - 2017-03-15 21:22 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 10:19 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-16 09:26 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-16 22:00 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-17 07:17 -0700
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-28 10:20 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-03-29 01:18 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-03-29 10:09 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-01 02:55 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-01 05:30 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-02 00:50 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-01 19:10 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-02 03:19 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-03 06:28 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-04 01:27 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-09 21:41 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-10 14:35 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2017-04-10 13:58 -0700
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-11 00:58 +0100
Re: Infinitely Recursive input on HP Proofs Pete Olcott <Pete@NoEmail.address> - 2017-04-10 20:29 -0500
Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-29 14:29 -0500
Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-29 14:45 -0500
Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-30 13:23 -0500
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-04-30 23:05 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-30 18:43 -0500
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2017-05-01 13:45 +0100
Re: Infinitely Recursive input on HP Proofs peteolcott <Pete@NoEmail.address> - 2017-04-30 13:24 -0500
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2017-04-27 21:16 +0100
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 Pete Olcott <Pete@NoEmail.address> - 2018-01-31 00:14 -0600
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 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-03 00:38 -0600
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 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 Pete Olcott <Pete@NoEmail.address> - 2018-02-01 21:15 -0600
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 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 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 peteolcott <peterolcott2@gmail.com> - 2017-03-25 19:56 -0700
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 00:18 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-13 13:06 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 16:55 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 00:30 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-13 19:38 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-14 02:27 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Andy Walker <anw@cuboid.co.uk> - 2018-02-14 22:55 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-14 17:22 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-14 21:00 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-15 21:38 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 17:27 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 17:34 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 00:15 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 18:43 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 01:05 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 19:37 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 02:34 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 20:51 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 03:32 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 22:42 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 12:06 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-16 10:26 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-16 20:42 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-16 17:48 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-17 01:33 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-02-19 15:48 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) David Kleinecke <dkleinecke@gmail.com> - 2018-02-22 12:40 -0800
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-22 15:31 -0600
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Andy Walker <anw@cuboid.co.uk> - 2018-02-15 12:24 +0000
Re: Infinitely Recursive input on HP Proofs (Final Solution?) Pete Olcott <Pete@NoEmail.address> - 2018-02-15 12:25 -0600
Page 2 of 6 — ← Prev page 1 [2] 3 4 5 6 Next page →
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-21 05:03 -0700 |
| Message-ID | <32500699-06ff-46b5-b524-58e7dca1a018@googlegroups.com> |
| In reply to | #11946 |
On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
> peteolcott <peterolcott> writes:
>
> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:
> >> peteolcott <peterolcott> writes:
> >>
> >> > On Saturday, March 18, 2017 at 10:35:57 AM UTC-5, Ben Bacarisse wrote:
> >> >> peteolcott <peterolcott> writes:
> >> >>
> >> >> > On Friday, March 17, 2017 at 8:39:09 PM UTC-5, Ben Bacarisse wrote:
> >> >> <snip>
> >> >> > I am calling Linz's description of H^ state transition matrix source
> >> >> > code, this would be obvious to anyone that understood state transition
> >> >> > matrices.
> >> >>
> >> >> Of course it's obvious -- it's just wrong. Source code is not the right
> >> >> way to refer to states and state transitions. It's not even the right
> >> >> way to refer to an encoded TM. If you want to be understood, use the
> >> >> right words.
> >> >
> >> > A Turing Machine Description IS the source code of a Turing Machine.
> >> > (as George Greene of sci.logic would say: you idiot).
> >> >
> >> >>
> >> >> > +++ q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> >> >> > +++ q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
> >> >> >
> >> >> > The last time that I told you this I did it by direct quotes that you
> >> >> > must have ignored or I would not have to say this all again.
> >> >> >
> >> >> > I will describe it step by (I think I already did this once)
> >> >> > q0 // H^ start state
> >> >> > Wm // Input to H^
> >> >> > |-* // an arbitrary number of state transitions that copy Wm
> >> >> > H^ qc Wm Wm // H^ has copied its input and is beginning to analyze WmWm
> >> >>
> >> >> That's saying more than you know. All you know is that H^ now "behaves
> >> >> exactly like H'".
> >> >
> >> > I call bullshit.
> >>
> >> I call not understanding.
> >>
> >> > If H^ behaved EXACTLY like H' then it would not copy its input.
> >>
> >> Did you miss the word "now"?
> >>
> >> > Try
> >> > and use your words with (as much as possible) 100% perfect
> >> > precision. I already called you on this before when you referred to a
> >> > true opinion, (contradiction in terms).
> >>
> >> They are Linz's words not mine; that's why I put them in quotes. H^
> >> copies it's input an *then* behaves exactly like H'. It's not hard to
> >> understand.
> >
> > You and Linz are both incorrect on this.
>
> Not so. It is so by definition.
>
I both you and Linz agreed that all of the square circles are blue in color you would be wrong. You and Linz said that H^ and H' behave the same way and they don't behave the same way.
> > If either you or Linz would have studied Linz's clearest possible
> > specification until you grokked it you would both have the same new
> > insight that I have.
>
> There is no point in drawing silly conclusions form an error in the
> text. If you can't see past it, try any of a hundred other proofs of
> this theorem. They all use the same definition that you are denying to
> Linz -- a machine copies its input and then behaves as the machine it is
> derived from.
>
All of these proof overlook the same problem.
My other post show this same problem.
Rejecting semantically ill-formed input to a Halt Decider.
The infinitely recursive nature of Kurt Gödel's first incompleteness theorem simply proves that his conclusion is incorrect.
The first incompleteness theorem states that no consistent system of axioms whose theorems can be listed by an effective procedure (i.e., an algorithm) is capable of proving all truths about the arithmetic of the natural numbers. For any such formal system, there will always be statements about the natural numbers that are true, but that are unprovable within the system.
Instead of finding G that is true but unprovable in PM he simply found G that is neither true nor false, thus not in PM. Alfred Tarski made similar mistakes.
> >
> > It is, however, so very much easier to simply understand these things in the conventional way. Also what would be your basis for even suspecting that the conventional understanding is incorrect?
> >
> > All of these years I have only had an intuition that the conventional understanding of the halting problem and the incompleteness problem are incorrect.
> >
> > My basis for this intuition it that the 2000 year old Liar Paradox
> > continued to lack any conventional understanding what-so-ever. Everyone knew that something was wrong yet no one knew exactly what was wrong.
> >
> > I also knew intuitively that all three of these HP, IT, and LP had pathological self reference as the source of their error. I said that here in this forum several years ago.
> >
> > It was not until about a year ago that I could state this intuition in a way that could be eventually mathematically verified. If the Incompleteness Theorem is correct then it proves that sometimes logical entailment either fails to complete or derives contradictory results. I have known that this is not possible because logical entailment is entirely based on logical tautology.
> >
> > You probably don't understand the mathematical meaning of those words and won't bother to look them up.
> >
> > This link anchors the concept of logical entailment:
> > https://en.wikipedia.org/wiki/Logical_consequence#Proofs_and_models
> >
> >>
> >> Unfortunately you rejected my formal explanation using state names but
> >> you offered not better alternative. I see no option but to quote Linz's
> >> words and hope that the penny drops. You are obviously averse to asking
> >> for help, but if you don't say what part of his proof is confusing you,
> >> I can't help much more than that.
> >
> > I did not reject state names. I said that Linz goofed when he resumed
> > the execution of H^ back to its start state after it copied its
> > input.
>
> So fix it and more on. None of your re-writes have been clear in how
> the problem should be fixed because, of course, you don't want to fix
> it. You thought that H^ machine endlessly copied it's input and you
> don't like that fact that that error is trivial to correct. You'd be
> stuck having to accept the theorem again as you did for so many years.
I already fixed it in this post.
Rejecting semantically ill-formed input to a Halt Decider.
It detects that it is stuck in infinite recursion and detects
that one of its its final states has been altered, and thus
rejects the input as semantically invalid.
It does this with a single-step execution trace from chosen
points in the execution sequence.
> >
> >>
> >> You can't criticise the proof until you've understood it, and you seemed
> >> genuinely surprised ("I call bullshit") by my direct quote of Linz words
> >> about H^ copying its input and then behaving like H'. That suggests to
> >> me that you don't know what Linz is saying.
> >
> > No it means that I ignore some of his mistakes and correct
> > others. Because H^ has an infinitely recursive structure and H' does
> > not have infinitely recursive structure there is not point where H^
> > behaves like H'.
>
> Of course you don't want to correct the poof so you pick and choose what
> you call the error. That shows only a lack of intellectual backbone.
> Fix the error in the proof so the proof is correct. Anything else is
> just burying your head in the sand.
>
I already fixed it here.
Rejecting semantically ill-formed input to a Halt Decider
> <snip>
> >> >> If you were a student of mine, I'd make it very concrete. I'd give you
> >> >> an actual machine H and ask you do write down H' and then H^. Then I'd
> >> >> ask you to run through the execution of H^. Have you done that? Do
> >> >> think you could do that?
> >> >
> >> > I have two patents as sole inventor of two finite state machines what
> >> > would you guess?
> >>
> >> Since you are avoiding the question, I would guess that you think you
> >> can't do it, but it's not hard and I'm pretty sure you could. I'll
> >> start you off. Here's an example H.
> >>
> >> H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})
> >>
> >> with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
> >> H' and H^?
> >>
> >
> > Since you changed the Linz notational conventions and and did not
> > define your differing notational conventions I have no idea what you
> > are saying.
>
> This is Linz's notation. You are confusing how he write execution
> configurations with how he defines machines. The explanation of the
> notation for a machine is a few chapter earlier on (you have read the
> book, yes?).
>
I have never read the whole book, I only read what I need for the HP.
> He defines a Turing machine an ordered 7-tuple so there can be no doubt
Figure 9.1
> what H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b}) means.
He always puts a q in front of all of his states, even on page 235.
> All the sets and
> functions are clearly specified. Only the details of the d function
> remain to written out (it would be unreadable if it were specified as a
> set in the tuple) and I did that.
>
> Anyway, as I said, I am sure that you can do this so just ask if
> something is confusing you. Which part of this machine description is
> bothering you?
>
Just quit changing his conventions.
> >> (For convenience I'm using Linz's formalism here so Q={a,b}, Sigma={1,0}
> >> and so on. If it's not clear, just ask.)
> >
> > That differs too much from Linz, stick with the convention of
> > preceding every state with a q such as q0.
>
> No, if you can't cope with a two-state machine with names
Then I will quit talking to you. I will simply consider you a disingenuous person playing head games.
> of my choosing
> you need to go back to square one. Especially as the crucial problem
> involves exactly the problem of confusing that start state of two
> machines one derived from the other. Using q0 for both is exactly the
> problem you need to get round.
>
> You sell yourself short if you think you can't cope with a machine with
> two states called a and b. I'm sure you can.
I have patents on two different finite state machine you nitwit.
>
> (I'm discounting the possibility that your deliberately want to use q0
> for every start state so that you can try avoid correcting Linz's
> mistake. That would be disingenuous in the extreme so I will reject
> that explanation for now.)
0 is the universal start state for all finite state machines because they are stored in a state transition matrix and 0 is the first element. If you are using an integer besides 0 you are doing it wrong.
>
> > This is better notation because it explicitly:
>
> <re-ordered a bit: here's the notation:>
>
> > q0 Wm W |-* H x1 qy x2
> > q0 Wm W |-* H y1 qn y2
> >
> > (a) Names every state in state transition order.
>
> No it doesn't. Do you really not know what the notation means? It's
> about machine configurations.
>
> > (b) Shows how many inputs
>
> No it does not. All TM's have a possibly blank tape to start with.
> There is no number of inputs -- only some set of input symbols. Again,
> you seem not to know what qx a b c |-* H ... means.
There are levels of evaluation. Ever since 1950 it has been the convention to talk about algorithms using the abstraction of some human readable language instead of raw machine language integers. The abstraction of H is specified with two inputs Wm, Wm. Linz explains this view on page 318.
H is defined to have Wm as its TMD input and W as the input to its TMD input.
If you continue to avoid the key points I will write you off as a disingenuous fool playing head games.
>
> > (c) Shows the final tape configuration (this is not very useful)
>
> Actually it's crucial to the proof, but since this notation is not about
> defining a machine, it does not apply here.
>
> > (d) Indicates an arbitrary number of unspecified state transitions
> > thus abstracts out unnecessary details.
>
> Ah, yes, that would indeed help you. What I asked for was an actual H'
> and H^ derived from an actual H. This would show that you are wrong, so
> you must at all costs never do anything that clear and concrete. Keep
> it as abstract and as far away from a counterexample as possible!
// State transitions of H
|--q0 Wm W |-* H x1 qy x2
|--q0 Wm W |-* H y1 qn y2
// State transitions of H'
|--q0 Wm W |-* H' qy ∞
|--q0 Wm W |-* H' y1 qn y2
// State transitions of H^
|--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
|--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
It of course shows that you are wrong, yet like the Donald you will never admit it. My current assessment is that you are a disingenuous fool playing head games. Additional information may change this assessment.
>
> Anyway, if you really think you can't write out H' and H^ from my
> example H, just say so, and I'll do it for you.
>
> <snip>
> --
> Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-21 19:47 +0000 |
| Message-ID | <87r31qo1jd.fsf@bsb.me.uk> |
| In reply to | #11947 |
peteolcott <peterolcott2@gmail.com> writes:
> On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>>
>> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:
<snip>
>> >> They are Linz's words not mine; that's why I put them in quotes. H^
>> >> copies it's input an *then* behaves exactly like H'. It's not hard to
>> >> understand.
>> >
>> > You and Linz are both incorrect on this.
>>
>> Not so. It is so by definition.
>
> I both you and Linz agreed that all of the square circles are blue in
> color you would be wrong. You and Linz said that H^ and H' behave the
> same way and they don't behave the same way.
Neither of us say that. I know you have some trouble with this
material, but do you really not understand how H^ is defined? Lots of
other proofs use the same definition so even if you simply can't get
past the error in Linz's notation, you must know what the words are
supposed to mean. For your convenience, I've corrected the text below.
<snip>
>> There is no point in drawing silly conclusions form an error in the
>> text. If you can't see past it, try any of a hundred other proofs of
>> this theorem. They all use the same definition that you are denying to
>> Linz -- a machine copies its input and then behaves as the machine it is
>> derived from.
>
> All of these proof overlook the same problem.
> My other post show this same problem.
> Rejecting semantically ill-formed input to a Halt Decider.
No. If you bit the bullet and did the exercise I suggested you would
see exactly how H, H' and H^ relate to each other.
Anyway, if you can't correct the proof (it's a tiny detail in notation)
I can fix it for you. Linz meant to say
"From H' we construct another Turing machine H^. This new machine
takes as input wM and copies it, ending in what was the initial state
of H' qx. After that it behaves like H'. Then the action of H^ is
such that
q0 wM |-*H^ qx wM wM |-*H^ oo
if M applied to wM halts, and
q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2
if M applied to wM does not halt."
See? Fixed. The proof is fine.
<snip>
>> >> Since you are avoiding the question, I would guess that you think you
>> >> can't do it, but it's not hard and I'm pretty sure you could. I'll
>> >> start you off. Here's an example H.
>> >>
>> >> H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b})
>> >>
>> >> with d(a,1) = (a,1,R), d(a,0) = (a,0,R) and d(a,_) = (b,_,L). What are
>> >> H' and H^?
>> >>
>> >
>> > Since you changed the Linz notational conventions and and did not
>> > define your differing notational conventions I have no idea what you
>> > are saying.
>>
>> This is Linz's notation. You are confusing how he write execution
>> configurations with how he defines machines. The explanation of the
>> notation for a machine is a few chapter earlier on (you have read the
>> book, yes?).
>
> I have never read the whole book, I only read what I need for the HP.
Ah, no wonder you are at sea. I would suggest you read it, but you
probably consider that dangerous since it's possible you'd understand
it.
>> He defines a Turing machine an ordered 7-tuple so there can be no doubt
> Figure 9.1
>
>> what H = ({a,b}, {1,0}, {1,0,_}, d, a, _, {b}) means.
> He always puts a q in front of all of his states, even on page 235.
No he does not always do that, but you've not read the book so you
wouldn't know.
But lets call them q1 and q1 if it makes you happy. Here's the machine
with the state names that don't give you the hives:
H = ({q0,q1}, {1,0}, {1,0,_}, d, q0, _, {q1})
with d(q0,1) = (q0,1,R), d(q0,0) = (q0,0,R) and d(q0,_) = (q1,_,L).
Now you need to find some other excuse to avoid withing out H' and H^.
<snip>
>> No, if you can't cope with a two-state machine with names
>
> Then I will quit talking to you. I will simply consider you a
> disingenuous person playing head games.
That's fine. I was simply correcting a detailed error in the proof that
might have confused other people.
<snip>
>> (I'm discounting the possibility that your deliberately want to use q0
>> for every start state so that you can try avoid correcting Linz's
>> mistake. That would be disingenuous in the extreme so I will reject
>> that explanation for now.)
>
> 0 is the universal start state for all finite state machines because
> they are stored in a state transition matrix and 0 is the first
> element. If you are using an integer besides 0 you are doing it wrong.
Nonsense. No lesser authority the Turing himself uses the letters a, b,
c and so on for actual states. And if you'd read Linz you would see
that he does always use q0, q1, ... either. But it's a good distraction
from actually writing out an example H' and H^.
<snip>
>> ... What I asked for was an actual H'
>> and H^ derived from an actual H. This would show that you are wrong, so
>> you must at all costs never do anything that clear and concrete. Keep
>> it as abstract and as far away from a counterexample as possible!
>
> // State transitions of H
> |--q0 Wm W |-* H x1 qy x2
> |--q0 Wm W |-* H y1 qn y2
>
>
> // State transitions of H'
> |--q0 Wm W |-* H' qy ∞
> |--q0 Wm W |-* H' y1 qn y2
>
>
> // State transitions of H^
> |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2
No, you are still confusing the notation for machine configurations and
the notation for the actual Turing machine. You can write a TM using
the |- notation (note: without the star) so feel free to do it that way
if you like.
Shall I do H' for you and then you can try H^? If you want me to do
that, what state names should I use so you won't pretend to not
understand?
<snip>
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-22 05:35 -0700 |
| Message-ID | <521efef4-8c19-473c-9551-d676335fe2b8@googlegroups.com> |
| In reply to | #11948 |
On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote: > peteolcott <peterolcott> writes: > > > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote: > >> peteolcott <peterolcott> writes: > >> > >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote: > <snip> > >> >> They are Linz's words not mine; that's why I put them in quotes. H^ > >> >> copies it's input an *then* behaves exactly like H'. It's not hard to > >> >> understand. > >> > > >> > You and Linz are both incorrect on this. > >> > >> Not so. It is so by definition. > > > > I both you and Linz agreed that all of the square circles are blue in > > color you would be wrong. You and Linz said that H^ and H' behave the > > same way and they don't behave the same way. > > Neither of us say that. I know you have some trouble with this > material, but do you really not understand how H^ is defined? There you are not being precise enough with words again. Although H^ is defined to have a superset of the states of H' this does not logically entail that H^ ever actually behaves like H'. A simple linear execution trace shows that H^ would never reach the H' states. Because of this H^ and H" never have the same behavior. Linz did not see this and you are not seeing this and it is very likely that no one has ever seen this before. Seeing this requires understanding how my Minimal Theory of Types applies to the Liar Paradox and the Incompleteness Theorem. Minimal Theory of Types copyright 2016 and 2017 Pete Olcott https://philpapers.org/archive/PETMTT-4.pdf > Lots of > other proofs use the same definition so even if you simply can't get > past the error in Linz's notation, you must know what the words are > supposed to mean. For your convenience, I've corrected the text below. > > <snip> > >> There is no point in drawing silly conclusions form an error in the > >> text. If you can't see past it, try any of a hundred other proofs of > >> this theorem. They all use the same definition that you are denying to > >> Linz -- a machine copies its input and then behaves as the machine it is > >> derived from. > > > > All of these proof overlook the same problem. > > My other post show this same problem. > > Rejecting semantically ill-formed input to a Halt Decider. > > No. If you bit the bullet and did the exercise I suggested you would > see exactly how H, H' and H^ relate to each other. > See my 1.5 page correct refutation of the Incompleteness Theorem and maybe you will begin to understand. > Anyway, if you can't correct the proof (it's a tiny detail in notation) > I can fix it for you. Linz meant to say > > "From H' we construct another Turing machine H^. This new machine > takes as input wM and copies it, ending in what was the initial state > of H' qx. After that it behaves like H'. Then the action of H^ is > such that > Yet H^ does not actually behave like H' because H^ has an infinitely recursive structure that H' does not have. > q0 wM |-*H^ qx wM wM |-*H^ oo > > if M applied to wM halts, and > > q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2 > > if M applied to wM does not halt." > > See? Fixed. The proof is fine. The bug is fixed so that H^ does not copy its input in an infinite loop. Now like every other definition of the Halting Problem counter-example it is stuck copying its input in infinite recursion. The Incompleteness Theorem and the Liar Paradox make this same mistake. Both the GIT and the LP are stuck in infinite recursion never completing their evaluation of their own expression. Because of this neither the GIT nor the LP are truth bearers. I gave a name to this error year ago in this forum: Pathological self-reference. Now I have mathematically formalized this error in my own Minimal Theory of Types. When-so-ever the formalization of the semantic meaning of any logical expression within an otherwise directed acyclic graph requires the insertion of cycles this expression derives pathological self-reference. <snip> > > // State transitions of H^ > > |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞ > > |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2 > > No, you are still confusing the notation for machine configurations and > the notation for the actual Turing machine. You can write a TM using > the |- notation (note: without the star) so feel free to do it that way > if you like. > regular expression syntax: |- exactly one state transition |-+ one or more state transitions |-* zero or more (an arbitrary number) of state transitions > Shall I do H' for you and then you can try H^? If you want me to do > that, what state names should I use so you won't pretend to not > understand? > > <snip> > -- > Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-22 16:41 +0000 |
| Message-ID | <87lgrxnu0a.fsf@bsb.me.uk> |
| In reply to | #11949 |
peteolcott <peterolcott2@gmail.com> writes: > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote: >> peteolcott <peterolcott> writes: >> >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote: >> >> peteolcott <peterolcott> writes: >> >> >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote: >> <snip> >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^ >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to >> >> >> understand. >> >> > >> >> > You and Linz are both incorrect on this. >> >> >> >> Not so. It is so by definition. >> > >> > I both you and Linz agreed that all of the square circles are blue in >> > color you would be wrong. You and Linz said that H^ and H' behave the >> > same way and they don't behave the same way. >> >> Neither of us say that. I know you have some trouble with this >> material, but do you really not understand how H^ is defined? > > There you are not being precise enough with words again. Although > H^ is defined to have a superset of the states of H' this does not > logically entail that H^ ever actually behaves like H'. A simple > linear execution trace shows that H^ would never reach the H' states. > Because of this H^ and H" never have the same behavior. Since you don't yet know what H^ is (and you are steadfastly refusing to write out an example so you can see) you can't have a trace of H^. You need to know what the machine is first. It's probably significant that you never read that chapter of the book. Anyway, you feel free to correct my wording below to make it as precise as you need it. Don't however, invent your own flawed H^. That shows nothing. There are lots of ways to fail to prove the halting theorem and you are currently fixated on just one of them -- your current misunderstanding of how H^ is defined. <snip> >> Anyway, if you can't correct the proof (it's a tiny detail in notation) >> I can fix it for you. Linz meant to say >> >> "From H' we construct another Turing machine H^. This new machine >> takes as input wM and copies it, ending in what was the initial state >> of H' qx. After that it behaves like H'. Then the action of H^ is >> such that > > Yet H^ does not actually behave like H' because H^ has an infinitely > recursive structure that H' does not have. Why don't you do the exercise I suggested? Are you worried that you'll see that H^ is not at all what you want to think it is? I don't think you'll understand until you do this exercise. >> q0 wM |-*H^ qx wM wM |-*H^ oo >> >> if M applied to wM halts, and >> >> q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2 >> >> if M applied to wM does not halt." >> >> See? Fixed. The proof is fine. > > The bug is fixed so that H^ does not copy its input in an infinite > loop. Exactly. That was the error in Linz notation (though the text made it clear). > Now like every other definition of the Halting Problem counter-example > it is stuck copying its input in infinite recursion. Nope. If you did the exercise you would see that it does not. I am beginning to think you are are too frightened to do it because you might suddenly see that the H^ construction is trivial and not at all what you think it is. Go on, do it! It should take only a few minutes, though you might have to read a few pages of chapter 9 to see what a Turing machine actually is. <snip> >> > // State transitions of H^ >> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞ >> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2 >> >> No, you are still confusing the notation for machine configurations and >> the notation for the actual Turing machine. You can write a TM using >> the |- notation (note: without the star) so feel free to do it that way >> if you like. > > regular expression syntax: > |- exactly one state transition > |-+ one or more state transitions > |-* zero or more (an arbitrary number) of state transitions That is correct. But explaining to me something I know won't help you understand how to define a Turing machine. As I said, you could define H' and H^ from my example H using the |- notation. Do it that way if you find it easier. >> Shall I do H' for you and then you can try H^? If you want me to do >> that, what state names should I use so you won't pretend to not >> understand? Are you sure you don't need some help? I'll write out H' using the |- notation is that would make you happier. It's much more involved than simple defining H' (because the notation has to name the parts of the tape that are not involved in the transition) but it can be done that way. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-23 06:24 -0700 |
| Message-ID | <e6d360f4-cb36-4759-b7d4-98ebbd87342e@googlegroups.com> |
| In reply to | #11950 |
On Wednesday, March 22, 2017 at 11:42:05 AM UTC-5, Ben Bacarisse wrote: > peteolcott <peterolcott> writes: > > > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote: > >> peteolcott <peterolcott> writes: > >> > >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote: > >> >> peteolcott <peterolcott> writes: > >> >> > >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote: > >> <snip> > >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^ > >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to > >> >> >> understand. > >> >> > > >> >> > You and Linz are both incorrect on this. > >> >> > >> >> Not so. It is so by definition. > >> > > >> > I both you and Linz agreed that all of the square circles are blue in > >> > color you would be wrong. You and Linz said that H^ and H' behave the > >> > same way and they don't behave the same way. > >> > >> Neither of us say that. I know you have some trouble with this > >> material, but do you really not understand how H^ is defined? > > > > There you are not being precise enough with words again. Although > > H^ is defined to have a superset of the states of H' this does not > > logically entail that H^ ever actually behaves like H'. A simple > > linear execution trace shows that H^ would never reach the H' states. > > Because of this H^ and H" never have the same behavior. > > Since you don't yet know what H^ is (and you are steadfastly refusing to > write out an example so you can see) you can't have a trace of H^. You > need to know what the machine is first. It's probably significant that > you never read that chapter of the book. > Every Halting Problem counter-example instance that copies its input has the same infinitely recursive process of copying its input, I showed this step by step in my other post. // Corrected H^ source (second q0 changed to qc) from page 319 // H^ is created from H’ by prepending steps that copy its input =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞ =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn Every state transition above is an H^ state transition. I removed the tape configuration and inserted the qy state back in. Here is the common prefix of state transtions: =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ (1) H^ begins at state q0 with Wm (a TMD of itself) as input. (2) H^ copies its input and transitions to qc. (3) H^ begins processing Wm Wm a pair of TMD copies of itself. (4) H^ does whatever it does to decide halting for Wm Wm. H^ might flip a coin or pray to its creator. The algorithmic thing to do is to determine that actual execution trace of its input. The simplest possible execution trace is to simply execute all of the steps of H^ Wm Wm acting as an interpreter for its first Wm. If H^ simply acts as an interpreter for its input then: (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input. (2) Wm copies its own input and transitions to its own qc. (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself. (4) Wm does whatever it does to decide halting for Wm2 Wm2. Since H^ is acting simply as an interpreter of its input Wm Wm (TMD copies of itself) then H^ would begin interpreting Wm2 Wm2 on and on as infinite recursion. https://philpapers.org/archive/PETMTT-4.pdf (1) Liar Paradox (2) Truth Teller Paradox (3) Kurt Gödel’s (1931) first incompleteness theorem For the above three we are simply done. The Minimal Theory of Types formalizes the underlying semantic meaning of their propositional variables using Rudolf Carnap (1952) Meaning Postulates proving that these propositional variables are not truth bearers. Carnap formalized some of the semantics of natural language. I formalized the semantics of formal language. The Minimal Theory of Types provided the means to formalize the semantic meaning of formal language variables representing formal language abstractions. This formalization shows the precise error of the Liar Paradox, Truth Teller, Gödel’s incompleteness theorem. When a math formula gets stuck in an infinite evaluation loop, the this math formula is simply incorrect. A Turing Machine has more intelligence. A TM could possibly detect that its input specifies and infinitely recursive evaluation. A TM would not necessarily be required to fully process this infinite set of inputs. > Anyway, you feel free to correct my wording below to make it as precise > as you need it. Don't however, invent your own flawed H^. That shows > nothing. There are lots of ways to fail to prove the halting theorem > and you are currently fixated on just one of them -- your current > misunderstanding of how H^ is defined. > > <snip> > >> Anyway, if you can't correct the proof (it's a tiny detail in notation) > >> I can fix it for you. Linz meant to say > >> > >> "From H' we construct another Turing machine H^. This new machine > >> takes as input wM and copies it, ending in what was the initial state > >> of H' qx. After that it behaves like H'. Then the action of H^ is > >> such that > > > > Yet H^ does not actually behave like H' because H^ has an infinitely > > recursive structure that H' does not have. > > Why don't you do the exercise I suggested? Are you worried that you'll > see that H^ is not at all what you want to think it is? I don't think > you'll understand until you do this exercise. > > >> q0 wM |-*H^ qx wM wM |-*H^ oo > >> > >> if M applied to wM halts, and > >> > >> q0 wM |-*H^ qx wM wM |-*H^ y1 qn y2 > >> > >> if M applied to wM does not halt." > >> > >> See? Fixed. The proof is fine. > > > > The bug is fixed so that H^ does not copy its input in an infinite > > loop. > > Exactly. That was the error in Linz notation (though the text made it > clear). > > > Now like every other definition of the Halting Problem counter-example > > it is stuck copying its input in infinite recursion. > > Nope. If you did the exercise you would see that it does not. I am > beginning to think you are are too frightened to do it I just did it. I am pretty sure that this is several times now that I did it. I tried to make this one more clear. > because you might > suddenly see that the H^ construction is trivial and not at all what you > think it is. Go on, do it! It should take only a few minutes, though > you might have to read a few pages of chapter 9 to see what a Turing > machine actually is. > > <snip> > >> > // State transitions of H^ > >> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞ > >> > |--q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2 > >> > >> No, you are still confusing the notation for machine configurations and > >> the notation for the actual Turing machine. You can write a TM using > >> the |- notation (note: without the star) so feel free to do it that way > >> if you like. > > > > regular expression syntax: > > |- exactly one state transition > > |-+ one or more state transitions > > |-* zero or more (an arbitrary number) of state transitions > > That is correct. But explaining to me something I know won't help you > understand how to define a Turing machine. As I said, you could define > H' and H^ from my example H using the |- notation. Do it that way if > you find it easier. > > >> Shall I do H' for you and then you can try H^? If you want me to do > >> that, what state names should I use so you won't pretend to not > >> understand? > > Are you sure you don't need some help? I'll write out H' using the |- > notation is that would make you happier. It's much more involved than > simple defining H' (because the notation has to name the parts of the > tape that are not involved in the transition) but it can be done that > way. > > -- > Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-25 01:11 +0000 |
| Message-ID | <87y3vu6tyf.fsf@bsb.me.uk> |
| In reply to | #11951 |
peteolcott <peterolcott2@gmail.com> writes: > On Wednesday, March 22, 2017 at 11:42:05 AM UTC-5, Ben Bacarisse wrote: >> peteolcott <peterolcott> writes: >> >> > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote: >> >> peteolcott <peterolcott> writes: >> >> >> >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote: >> >> >> peteolcott <peterolcott> writes: >> >> >> >> >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote: >> >> <snip> >> >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^ >> >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to >> >> >> >> understand. >> >> >> > >> >> >> > You and Linz are both incorrect on this. >> >> >> >> >> >> Not so. It is so by definition. >> >> > >> >> > I both you and Linz agreed that all of the square circles are blue in >> >> > color you would be wrong. You and Linz said that H^ and H' behave the >> >> > same way and they don't behave the same way. >> >> >> >> Neither of us say that. I know you have some trouble with this >> >> material, but do you really not understand how H^ is defined? >> > >> > There you are not being precise enough with words again. Although >> > H^ is defined to have a superset of the states of H' this does not >> > logically entail that H^ ever actually behaves like H'. A simple >> > linear execution trace shows that H^ would never reach the H' states. >> > Because of this H^ and H" never have the same behavior. >> >> Since you don't yet know what H^ is (and you are steadfastly refusing to >> write out an example so you can see) you can't have a trace of H^. You >> need to know what the machine is first. It's probably significant that >> you never read that chapter of the book. > > Every Halting Problem counter-example instance that copies its input > has the same infinitely recursive process of copying its input, If you did the exercise you'd see this is not the case. Is that why you won't do it? If you wrote out an actual H^ you could see what it does. It would be clear there is no "infinitely recursive process of copying its input". > I showed this step by step in my other post. > > // Corrected H^ source (second q0 changed to qc) from page 319 > // H^ is created from H’ by prepending steps that copy its input > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞ > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn > > Every state transition above is an H^ state transition. I removed the > tape configuration and inserted the qy state back in. You don't understand this notation. The wrong above right like is not. That's how your garbled use of the notation reads to me. You can't see it because you use mathematical symbols in a sort of poetic way -- your string them together in the hope of conveying some meaning. Hand-waving is all very well in English, but the halting theorem is an exact statement about precisely defined entities. It's ludicrous to try to refute it when you don't even know the being nation used. Just go back to waffling about ill-formed questions and you can be wrong in way that no one will ever care about. > Here is the common prefix of state transtions: > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ > > (1) H^ begins at state q0 with Wm (a TMD of itself) as input. > (2) H^ copies its input and transitions to qc. > (3) H^ begins processing Wm Wm a pair of TMD copies of itself. > (4) H^ does whatever it does to decide halting for Wm Wm. Kind of. From step 3, H^ behaves as H', and H' starts by behaving like H so what happens form step three is best described in terms of what H' and H do. None of the extra states added when making H^ play any role after step 2. You'd know this if came clean and said what qc actually is. And you'd know it if you did the exercise I suggested. > H^ might flip a coin or pray to its creator. No, a TM can't do either of these things. > The algorithmic thing to > do is to determine that actual execution trace of its input. > > The simplest possible execution trace is to simply execute all of the > steps of H^ Wm Wm acting as an interpreter for its first Wm. No, if you did the exercise you'd see a much simpler possible execution trace. Why won't you do it? > If H^ simply acts as an interpreter for its input then: > > (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input. > (2) Wm copies its own input and transitions to its own qc. > (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself. > (4) Wm does whatever it does to decide halting for Wm2 Wm2. For some H, H^ will do this. But the construction of H^ lets one deduce something about H' and then about H from this behaviour. That's a crucial part of the argument. I don't think you know how to do that, because you've got stuck in a loop of your own. <snip> >> > Now like every other definition of the Halting Problem counter-example >> > it is stuck copying its input in infinite recursion. >> >> Nope. If you did the exercise you would see that it does not. I am >> beginning to think you are are too frightened to do it > > I just did it. I am pretty sure that this is several times now that I did it. > I tried to make this one more clear. Please, that just makes you look silly. You didn't even know what Linz's notation for a TM meant, so you could not even understand the machine I wrote much less construct two others form it. Doing this exercise would involve writing down a TM and that would mean reading at least a bit of Chapter 9. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-25 08:09 -0700 |
| Message-ID | <9a40ad14-9263-4fad-aaf7-ee8ced10e7ae@googlegroups.com> |
| In reply to | #11956 |
On Friday, March 24, 2017 at 8:11:54 PM UTC-5, Ben Bacarisse wrote:
> peteolcott <peterolcott> writes:
>
> > On Wednesday, March 22, 2017 at 11:42:05 AM UTC-5, Ben Bacarisse wrote:
> >> peteolcott <peterolcott> writes:
> >>
> >> > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote:
> >> >> peteolcott <peterolcott> writes:
> >> >>
> >> >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
> >> >> >> peteolcott <peterolcott> writes:
> >> >> >>
> >> >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:
> >> >> <snip>
> >> >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^
> >> >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to
> >> >> >> >> understand.
> >> >> >> >
> >> >> >> > You and Linz are both incorrect on this.
> >> >> >>
> >> >> >> Not so. It is so by definition.
> >> >> >
> >> >> > I both you and Linz agreed that all of the square circles are blue in
> >> >> > color you would be wrong. You and Linz said that H^ and H' behave the
> >> >> > same way and they don't behave the same way.
> >> >>
> >> >> Neither of us say that. I know you have some trouble with this
> >> >> material, but do you really not understand how H^ is defined?
> >> >
> >> > There you are not being precise enough with words again. Although
> >> > H^ is defined to have a superset of the states of H' this does not
> >> > logically entail that H^ ever actually behaves like H'. A simple
> >> > linear execution trace shows that H^ would never reach the H' states.
> >> > Because of this H^ and H" never have the same behavior.
> >>
> >> Since you don't yet know what H^ is (and you are steadfastly refusing to
> >> write out an example so you can see) you can't have a trace of H^. You
> >> need to know what the machine is first. It's probably significant that
> >> you never read that chapter of the book.
> >
> > Every Halting Problem counter-example instance that copies its input
> > has the same infinitely recursive process of copying its input,
>
> If you did the exercise you'd see this is not the case. Is that why you
> won't do it? If you wrote out an actual H^ you could see what it does.
> It would be clear there is no "infinitely recursive process of copying
> its input".
Because H^ contains unspecified sequences of state transitions |-*
an infinite number of different configurations of H^ are specified.
Within the single element of this infinite set where H^ acts as and interpreter (UTM) and simply executes its input state by state, H^ and its input unequivocally specify infinitely recursive input.
I will probably have to formalize this with my brand new (as of March 10, 2017) Minimal Type Theory or it will be too difficult for you to see this.
>
> > I showed this step by step in my other post.
> >
> > // Corrected H^ source (second q0 changed to qc) from page 319
> > // H^ is created from H’ by prepending steps that copy its input
> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn
> >
> > Every state transition above is an H^ state transition. I removed the
> > tape configuration and inserted the qy state back in.
>
> You don't understand this notation.
> The wrong above right like is not.
Have no idea what you are saying here.
Give me a quote of what you mean by: {above right}.
The {above right} is not what?
> That's how your garbled use of the notation reads to me. You can't see
> it because you use mathematical symbols in a sort of poetic way -- your
> string them together in the hope of conveying some meaning.
You did not notice that the above is a direct quote from Linz?
(I did remove the tape symbols y1, y2 from this direct quote)
(I also added back in the qy state shown it the diagram).
>
> Hand-waving is all very well in English, but the halting theorem is an
> exact statement about precisely defined entities. It's ludicrous to try
> to refute it when you don't even know the being nation used. Just go
> back to waffling about ill-formed questions and you can be wrong in way
> that no one will ever care about.
>
> > Here is the common prefix of state transtions:
> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^
> >
> > (1) H^ begins at state q0 with Wm (a TMD of itself) as input.
> > (2) H^ copies its input and transitions to qc.
> > (3) H^ begins processing Wm Wm a pair of TMD copies of itself.
> > (4) H^ does whatever it does to decide halting for Wm Wm.
>
> Kind of. From step 3, H^ behaves as H', and H' starts by behaving like
> H
Yes at the exact point of step (3) we are at the start state of both H' and H.
> so what happens from step three is best described in terms of what H'
> and H do.
No. Neither H' nor H are exactly H^ and neither H' nor H have (H^, H^) as their input. When H^ begins to analyze its input, its input has an entirely different start state than either H' or H. (All three machines name their start state q0).
> None of the extra states added when making H^ play any role
> after step 2. You'd know this if came clean and said what qc actually
> is. And you'd know it if you did the exercise I suggested.
>
> > H^ might flip a coin or pray to its creator.
>
> No, a TM can't do either of these things.
>
> > The algorithmic thing to
> > do is to determine that actual execution trace of its input.
> >
> > The simplest possible execution trace is to simply execute all of the
> > steps of H^ Wm Wm acting as an interpreter for its first Wm.
>
> No, if you did the exercise you'd see a much simpler possible execution
> trace. Why won't you do it?
>
> > If H^ simply acts as an interpreter for its input then:
> >
> > (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input.
> > (2) Wm copies its own input and transitions to its own qc.
> > (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself.
> > (4) Wm does whatever it does to decide halting for Wm2 Wm2.
>
> For some H, H^ will do this.
I have only been talking about the single instance of H^ being executed with a TMD of itself as its input, thus there is no H' nor H, only H^.
> But the construction of H^ lets one deduce
> something about H' and then about H from this behaviour. That's a
> crucial part of the argument. I don't think you know how to do that,
> because you've got stuck in a loop of your own.
I cannot understand why you keep jumping around and changing the subject away from H^ to either H' or H. I am only talking about H^ being executed with a TMD of itself as its input.
>
> <snip>
> >> > Now like every other definition of the Halting Problem counter-example
> >> > it is stuck copying its input in infinite recursion.
> >>
> >> Nope. If you did the exercise you would see that it does not. I am
> >> beginning to think you are are too frightened to do it
> >
> > I just did it. I am pretty sure that this is several times now that I did it.
> > I tried to make this one more clear.
>
> Please, that just makes you look silly. You didn't even know what
> Linz's notation for a TM meant,
Bullshit.
<snip>
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-25 21:58 +0000 |
| Message-ID | <87h92h6msz.fsf@bsb.me.uk> |
| In reply to | #11957 |
peteolcott <peterolcott2@gmail.com> writes:
> On Friday, March 24, 2017 at 8:11:54 PM UTC-5, Ben Bacarisse wrote:
>> peteolcott <peterolcott> writes:
>>
>> > On Wednesday, March 22, 2017 at 11:42:05 AM UTC-5, Ben Bacarisse wrote:
>> >> peteolcott <peterolcott> writes:
>> >>
>> >> > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote:
>> >> >> peteolcott <peterolcott> writes:
>> >> >>
>> >> >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote:
>> >> >> >> peteolcott <peterolcott> writes:
>> >> >> >>
>> >> >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote:
>> >> >> <snip>
>> >> >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^
>> >> >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to
>> >> >> >> >> understand.
>> >> >> >> >
>> >> >> >> > You and Linz are both incorrect on this.
>> >> >> >>
>> >> >> >> Not so. It is so by definition.
>> >> >> >
>> >> >> > I both you and Linz agreed that all of the square circles are blue in
>> >> >> > color you would be wrong. You and Linz said that H^ and H' behave the
>> >> >> > same way and they don't behave the same way.
>> >> >>
>> >> >> Neither of us say that. I know you have some trouble with this
>> >> >> material, but do you really not understand how H^ is defined?
>> >> >
>> >> > There you are not being precise enough with words again. Although
>> >> > H^ is defined to have a superset of the states of H' this does not
>> >> > logically entail that H^ ever actually behaves like H'. A simple
>> >> > linear execution trace shows that H^ would never reach the H' states.
>> >> > Because of this H^ and H" never have the same behavior.
>> >>
>> >> Since you don't yet know what H^ is (and you are steadfastly refusing to
>> >> write out an example so you can see) you can't have a trace of H^. You
>> >> need to know what the machine is first. It's probably significant that
>> >> you never read that chapter of the book.
>> >
>> > Every Halting Problem counter-example instance that copies its input
>> > has the same infinitely recursive process of copying its input,
>>
>> If you did the exercise you'd see this is not the case. Is that why you
>> won't do it? If you wrote out an actual H^ you could see what it does.
>> It would be clear there is no "infinitely recursive process of copying
>> its input".
>
> Because H^ contains unspecified sequences of state transitions |-*
> an infinite number of different configurations of H^ are specified.
The only way you will be able to stop believing this is to do the
exercise I suggested. You'll then see, clear as day, an H^ with no
unspecified sequences of state transitions and only a finite number of
configurations (for any given tape, of course -- even the degenerate 1
state TM has infinite configurations if you include all the possible
tapes it can be started with).
> Within the single element of this infinite set where H^ acts as and
> interpreter (UTM) and simply executes its input state by state, H^ and
> its input unequivocally specify infinitely recursive input.
Pure fantasy. H^ can behave in many ways -- most of which you have
never even imagined.
> I will probably have to formalize this with my brand new (as of March
> 10, 2017) Minimal Type Theory or it will be too difficult for you to
> see this.
Note that if you succeed in proving what you say it will immediately
show your Minimal Type Theory to be faulty.
>> > I showed this step by step in my other post.
>> >
>> > // Corrected H^ source (second q0 changed to qc) from page 319
>> > // H^ is created from H’ by prepending steps that copy its input
>> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
>> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn
>> >
>> > Every state transition above is an H^ state transition. I removed the
>> > tape configuration and inserted the qy state back in.
>>
>> You don't understand this notation.
>
>> The wrong above right like is not.
> Have no idea what you are saying here.
> Give me a quote of what you mean by: {above right}.
> The {above right} is not what?
Exactly. It's garbled isn't it? Exactly like your garbled use of
Linz's notation. I just wanted to show you what
q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞
looks like to someone who understand the language it's written in.
>> That's how your garbled use of the notation reads to me. You can't see
>> it because you use mathematical symbols in a sort of poetic way -- your
>> string them together in the hope of conveying some meaning.
>
> You did not notice that the above is a direct quote from Linz?
It isn't.
> (I did remove the tape symbols y1, y2 from this direct quote)
> (I also added back in the qy state shown it the diagram).
Ah. Here, then, is a direct quote from you:
"See my 1.5 page incorrect refutation of the Incompleteness Theorem and
maybe you will begin to understand how silly I am."
(I did change a couple of things but I don't think they matter.)
<snip>
>> > Here is the common prefix of state transtions:
>> > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^
>> >
>> > (1) H^ begins at state q0 with Wm (a TMD of itself) as input.
>> > (2) H^ copies its input and transitions to qc.
>> > (3) H^ begins processing Wm Wm a pair of TMD copies of itself.
>> > (4) H^ does whatever it does to decide halting for Wm Wm.
>>
>> Kind of. From step 3, H^ behaves as H', and H' starts by behaving like
>> H
>
> Yes at the exact point of step (3) we are at the start state of both
> H' and H.
Odd, then, that you rejected all my attempts to make that clear. You
flat-out refused to state that qc is the start state of H and H'. I
think you just say things based on the immediate context without any
memory of what you've said or claimed before.
Anyway, I'm, glad we now agree on what qc stands for (though I think you
contradict yourself below).
>> so what happens from step three is best described in terms of what H'
>> and H do.
>
> No. Neither H' nor H are exactly H^ and neither H' nor H have (H^, H^)
> as their input. When H^ begins to analyze its input, its input has an
> entirely different start state than either H' or H. (All three
> machines name their start state q0).
Nonsense (literally and figuratively). Do the exercise and you'll see.
You simply don't know how to use Linz's notation. I don't see any value
in my explaining it again and I'm sure you won't ever do the simple
exercise so I think you are doomed to stay in this loop indefinitely.
<snip>
>> > If H^ simply acts as an interpreter for its input then:
>> >
>> > (1) Wm begins at its own state q0 with Wm (a TMD of itself) as input.
>> > (2) Wm copies its own input and transitions to its own qc.
>> > (3) Wm begins processing Wm2 Wm2 a pair of TMD copies of itself.
>> > (4) Wm does whatever it does to decide halting for Wm2 Wm2.
>>
>> For some H, H^ will do this.
>
> I have only been talking about the single instance of H^ being
> executed with a TMD of itself as its input, thus there is no H' nor H,
> only H^.
You need to find someone locally who can read what you write and help
you out. I'm sure you wouldn't believe me if I told you what you've
just said, and I doubt that re-reading it will make you see how absurd
it is.
>> But the construction of H^ lets one deduce
>> something about H' and then about H from this behaviour. That's a
>> crucial part of the argument. I don't think you know how to do that,
>> because you've got stuck in a loop of your own.
>
> I cannot understand why you keep jumping around and changing the
> subject away from H^ to either H' or H. I am only talking about H^
> being executed with a TMD of itself as its input.
Because it's what H^ does -- it copies its input and then behaves like
H'. You can't get anywhere until you stop jumping around and grasp that
basic definition. If you did the exercise, you might see.
>> <snip>
>> >> > Now like every other definition of the Halting Problem counter-example
>> >> > it is stuck copying its input in infinite recursion.
>> >>
>> >> Nope. If you did the exercise you would see that it does not. I am
>> >> beginning to think you are are too frightened to do it
>> >
>> > I just did it. I am pretty sure that this is several times now that I did it.
>> > I tried to make this one more clear.
>>
>> Please, that just makes you look silly. You didn't even know what
>> Linz's notation for a TM meant,
>
> Bullshit.
Great! So you do understand his notation for a TM? There is nothing
stopping you from doing the exercise then. If you don't want to use my
H, write out your own.
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-27 06:18 -0700 |
| Message-ID | <0d499750-aafc-456f-95aa-973504c26bb2@googlegroups.com> |
| In reply to | #11958 |
On Saturday, March 25, 2017 at 4:58:39 PM UTC-5, Ben Bacarisse wrote: > peteolcott <peterolcott> writes: > > > On Friday, March 24, 2017 at 8:11:54 PM UTC-5, Ben Bacarisse wrote: > >> peteolcott <peterolcott> writes: > >> > >> > On Wednesday, March 22, 2017 at 11:42:05 AM UTC-5, Ben Bacarisse wrote: > >> >> peteolcott <peterolcott> writes: > >> >> > >> >> > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote: > >> >> >> peteolcott <peterolcott> writes: > >> >> >> > >> >> >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote: > >> >> >> >> peteolcott <peterolcott> writes: > >> >> >> >> > >> >> >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote: > >> >> >> <snip> > >> >> >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^ > >> >> >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to > >> >> >> >> >> understand. > >> >> >> >> > > >> >> >> >> > You and Linz are both incorrect on this. > >> >> >> >> > >> >> >> >> Not so. It is so by definition. > >> >> >> > > >> >> >> > I both you and Linz agreed that all of the square circles are blue in > >> >> >> > color you would be wrong. You and Linz said that H^ and H' behave the > >> >> >> > same way and they don't behave the same way. > >> >> >> > >> >> >> Neither of us say that. I know you have some trouble with this > >> >> >> material, but do you really not understand how H^ is defined? > >> >> > > >> >> > There you are not being precise enough with words again. Although > >> >> > H^ is defined to have a superset of the states of H' this does not > >> >> > logically entail that H^ ever actually behaves like H'. A simple > >> >> > linear execution trace shows that H^ would never reach the H' states. > >> >> > Because of this H^ and H" never have the same behavior. > >> >> > >> >> Since you don't yet know what H^ is (and you are steadfastly refusing to > >> >> write out an example so you can see) you can't have a trace of H^. You > >> >> need to know what the machine is first. It's probably significant that > >> >> you never read that chapter of the book. > >> > > >> > Every Halting Problem counter-example instance that copies its input > >> > has the same infinitely recursive process of copying its input, > >> > >> If you did the exercise you'd see this is not the case. Is that why you > >> won't do it? If you wrote out an actual H^ you could see what it does. > >> It would be clear there is no "infinitely recursive process of copying > >> its input". > > > > Because H^ contains unspecified sequences of state transitions |-* > > an infinite number of different configurations of H^ are specified. > > The only way you will be able to stop believing this I do not stop believing verifiable facts. That you propose that I should seems to show very sloppy reasoning on your part. The |-* symbols specifies an infinite set different different state transitions. > is to do the > exercise I suggested. You'll then see, clear as day, an H^ with no > unspecified sequences of state transitions and only a finite number of > configurations (for any given tape, of course -- even the degenerate 1 > state TM has infinite configurations if you include all the possible > tapes it can be started with). The single state tape may have an infinite number of different states yet only a single execution trace. > > > Within the single element of this infinite set where H^ acts as and > > interpreter (UTM) and simply executes its input state by state, H^ and > > its input unequivocally specify infinitely recursive input. > > Pure fantasy. H^ can behave in many ways -- most of which you have > never even imagined. It looks like you cannot imagine it simply as an (UTM) interpreter. If you could then the execution trace that I propose would be a syntactic logical consequence from this premise. > > > I will probably have to formalize this with my brand new (as of March > > 10, 2017) Minimal Type Theory or it will be too difficult for you to > > see this. > > Note that if you succeed in proving what you say it will immediately > show your Minimal Type Theory to be faulty. You lack the imagination to follow the execution trace of H^ where the |-* wildcard states cause H^ to only be a UTM interpreter of its input. We cannot proceed until you understand the execution trace of H^ in the context that its |-* specify H^ as only a UTM interpreter of its input. This is a mandatory prerequisite. <snip>
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-27 22:20 +0100 |
| Message-ID | <87r31i4dsf.fsf@bsb.me.uk> |
| In reply to | #11962 |
peteolcott <peterolcott2@gmail.com> writes: <snip> > I do not stop believing verifiable facts. That you propose that I > should seems to show very sloppy reasoning on your part. The |-* > symbols specifies an infinite set different different state > transitions. Nope. There's no point in my trying to explain it because it's just the simplest matter of nation. Linz explains it as clearly as I could and you don't yet know what it means so I don't think there's much hope. Here's a fact you might like to ponder. If I write q0 |-*M qx (the M is a subscript, of course) I am *always* describing a finite sequence of transitions. I wonder if you agree. When you are inclined to deepen your understanding, you could try to write out a few simple machines as I suggested. Building H' and H^ from the H I gave would be a good start. > On Saturday, March 25, 2017 at 4:58:39 PM UTC-5, Ben Bacarisse wrote: >> is to do the >> exercise I suggested. You'll then see, clear as day, an H^ with no >> unspecified sequences of state transitions and only a finite number of >> configurations (for any given tape, of course -- even the degenerate 1 >> state TM has infinite configurations if you include all the possible >> tapes it can be started with). > > The single state tape may have an infinite number of different states > yet only a single execution trace. Nonsense. Do you really expect to be taken seriously when you write such things? Am I supposed to try to tease out your meaning from this abuse of technical terms? I've ploughed though a lot of mediocre exam answers so I can guess what you might mean, but why should I bother? >> peteolcott <peterolcott> writes: >> > Within the single element of this infinite set where H^ acts as and >> > interpreter (UTM) and simply executes its input state by state, H^ and >> > its input unequivocally specify infinitely recursive input. >> >> Pure fantasy. H^ can behave in many ways -- most of which you have >> never even imagined. > > It looks like you cannot imagine it simply as an (UTM) interpreter. > If you could then the execution trace that I propose would be a syntactic > logical consequence from this premise. This displays a serious flaw in your reasoning. Since you obviously don't follow yet, here's the gist of the exchange: you: ...where H^ acts like a UTM ... me: H^ can act in many ways. you: You obviously can't imagine H^ acting like a UTM. Do you see the problem? <snip> > We cannot proceed until you understand the execution trace of H^ > in the context that its |-* specify H^ as only a UTM interpreter > of its input. This is a mandatory prerequisite. I think it would be better to start with you showing me you know how to write out a TM. Try, for example constructing H' from the H I gave you. I don't think you can do H^ yet, but you might get there eventually once you know how to write a TM. Then I might try to explain why the behaviour of H^ in the one case you have become obsessed with is of no consequence to a theorem about a general and unspecified H. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-28 15:33 -0700 |
| Message-ID | <63bd12eb-60cd-4bde-90e5-9d6f562b5b9f@googlegroups.com> |
| In reply to | #11963 |
On Monday, March 27, 2017 at 4:20:51 PM UTC-5, Ben Bacarisse wrote: > peteolcott <peterolcott> writes: > > <snip> > > I do not stop believing verifiable facts. That you propose that I > > should seems to show very sloppy reasoning on your part. The |-* > > symbols specifies an infinite set different different state > > transitions. > > Nope. There's no point in my trying to explain it because it's just the > simplest matter of nation. Linz explains it as clearly as I could and > you don't yet know what it means so I don't think there's much hope. > > Here's a fact you might like to ponder. If I write > > q0 |-*M qx > > (the M is a subscript, of course) I am *always* describing a finite > sequence of transitions. I wonder if you agree. > > When you are inclined to deepen your understanding, you could try to > write out a few simple machines as I suggested. Building H' and H^ from > the H I gave would be a good start. > > > On Saturday, March 25, 2017 at 4:58:39 PM UTC-5, Ben Bacarisse wrote: > > >> is to do the > >> exercise I suggested. You'll then see, clear as day, an H^ with no > >> unspecified sequences of state transitions and only a finite number of > >> configurations (for any given tape, of course -- even the degenerate 1 > >> state TM has infinite configurations if you include all the possible > >> tapes it can be started with). > > > > The single state tape may have an infinite number of different states > > yet only a single execution trace. > > Nonsense. Do you really expect to be taken seriously when you write > such things? A said that incorrectly. A single state tape can have an infinite number of different configurations because the tape is an aspect of its configuration. > Am I supposed to try to tease out your meaning from this > abuse of technical terms? I've ploughed though a lot of mediocre exam > answers so I can guess what you might mean, but why should I bother? > > >> peteolcott <peterolcott> writes: > > >> > Within the single element of this infinite set where H^ acts as and > >> > interpreter (UTM) and simply executes its input state by state, H^ and > >> > its input unequivocally specify infinitely recursive input. > >> > >> Pure fantasy. H^ can behave in many ways -- most of which you have > >> never even imagined. > > > > It looks like you cannot imagine it simply as an (UTM) interpreter. > > If you could then the execution trace that I propose would be a syntactic > > logical consequence from this premise. > > This displays a serious flaw in your reasoning. Since you obviously > don't follow yet, here's the gist of the exchange: > > you: ...where H^ acts like a UTM ... > me: H^ can act in many ways. > you: You obviously can't imagine H^ acting like a UTM. > > Do you see the problem? If we begin with the single premise (of an infinite set of premises) that H^ acts as a UTM and simply executes its input, then (within this single premise) H^ has an infinitely recursive specification. > > <snip> > > We cannot proceed until you understand the execution trace of H^ > > in the context that its |-* specify H^ as only a UTM interpreter > > of its input. This is a mandatory prerequisite. > > I think it would be better to start with you showing me you know how to > write out a TM. Try, for example constructing H' from the H I gave > you. I don't think you can do H^ yet, but you might get there > eventually once you know how to write a TM. > ~~ Corrected H^ abbreviated state transitions from quoted from page 319 ~~ q0 Wm |-* H^ qc Wm Wm |-* H^ ∞ ~~ q0 Wm |-* H^ qc Wm Wm |-* H^ y1 qn y2 [Tape Location]---[Machine State]---[Linz notation]---[Action] Tape01--State00 q0 Wm goto 001 // Wm is at Tape09 Tape02--State01 |-* copy input goto 002 Tape03--State02 qc Wm Wm goto 003 Tape04--State03 |-* process copied input then goto 004 or 007 Tape05--State04 qy goto 005 Tape06--State05 qa goto 006 Tape07--State06 qb goto 005 Tape08--State07 qn Tape09--State00 q0 Wm goto 001 Tape10--State01 |-* copy input goto 002 Tape11--State02 qc Wm Wm goto 003 Tape12--State03 |-* process copied input then goto 004 or 007 Tape13--State04 qy goto 005 Tape14--State05 qa goto 006 Tape15--State06 qb goto 005 Tape16--State07 qn The above is a pseudo Turing Machine Description of H^ configured with a copy of itself as its own input beginning at Tape location Tape09. > Then I might try to explain why the behaviour of H^ in the one case you > have become obsessed with is of no consequence to a theorem about a > general and unspecified H. > > -- > Ben. The behavior of the one case that I am focusing on is the reason why Kurt Gödel's first incompleteness theorem is incorrect, as I have proven in my paper. Three online sources of my paper: https://philpapers.org/archive/PETMTT-4.pdf https://www.researchgate.net/publication/315367846_Minimal_Type_Theory_MTT http://liarparadox.org/Minimal_Type_Theory.pdf
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-29 01:29 +0100 |
| Message-ID | <8737dxvsc1.fsf@bsb.me.uk> |
| In reply to | #11965 |
peteolcott <peterolcott2@gmail.com> writes: > On Monday, March 27, 2017 at 4:20:51 PM UTC-5, Ben Bacarisse wrote: >> peteolcott <peterolcott> writes: >> > On Saturday, March 25, 2017 at 4:58:39 PM UTC-5, Ben Bacarisse wrote: <snip> >> >> is to do the >> >> exercise I suggested. You'll then see, clear as day, an H^ with no >> >> unspecified sequences of state transitions and only a finite number of >> >> configurations (for any given tape, of course -- even the degenerate 1 >> >> state TM has infinite configurations if you include all the possible >> >> tapes it can be started with). >> > >> > The single state tape may have an infinite number of different states >> > yet only a single execution trace. >> >> Nonsense. Do you really expect to be taken seriously when you write >> such things? > > A said that incorrectly. A single state tape can have an infinite > number of different configurations because the tape is an aspect of > its configuration. Still nonsense. Do you mean "a single state TM"? If so you are just saying what I said. If not, what is a "single state tape"? <snip> >> > It looks like you cannot imagine it simply as an (UTM) interpreter. >> > If you could then the execution trace that I propose would be a syntactic >> > logical consequence from this premise. >> >> This displays a serious flaw in your reasoning. Since you obviously >> don't follow yet, here's the gist of the exchange: >> >> you: ...where H^ acts like a UTM ... >> me: H^ can act in many ways. >> you: You obviously can't imagine H^ acting like a UTM. >> >> Do you see the problem? > > If we begin with the single premise (of an infinite set of premises) > that H^ acts as a UTM and simply executes its input, then (within this > single premise) H^ has an infinitely recursive specification. So what? If you start with this premise your conclusions will be contingent on it. No one doubts that *some* H^ behave like this. Linz shows that *no* H^ behaves as if were derived from a halting decider. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2017-03-25 19:57 -0700 |
| Message-ID | <349ade46-cad2-4a14-8caa-adce928270d5@googlegroups.com> |
| In reply to | #11956 |
On Friday, March 24, 2017 at 8:11:54 PM UTC-5, Ben Bacarisse wrote: > peteolcott <peterolcott> writes: > > > On Wednesday, March 22, 2017 at 11:42:05 AM UTC-5, Ben Bacarisse wrote: > >> peteolcott <peterolcott> writes: > >> > >> > On Tuesday, March 21, 2017 at 2:47:06 PM UTC-5, Ben Bacarisse wrote: > >> >> peteolcott <peterolcott> writes: > >> >> > >> >> > On Monday, March 20, 2017 at 1:07:53 PM UTC-5, Ben Bacarisse wrote: > >> >> >> peteolcott <peterolcott> writes: > >> >> >> > >> >> >> > On Saturday, March 18, 2017 at 4:35:57 PM UTC-5, Ben Bacarisse wrote: > >> >> <snip> > >> >> >> >> They are Linz's words not mine; that's why I put them in quotes. H^ > >> >> >> >> copies it's input an *then* behaves exactly like H'. It's not hard to > >> >> >> >> understand. > >> >> >> > > >> >> >> > You and Linz are both incorrect on this. > >> >> >> > >> >> >> Not so. It is so by definition. > >> >> > > >> >> > I both you and Linz agreed that all of the square circles are blue in > >> >> > color you would be wrong. You and Linz said that H^ and H' behave the > >> >> > same way and they don't behave the same way. > >> >> > >> >> Neither of us say that. I know you have some trouble with this > >> >> material, but do you really not understand how H^ is defined? > >> > > >> > There you are not being precise enough with words again. Although > >> > H^ is defined to have a superset of the states of H' this does not > >> > logically entail that H^ ever actually behaves like H'. A simple > >> > linear execution trace shows that H^ would never reach the H' states. > >> > Because of this H^ and H" never have the same behavior. > >> > >> Since you don't yet know what H^ is (and you are steadfastly refusing to > >> write out an example so you can see) you can't have a trace of H^. You > >> need to know what the machine is first. It's probably significant that > >> you never read that chapter of the book. > > > > Every Halting Problem counter-example instance that copies its input > > has the same infinitely recursive process of copying its input, > > If you did the exercise you'd see this is not the case. Is that why you > won't do it? If you wrote out an actual H^ you could see what it does. > It would be clear there is no "infinitely recursive process of copying > its input". > > > I showed this step by step in my other post. > > > > // Corrected H^ source (second q0 changed to qc) from page 319 > > // H^ is created from H’ by prepending steps that copy its input > > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qy ∞ > > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ qn > > > > Every state transition above is an H^ state transition. I removed the > > tape configuration and inserted the qy state back in. > > You don't understand this notation. The wrong above right like is not. > That's how your garbled use of the notation reads to me. You can't see > it because you use mathematical symbols in a sort of poetic way -- your > string them together in the hope of conveying some meaning. > > Hand-waving is all very well in English, but the halting theorem is an > exact statement about precisely defined entities. It's ludicrous to try > to refute it when you don't even know the being nation used. Just go > back to waffling about ill-formed questions and you can be wrong in way > that no one will ever care about. > > > Here is the common prefix of state transtions: > > =>>> q0 Wm |-* H^ qc Wm Wm |-* H^ > > > > (1) H^ begins at state q0 with Wm (a TMD of itself) as input. > > (2) H^ copies its input and transitions to qc. > > (3) H^ begins processing Wm Wm a pair of TMD copies of itself. > > (4) H^ does whatever it does to decide halting for Wm Wm. > > Kind of. From step 3, H^ behaves as H', and H' starts by behaving like > H so what happens form step three is best described in terms of what H' > and H do. None of the extra states added when making H^ play any role > after step 2. You'd know this if came clean and said what qc actually > is. And you'd know it if you did the exercise I suggested. > <snip> .....q0 Wm |-* H^ qc Wm Wm |-* H^ Maybe this make make what I am saying clearer: .....H^ qc Wm Wm |-* I am trying to show one possible execution trace for the |-* wildcard unspecified set of state transitions shown beginning at state qc listed above. It is not that I do not understand what Linz is saying. It is that I am extending my analysis well beyond anything that he said. I will respond to your other message on Monday. I only respond to the prior days messages once a day, and I always take Sunday off to keep the Sabbath Holy. These two rules keep my working on this stuff below 50 hours per week. I spent 1/2 day responding to messages and 1/2 day doing additional analysis and research.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-26 23:53 +0100 |
| Message-ID | <87k27b6460.fsf@bsb.me.uk> |
| In reply to | #11960 |
peteolcott <peterolcott2@gmail.com> writes: <snip> > .....q0 Wm |-* H^ qc Wm Wm |-* H^ > > Maybe this make make what I am saying clearer: > .....H^ qc Wm Wm |-* No, but that's fine. Provided you are saying nothing intelligible there is nothing to correct. > I am trying to show one possible execution trace for the |-* > wildcard unspecified set of state transitions shown beginning > at state qc listed above. If all you want to say now is what H^ *might* do, go ahead. What you said before about what H^ actually did was wrong and that needed correcting. What's certain is that you will never say anything interesting about H^. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-13 03:14 +0000 |
| Message-ID | <8737ehx3zz.fsf@bsb.me.uk> |
| In reply to | #11914 |
peteolcott <peteolcott@gmail.com> writes: I've cut everything I wrote because you decided not to address any of the points. > The key thing to remember is that every instance of H-Hat must > have its own input H-Hat which it copies so that it can evaluate > the execution trace of its input H-Hat on this input H-Hat's > (copy of itself) input H-Hat. This creates an infinite sequence > of copies of H-Hat. No. You once understood this theorem. Why not go back to the proof that you did understand? > The above can be verified by an execution trace of the following > source code: q0 Wm |-* H-Hat q0 Wm Wm... > > H-Hat begins at its start state q0 its with Wm (TMD of H-Hat) > input then |-* through a sequence of steps H-Hat copies its > input and and begins evaluating its input pair: Wm Wm at the > start state q0 of its input Wm (TMD of H-Hat) on its own input > the copied Wm (TMD of H-Hat). > > The execution trace of the initial input Wm (TMD of H-Hat) > shows that it must proceed through the same steps listed > above with its input (the TMD of H-Hat copy of itself). > So it must make a copy of its own input so that the copy > of itself has input. This makes a new copy not shown above. You don't understand either the notion being used or the textual explanation the Linz gives, because this description has nothing to do with the H^ described in the book. It seem you think H^ must execute its description, Wm, as if it were some sort of universal TM. I don't know where you get that from but it's not in Linz and it's not what's H^ does at all. <snip the rest derived from this misunderstanding> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peteolcott@gmail.com> |
|---|---|
| Date | 2017-03-13 07:23 -0700 |
| Message-ID | <8cb5d54a-10a7-48c4-8cb1-fcc81ba7e4d3@googlegroups.com> |
| In reply to | #11916 |
On Sunday, March 12, 2017 at 10:14:09 PM UTC-5, Ben Bacarisse wrote: > peteolcott <peteolcott> writes: > > I've cut everything I wrote because you decided not to address any of > the points. > > > The key thing to remember is that every instance of H-Hat must > > have its own input H-Hat which it copies so that it can evaluate > > the execution trace of its input H-Hat on this input H-Hat's > > (copy of itself) input H-Hat. This creates an infinite sequence > > of copies of H-Hat. > > No. You once understood this theorem. Why not go back to the proof > that you did understand? > > > The above can be verified by an execution trace of the following > > source code: q0 Wm |-* H-Hat q0 Wm Wm... > > > > H-Hat begins at its start state q0 its with Wm (TMD of H-Hat) > > input then |-* through a sequence of steps H-Hat copies its > > input and and begins evaluating its input pair: Wm Wm at the > > start state q0 of its input Wm (TMD of H-Hat) on its own input > > the copied Wm (TMD of H-Hat). > > > > The execution trace of the initial input Wm (TMD of H-Hat) > > shows that it must proceed through the same steps listed > > above with its input (the TMD of H-Hat copy of itself). > > So it must make a copy of its own input so that the copy > > of itself has input. This makes a new copy not shown above. > > You don't understand either the notion being used or the textual > explanation the Linz gives, because this description has nothing to do > with the H^ described in the book. > I did have to make some corrections, yet the essential meaning remains unchanged. H-Hat source code from quoted from page 319 q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞ q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2 Meaning of |-* quoted from page 237 The symbols |-* and |-+ will have the usual meaning of an arbitrary number of moves. Page 319 quote From H' we construct another Turing machine H^. This new machine takes as input WM, copies it, and then behaves exactly like H'. "0 Wm": H^ begins at its own q0 with Wm (TMD of itself) as its input "|-*": H^ proceeds through a number of steps to copy its input "H^ q0 Wm Wm |-*" and then behaves exactly like H' After the corrections that I made it is clear that the infinitely recursive aspect of H^ occurs in the second |-* of the source code when H^ evaluates Wm Wm. This would seem to be a mistake on the original author's part because if H^ did begin again at its actual start state it would then make another copy of its input. So we will correct the Linz notational convention to say this: // We changed the second q0 to qx q0 Wm |-* H^ qx Wm Wm |-* H^ ∞ q0 Wm |-* H^ qx Wm Wm |-* H^ y1 qn y2 So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2) the execution trace of Wm_1 indicates that it makes a copy of Wm_2 which for clarity we will call Wm_3. The next step of the execution trace of Wm_1 indicates that it begins its own evaluation execution trace of Wm_2 Wm_3. The execution trace of Wm_2 indicates that it makes a copy of Wm_3 which for clarity we will call Wm_4. > It seem you think H^ must execute its description, Wm, as if it were > some sort of universal TM. I don't know where you get that from but > it's not in Linz and it's not what's H^ does at all. > There is no need for H^ to be a universal Turing Machine I have no idea how you misconstrued my words to mean that. That the Linz example has H^ use its own description as its input can be verified by this direct quote from page 320: Now H^ is a Turing machine, so that it will have some description in ∑*, say w^. This string, in addition to being the description of H^ can also be used as input string. We can therefore legitimately ask what would happen if H^ is applied to w^. > <snip the rest derived from this misunderstanding> > -- > Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-15 17:12 +0000 |
| Message-ID | <878to6v4za.fsf@bsb.me.uk> |
| In reply to | #11917 |
I'll cut to the chase... peteolcott <peteolcott@gmail.com> writes: <snip> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2) > the execution trace of Wm_1 indicates that it makes a copy of Wm_2 > which for clarity we will call Wm_3. > > The next step of the execution trace of Wm_1 indicates that it begins > its own evaluation execution trace of Wm_2 Wm_3. > > The execution trace of Wm_2 indicates that it makes a copy of Wm_3 > which for clarity we will call Wm_4. None of the Wm have an execution trace. They are stings in the alphabet of the TM H (and H^). The only thing that can have has any "execution trace" is H^ and we have no idea what it does after copying the tape other than it behaves like some other machine called H. You don't understand Linz's notation, and you don't understand what H^ is. And, as usual, you a confusing machines with representations of machines. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peteolcott@gmail.com> |
|---|---|
| Date | 2017-03-15 13:56 -0700 |
| Message-ID | <7b6313c0-3f5a-4bea-8249-67bdfe61d5f3@googlegroups.com> |
| In reply to | #11925 |
On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote: > I'll cut to the chase... > peteolcott <peteolcott> writes: > <snip> > > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2) > > the execution trace of Wm_1 indicates that it makes a copy of Wm_2 > > which for clarity we will call Wm_3. > > > > The next step of the execution trace of Wm_1 indicates that it begins > > its own evaluation execution trace of Wm_2 Wm_3. > > > > The execution trace of Wm_2 indicates that it makes a copy of Wm_3 > > which for clarity we will call Wm_4. > > None of the Wm have an execution trace. They are stings in the alphabet > of the TM H (and H^). The only thing that can have has any "execution > trace" is H^ and we have no idea what it does after copying the tape > other than it behaves like some other machine called H. To provide cognitive leverage and thus eliminate (Fred Brooks) inessential complexity we will assume that the Turing Machine Description of H^ is executed inside of (an interpreter) Universal Turing Machine. The purpose for making this simplifying assumption is so that we can assume H^, w^ and Wm are all names of the same literal string. To provide a little more insight into what a potential halt decider PHD might do to decide halting we could hypothesize that it might simulate the execution of its input TMD in its own UTM (interpreter). Since it could simulate this execution step-by-step there is no risk that this PHD would get stuck in an infinite loop. With the above assumptions we could imagine the following syntax: Execute(H^, H^) executes H^ with H^ input inside a UTM. The H^ could execute its own internal command: Simulate-Execute(Wm, Wm) This would occur immediately after the first |-* in its source code; --> H-Hat source code from quoted from page 319 --> q0 Wm |-* H^ q0 Wm Wm |-* H^ ∞ --> q0 Wm |-* H^ q0 Wm Wm |-* H^ y1 qn y2 |> Direct quote from page 320: |> Now H^ is a Turing machine, so that it will have some |> description in ∑*, say w^. This string, in addition to |> being the description of H^ can also be used as input |> string. We can therefore legitimately ask what would |> happen if H^ is applied to w^. H^ has a Turing Machine Description of w^. According to the Linz quotes: H^ is invoked with w^ input which it receives as Wm. According to the simplifying assumptions: H^, w^ and Wm are merely different names for the same literal string.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2017-03-16 03:23 +0000 |
| Message-ID | <87o9x1ucpi.fsf@bsb.me.uk> |
| In reply to | #11928 |
peteolcott <peteolcott@gmail.com> writes: > On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote: >> I'll cut to the chase... >> peteolcott <peteolcott> writes: >> <snip> >> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2) >> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2 >> > which for clarity we will call Wm_3. >> > >> > The next step of the execution trace of Wm_1 indicates that it begins >> > its own evaluation execution trace of Wm_2 Wm_3. >> > >> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3 >> > which for clarity we will call Wm_4. >> >> None of the Wm have an execution trace. They are stings in the alphabet >> of the TM H (and H^). The only thing that can have has any "execution >> trace" is H^ and we have no idea what it does after copying the tape >> other than it behaves like some other machine called H. > > To provide cognitive leverage and thus eliminate (Fred Brooks) > inessential complexity we will assume that the Turing Machine > Description of H^ is executed inside of (an interpreter) > Universal Turing Machine. That complicates matters -- so much so that you've lost track of the argument altogether. You find it hard enough to separate machine from representations without adding another layer of description. > The purpose for making this simplifying assumption is so > that we can assume H^, w^ and Wm are all names of the same > literal string. > > To provide a little more insight into what a potential halt > decider PHD might do to decide halting we could hypothesize > that it might simulate the execution of its input TMD in its > own UTM (interpreter). Since it could simulate this execution > step-by-step there is no risk that this PHD would get stuck > in an infinite loop. You *could* make that hypothesis but it would render any conclusion you draw from it contingent on it. The simpler argument (the one in Linz) assumes only that H is a halting decider. <snip> -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peteolcott@gmail.com> |
|---|---|
| Date | 2017-03-15 21:22 -0700 |
| Message-ID | <d526cdb1-9d30-4af7-99aa-e92ce9710b52@googlegroups.com> |
| In reply to | #11930 |
On Wednesday, March 15, 2017 at 10:23:24 PM UTC-5, Ben Bacarisse wrote: > peteolcott <peteolcott> writes: > > > On Wednesday, March 15, 2017 at 12:12:45 PM UTC-5, Ben Bacarisse wrote: > >> I'll cut to the chase... > >> peteolcott <peteolcott> writes: > >> <snip> > >> > So when H^ evaluates Wm Wm (for clarity we will call Wm_1 and Wm_2) > >> > the execution trace of Wm_1 indicates that it makes a copy of Wm_2 > >> > which for clarity we will call Wm_3. > >> > > >> > The next step of the execution trace of Wm_1 indicates that it begins > >> > its own evaluation execution trace of Wm_2 Wm_3. > >> > > >> > The execution trace of Wm_2 indicates that it makes a copy of Wm_3 > >> > which for clarity we will call Wm_4. > >> > >> None of the Wm have an execution trace. They are stings in the alphabet > >> of the TM H (and H^). The only thing that can have has any "execution > >> trace" is H^ and we have no idea what it does after copying the tape > >> other than it behaves like some other machine called H. > > > > To provide cognitive leverage and thus eliminate (Fred Brooks) > > inessential complexity we will assume that the Turing Machine > > Description of H^ is executed inside of (an interpreter) > > Universal Turing Machine. > > That complicates matters -- so much so that you've lost track of the > argument altogether. You find it hard enough to separate machine from > representations without adding another layer of description. > It reduces the names from three(H^, w^, Wm) to one: H^ > > The purpose for making this simplifying assumption is so > > that we can assume H^, w^ and Wm are all names of the same > > literal string. > > > > To provide a little more insight into what a potential halt > > decider PHD might do to decide halting we could hypothesize > > that it might simulate the execution of its input TMD in its > > own UTM (interpreter). Since it could simulate this execution > > step-by-step there is no risk that this PHD would get stuck > > in an infinite loop. > > You *could* make that hypothesis but it would render any conclusion you > draw from it contingent on it. The simpler argument (the one in Linz) > assumes only that H is a halting decider. > When ^H1(^H2, ^H3) is invoked ^H1 is evaluating what ^H2 would do on its input ^H3. This requires ^H2 to know what ^H3 would do on its input, yet it has no input. > <snip> > -- > Ben.
[toc] | [prev] | [next] | [standalone]
Page 2 of 6 — ← Prev page 1 [2] 3 4 5 6 Next page →
Back to top | Article view | comp.theory
csiph-web