Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > sci.logic > #170308 > unrolled thread
| Started by | George Greene <greeneg@email.unc.edu> |
|---|---|
| First post | 2018-01-16 13:25 -0800 |
| Last post | 2018-01-22 18:10 -0800 |
| Articles | 20 on this page of 78 — 7 participants |
Back to article view | Back to sci.logic
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-16 13:25 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-16 14:09 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-17 20:05 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-17 20:28 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-17 21:09 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-17 21:15 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-18 09:37 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:50 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 07:57 -0800
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-01-18 16:28 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:22 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 10:30 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:51 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-17 01:09 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 08:18 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 10:01 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 10:22 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-21 20:58 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:45 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 18:18 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-19 01:04 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 17:54 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 19:12 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 19:32 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 20:06 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 20:20 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 21:10 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-20 00:06 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 19:36 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-18 18:50 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-18 19:38 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-20 00:00 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-20 00:12 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-21 07:19 -0800
Re: Infinitely Recursive input on HP Proofs Jim Burns <james.g.burns@att.net> - 2018-01-21 21:32 -0500
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:22 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 17:31 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-22 02:40 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 14:59 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-23 01:58 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 18:17 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 18:34 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 19:02 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 21:30 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 21:35 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-23 11:43 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 08:31 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-23 20:30 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 14:11 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-24 01:20 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 17:56 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 02:04 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-24 18:14 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 02:38 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-24 18:48 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 04:07 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-23 22:05 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 22:16 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-24 19:43 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-24 20:17 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-24 20:57 -0800
Re: Infinitely Recursive input on HP Proofs grahamcooper7@gmail.com - 2018-01-24 21:00 -0800
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-25 11:31 +0000
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-25 07:28 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-23 22:09 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 22:27 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-24 19:48 -0800
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-01-21 17:41 +0000
Re: Infinitely Recursive input on HP Proofs Ben Bacarisse <ben.usenet@bsb.me.uk> - 2018-01-22 01:18 +0000
Re: Infinitely Recursive input on HP Proofs Peter Percival <peterxpercival@hotmail.com> - 2018-01-22 12:38 +0000
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-21 20:49 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-21 20:51 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:24 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 17:32 -0800
Re: Infinitely Recursive input on HP Proofs Mikko <mikko.levanto@outlook.com> - 2018-01-23 20:15 +0200
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-23 14:13 -0800
Re: Infinitely Recursive input on HP Proofs peteolcott <peterolcott2@gmail.com> - 2018-01-22 15:40 -0800
Re: Infinitely Recursive input on HP Proofs George Greene <greeneg@email.unc.edu> - 2018-01-22 18:10 -0800
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-01-19 01:04 +0000 |
| Message-ID | <87607y3bgu.fsf@bsb.me.uk> |
| In reply to | #170433 |
peteolcott <peterolcott2@gmail.com> writes: > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote: >> George Greene writes: >> <snip> >> > The ACTUAL correction would read something like >> > qx Wm Wm ⊢* Ĥ y1 qn y2 , >> > since Linz's notation ALWAYS starts with the state where you are beginning. >> > You are just assuming continuation from the previous/last state, >> > which is correct, but again, the question is HOW TO WRITE it clearly, >> > and Linz just fails massively. >> >> Linz has a notation that could have been used to clear this up but it's >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it >> makes it clear what states belong to which machine that also obscures >> the fact the all the machines in the construction share a lot of states >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of >> H, > > That would be a neat trick since H and H' have mutually exclusive > states. No, H and H' may have non-intersecting state sets or they may not have. You can define H' either way. The fact that you can't see this is very telling. The states themselves have almost no significance for TMs. What matters is the state transition function. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-18 17:54 -0800 |
| Message-ID | <18b7ace4-53af-41eb-a903-6a11a9bfce90@googlegroups.com> |
| In reply to | #170458 |
On Thursday, January 18, 2018 at 8:04:52 PM UTC-5, Ben Bacarisse wrote: > No, H and H' may have non-intersecting state sets or they may not have. > You can define H' either way. The fact that you can't see this is very > telling. Exactly. Dear Peter: What MAKES a state a state? How can you TELL one state from another? Is it because they have different names? Is it because they are in physically different TMs? NO, it is NEITHER of those. If you had a TM with all the states named q0,q1,q2,etc, up to q-however-many-states-the-TM-had, and somebody came along and said "I like Peter so I'm going to rename all the states P0,P1,P2,...", would that produce A DIFFERENT TM? If it were a schoolwork assignment and somebody turned in a TM as the answer and you copied their work and insisted it WASN'T a copy because all your states had different names, WOULD YOU WIN? NO. Similarly, if you wrote a TM and ran it on your PC at home and then emailed the code to somebody else and he ran it on his PC, would he be running A DIFFERENT TM, or THE SAME one? When your PC and his were running this algorithm on the same input, would they go through the SAME states or DIFFERENT states? Dear Peter, continued: You Have Bragged about resolving self-reference through directed graphs. Does it truly not occur to you that even though the state-transition-matrix is represented as a matrix, with rows and columns, that it COULD ALSO BE REPRESENTED AS A DIRECTED GRAPH, with a node for each state and an edge, leaving each node, for each letter of the input-alphabet, going from the state where that letter was read, TO the state that the transition matrix wanted to transition to? The other 2 pieces of information (the letter to write on the tape and the direction to move the tape-head) could just be tacked on to the edge as metadata. I AM SINCERELY TRYING TO HELP YOU here. The nodes of a graph DON'T have to be NAMED. If you email a copy of the graph to somebody else, then it is NOT important that his nodes and your nodes are now somehow DIFFERENT! If it was THAT graph that you were INTENDING TO COMMUNICATE, then it is actually more important to think of them as THE SAME. > The states themselves have almost no significance for TMs. What matters > is the state transition function. Exacxtly. That function determines the relationship that each state bears to the others and the input/output/computation paths VIA which the computation COULD GET from any state to any other. THE SHAPE OF THAT GRAPH is what MAKES the program the program, or the TM the TM.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-18 19:12 -0800 |
| Message-ID | <b61d848f-7210-4b12-8600-8092bbeb5080@googlegroups.com> |
| In reply to | #170460 |
On Thursday, January 18, 2018 at 7:54:32 PM UTC-6, George Greene wrote: > On Thursday, January 18, 2018 at 8:04:52 PM UTC-5, Ben Bacarisse wrote: > > No, H and H' may have non-intersecting state sets or they may not have. > > You can define H' either way. The fact that you can't see this is very > > telling. > > Exactly. > > Dear Peter: > What MAKES a state a state? How can you TELL one state from another? > Is it because they have different names? Is it because they are in physically > different TMs? NO, it is NEITHER of those. If you had a TM with all the states > named q0,q1,q2,etc, up to q-however-many-states-the-TM-had, and somebody came > along and said "I like Peter so I'm going to rename all the states P0,P1,P2,...", would that produce A DIFFERENT TM? If it were a schoolwork > assignment and somebody turned in a TM as the answer and you copied their > work and insisted it WASN'T a copy because all your states had different names, > WOULD YOU WIN? NO. > > Similarly, if you wrote a TM and ran it on your PC at home and then emailed > the code to somebody else and he ran it on his PC, would he be running A DIFFERENT TM, or THE SAME one? When your PC and his were running this algorithm > on the same input, would they go through the SAME states or DIFFERENT states? > > Dear Peter, continued: > You Have Bragged about resolving self-reference through directed graphs. > Does it truly not occur to you that even though the state-transition-matrix > is represented as a matrix, with rows and columns, that it COULD ALSO BE > REPRESENTED AS A DIRECTED GRAPH, <sarcasm> Yes that has never ever occurred to me that is why I spent several hours carefully translating the state transition sequence into a state transition diagram. </sarcasm> http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ If you have the intellectual and educational capacity to understand me (probably the former, IDK about the latter) then the problem is that you need to pay much more attention. Maybe this is the part that you cannot manage. Some people only have an attention space of a few seconds. Or maybe you simply don't know some of the terms that I am using. I am to some extent using my own private language, so that would be reasonable.
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-18 19:32 -0800 |
| Message-ID | <5606d2e2-0f4d-4adf-b1fa-a63dfeb75e31@googlegroups.com> |
| In reply to | #170463 |
On Thursday, January 18, 2018 at 10:12:32 PM UTC-5, peteolcott wrote: > If you have the intellectual and educational capacity to understand me > (probably the former, IDK about the latter) then the problem is that > you need to pay much more attention. That is not the problem. The problem is that you keep saying things that are just full of shit on their face, like that H^ doesn't call H', or H' doesn't call H. The further problem is that you actually presented the basic definition (as a 6-tuple) to me without knowing that I encountered *that* in 1976, i.e. more than 40 years ago. THERE IS NOTHING about this that YOU CAN explain to the people trying to help you here. YOU DON'T KNOW.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-18 20:06 -0800 |
| Message-ID | <67e867c7-a48f-433e-893d-f37b17396797@googlegroups.com> |
| In reply to | #170465 |
On Thursday, January 18, 2018 at 9:32:04 PM UTC-6, George Greene wrote: > On Thursday, January 18, 2018 at 10:12:32 PM UTC-5, peteolcott wrote: > > If you have the intellectual and educational capacity to understand me > > (probably the former, IDK about the latter) then the problem is that > > you need to pay much more attention. > > That is not the problem. The problem is that you keep saying things that > are just full of shit on their face, like that H^ doesn't call H', or H' doesn't call H. Yeah so I have to give up on you George. After having spoken with you over the years I know that you are quite intelligent and reasonbly well-educated. If we assume those two things then your claim that H' calls H must only be woefully dishonest. All of the HP proofs that I have ever seen require an infinite loop be appended to the [it does halt] state. If H' calls H then you just chopped off the infinite loop (H has no infinite loop) and thus disabled the whole proof. This is your last chance to be reasonable before I start ignoring everything that you ever say. http://liarparadox.org/HP_Infinite_Recursion.pdf Figure 12.1 is H with two final states. Figure 12.2 is H' with an infinite loop swapped for a final state. http://liarparadox.org/index.php/2018/01/18/refutation-of-the-halting-problem-proof/ Figure 12.3 is Ĥ with copying the input prepended
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-18 20:20 -0800 |
| Message-ID | <4b113fc1-a7d7-44c6-b945-b6f90a550a86@googlegroups.com> |
| In reply to | #170472 |
On Thursday, January 18, 2018 at 11:06:44 PM UTC-5, peteolcott wrote:
> If we assume those two things then your claim that H'
> calls H must only be woefully dishonest.
The problem is that you DON'T KNOW WHAT KIND of thing H^ and H' ARE.
Suppose we were to write the code for these 3 TMs on 3 blackboards
(I think we are both old enough to say blackboard instead of whiteboard).
Suppose the 3 blackboards looked like this:
H: H(m,i) | {If the machine named/coded by string m halts on input string i,
then halt returning true, else halt returning false}
H': H'(n,j) | {If H(n,j) then Loop else halt returning true}
H^: H^(s) | If H'(s,s) then halt returnig true.
The letter before the colon is written in the upper left corner of each
blackboard, like a label.
Question: is this letter naming
a) the blackboard, or
b) THE SUBROUTINE that is defined (with the SAME letter-name) immediately
after it.
Next question: IS IT POSSIBLE to write H' or H^ ON A DIFFERENT BOARD
and have that board STILL have THE SAME TM written on it?
Your problem is that you have still not figured out in your own mind whether
a TM is hardware or software -- whether it is something written or something
physical. When YOUR (and Linz's) definition of H^ says that from some point
in its execution, it "behaves exactly the same as H'", THAT IS *NOT*IN*CONFLICT*
with my claim that H^ calls H' -- those two locutions MEAN THE SAME thing.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-18 21:10 -0800 |
| Message-ID | <76add062-1d14-4a59-8e57-91d0967cac90@googlegroups.com> |
| In reply to | #170475 |
On Thursday, January 18, 2018 at 10:20:54 PM UTC-6, George Greene wrote:
> On Thursday, January 18, 2018 at 11:06:44 PM UTC-5, peteolcott wrote:
> > If we assume those two things then your claim that H'
> > calls H must only be woefully dishonest.
>
> The problem is that you DON'T KNOW WHAT KIND of thing H^ and H' ARE.
>
> Suppose we were to write the code for these 3 TMs on 3 blackboards
> (I think we are both old enough to say blackboard instead of whiteboard).
> Suppose the 3 blackboards looked like this:
>
> H: H(m,i) | {If the machine named/coded by string m halts on input string i,
> then halt returning true, else halt returning false}
>
> H': H'(n,j) | {If H(n,j) then Loop else halt returning true}
>
> H^: H^(s) | If H'(s,s) then halt returnig true.
>
>
> The letter before the colon is written in the upper left corner of each
> blackboard, like a label.
>
> Question: is this letter naming
> a) the blackboard, or
> b) THE SUBROUTINE that is defined (with the SAME letter-name) immediately
> after it.
>
> Next question: IS IT POSSIBLE to write H' or H^ ON A DIFFERENT BOARD
> and have that board STILL have THE SAME TM written on it?
>
>
> Your problem is that you have still not figured out in your own mind whether
> a TM is hardware or software -- whether it is something written or something
> physical. When YOUR (and Linz's) definition of H^ says that from some point
> in its execution, it "behaves exactly the same as H'", THAT IS *NOT*IN*CONFLICT*
> with my claim that H^ calls H' -- those two locutions MEAN THE SAME thing.
Ultimately a TM is a mathematical formalism that can be transformed
into Higher Order Logic with self-reference semantics.
It is this instance that is most directly refuted by the formalized
pathological self-reference error. In this case we are merely evaluating
a finite string with a HOL predicate to see if this HOL predicate resolves
to True or False.
We don't have to go back and forth with what is a machine and what is
a machine description. We simply need to evaluate a HOL predicate
as a mathematical formalism (thus finite string).
M ≡ Halts(M) // HOL with self-reference semantics
It turns out that it does not matter what semantics the predicate
refers to each and every instance of any predicate of this form
always gets stuck in an infinite evaluation loop:
LP ≡ ~True(LP)
G ≡ ~Provable(G)
S ≡ True(S)
Oh yeah, BTW, your feedback did help me today. It got me focusing
on the border cases of self-reference that are not pathological.
"This sentence is comprised of seven words".
The above had been my best example. Because of your feedback I am
working on providing more formal examples of self-reference that
are not pathological.
Copyright 2018 Pete Olcott
Self-reference semantics recently updated on this link
http://liarparadox.org/index.php/2017/12/08/concise-formalization-of-the-liar-paradox/
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-20 00:06 -0800 |
| Message-ID | <5600eb40-c350-4d1d-bacd-d1af3c889f5e@googlegroups.com> |
| In reply to | #170479 |
On Friday, January 19, 2018 at 12:11:02 AM UTC-5, peteolcott wrote: > Ultimately a TM No, not really. TMs are BASIC. They're NOT ultimate. They're FOUNDATIONAL. They're at THE BOTTOM AND THE BEGINNING. > is a mathematical formalism WHY do you have to be SUCH a pretentious "git"?? EVERY LAST ABSTRACTION THAT HAS EVER BEEN THOUGHT UP "is a mathemtatical formalism". THE LETTER 'a' IS A MATHEMATICAL FORMALISM. EVERY character-string IS A MATHEMATICAL FORMALISM. What MAKES them "formal" (i.e. abstract) is the fact that they DON'T have any PHYSICAL identity or existence. Individual a's can exist and get typed on this page (and numerals can too), but NO WHERE do you find THE letter 'a' -- that's IN A WHOLE DIFFERENT REALM OF EXISTENCE. This is NOT complicated. MOST PEOPLE KNOW what abstractions are WITHOUT BELABORING the point! But you saw one TM defined on one part of the page and another defined lower and because the M stood for "Machine", YOU LOST YOUR MIND long enough to think that it was not possible for one of them to be part of or calling the other. IF THEY HAD BEEN POEMS instead of TMs THEN you would not have had a problem with the fact that one later longer poem could have, as a verse, an earlier shorter poem, EVEN if the TITLES weren't the same or repeated or embedded. But YOU JUST DIDN'T KNOW what KIND of thing you were dealing with! > that can be transformed into Higher Order Logic > with self-reference semantics. COULD be, but WHY WOULD ANYONE *BOTHER*, GIVEN that *EVERY* TM, BEING *FINITE*, IS INHERENTLY *0th*-order and NOT higher-order?? THE ONLY way you can lift any TM even to FIRST-order is by caring about the fact that the tape is infinte and that the machine, despite being a finite object, MIGHT NOT HALT on SOME finite inputs. The class of finite inputs to which most TMs can be applied is infinite, so THAT might get you some first-order considerations (again, especially if the TM might not halt). But that higher-order really is OVERKILL here. This concept IS BASIC. You can USE it to say basically ANYthing that CAN be said, EXCEPT higher-order things ABOUT TMs in general. > It is this instance that is most directly refuted by the formalized > pathological self-reference error. The proof as presented may be an example of what you call pathological self-reference, but you were talking about an infinite regress in making copies of the input instead, and that IS NOT the same thing and that IS NOT happening in this example, EVEN if there is pathological self-reference.
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-18 19:36 -0800 |
| Message-ID | <f8e4441f-96b5-46bc-a7c9-f07543df6f60@googlegroups.com> |
| In reply to | #170463 |
On Thursday, January 18, 2018 at 10:12:32 PM UTC-5, peteolcott wrote: > Or maybe you simply don't know some of the terms that I am using. I am > to some extent using my own private language, so that would be reasonable. Using your own private language is not reasonable. If your goal is to persuade people to like your private language then you are going to have to phrase the pitch in language that proves you already understand BASIC terms (like TM) OF OUR language. Right now the goal is to get you to understand what a TM is. If you think the 6-tuple definition you posted is relevant then that is evidence OF YOUR LACK of understanding. THE ONLY one of those 6 things that actually matters is the delta, is the transition matrix. The rest of it is just annotation FOR that matrix. The matrix could just as easily be represented as a graph. When Linz's argument says that H^, after doubling its input, "behaves exactly like" H', THAT'S WHAT "calling H'" MEANS. If you looked at the graph of H^, it would have a section following the doubling of the input that LOOKED EXACTLY LIKE the graph of H'. If you wrote H^ out in code instead, then after the code for doubling the input, there would be a string of code whose text LOOKED EXACTLY LIKE H's code-text, with the possible exception of the state-names being slightly different, WHICH WOULDN'T MATTER -- those states would still get invoked in the same order with H^ here as they would when H' was being invoked IN ANY OTHER CONTEXT with the same input.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-18 18:50 -0800 |
| Message-ID | <1feee1c9-ed5f-49b1-a385-eadff3fa11be@googlegroups.com> |
| In reply to | #170458 |
On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote: > peteolcott writes: > > > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote: > >> George Greene writes: > >> <snip> > >> > The ACTUAL correction would read something like > >> > qx Wm Wm ⊢* Ĥ y1 qn y2 , > >> > since Linz's notation ALWAYS starts with the state where you are beginning. > >> > You are just assuming continuation from the previous/last state, > >> > which is correct, but again, the question is HOW TO WRITE it clearly, > >> > and Linz just fails massively. > >> > >> Linz has a notation that could have been used to clear this up but it's > >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it > >> makes it clear what states belong to which machine that also obscures > >> the fact the all the machines in the construction share a lot of states > >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of > >> H, > > > > That would be a neat trick since H and H' have mutually exclusive > > states. > > No, H and H' may have non-intersecting state sets or they may not have. If a cat is defined to be an animal you are no longer free to define a cat as a pile of bricks. H is defined with two final states, H' is and adapted form of H where one of these final states has been converted into an infinite loop. > You can define H' either way. The fact that you can't see this is very > telling. > That is analogous to defining a cat as a pile of bricks, thus positing this absurdity you are showing your lack of integrity. > The states themselves have almost no significance for TMs. What matters > is the state transition function. > state ((qy)) that was converted to (qy) ∞, both transitions having a defined semantics, equivalent to Boolean True. So all your hem-hawing to be disagreeable makes you disingenuous. You could understand and confirm what I say you prefer to be disagreeable even a the cost of truth. All you have ever given as any rebuttal of my work is boiler plate generalities the amount to nothing more that the appeal to authority fallacy. > -- > Ben.
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-18 19:38 -0800 |
| Message-ID | <e868da37-f38a-4630-b18b-9cb40163e7f6@googlegroups.com> |
| In reply to | #170462 |
On Thursday, January 18, 2018 at 9:50:50 PM UTC-5, peteolcott wrote: > If a cat is defined to be an animal you are no longer free to define > a cat as a pile of bricks. Bu TMs are not like that, and the fact that you think that one TM is as different from another as a cat is from a pile of bricks is just proof of how ignorant you are. > H is defined with two final states, H' is and > adapted form of H where one of these final states has been converted > into an infinite loop. AND THIS IS DONE by having H' *CALL*H*FIRST* AND THEN do something ELSE AFTERWARD.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-01-20 00:00 +0000 |
| Message-ID | <874lnh1js3.fsf@bsb.me.uk> |
| In reply to | #170462 |
peteolcott <peterolcott2@gmail.com> writes: > On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote: >> peteolcott writes: >> >> > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote: >> >> George Greene writes: >> >> <snip> >> >> > The ACTUAL correction would read something like >> >> > qx Wm Wm ⊢* Ĥ y1 qn y2 , >> >> > since Linz's notation ALWAYS starts with the state where you are beginning. >> >> > You are just assuming continuation from the previous/last state, >> >> > which is correct, but again, the question is HOW TO WRITE it clearly, >> >> > and Linz just fails massively. >> >> >> >> Linz has a notation that could have been used to clear this up but it's >> >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it >> >> makes it clear what states belong to which machine that also obscures >> >> the fact the all the machines in the construction share a lot of states >> >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of >> >> H, >> > >> > That would be a neat trick since H and H' have mutually exclusive >> > states. >> >> No, H and H' may have non-intersecting state sets or they may not have. > > If a cat is defined to be an animal you are no longer free to define > a cat as a pile of bricks. H is defined with two final states, H' is and > adapted form of H where one of these final states has been converted > into an infinite loop. > >> You can define H' either way. The fact that you can't see this is very >> telling. >> > That is analogous to defining a cat as a pile of bricks, thus > positing this absurdity you are showing your lack of integrity. No. You analogy reveals you don't understand either what I wrote or what a TM is. Important facts about cats (such as they are not dogs) do not depend on the names given to their hairs. >> The states themselves have almost no significance for TMs. What matters >> is the state transition function. > > state ((qy)) that was converted to (qy) ∞, both transitions > having a defined semantics, equivalent to Boolean True. No again. The sates have no semantics of any significance. We can call them the green and the purple states. The theorem then tells us of the non-existence of a TM that can decide which strings encode those TMs that enter a purple state (or, for that matter, a green state). > So all your hem-hawing to be disagreeable makes you disingenuous. You > could understand and confirm what I say you prefer to be disagreeable > even a the cost of truth. No. You are completely at sea. Mainly because you started with a false conclusion as your premise -- halt deciding *must* be "wrong" in some way -- and you have wasted more than a decade trying to find some way of saying that that makes sense. > All you have ever given as any rebuttal of my work is boiler plate > generalities the amount to nothing more that the appeal to > authority fallacy. No, I appeal to a proven theorem. That is perfectly valid. Further more, I point out your misunderstandings. Yes, they are common misunderstandings so my replies are often "boilerplate" but what else can I do if you don't come up with any original ideas? -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-20 00:12 -0800 |
| Message-ID | <84e56444-1098-45bf-97a9-f185b593b0d3@googlegroups.com> |
| In reply to | #170561 |
On Friday, January 19, 2018 at 11:55:32 PM UTC-5, Pete Olcott wrote: > Mathematics > is a body of necessary truth thus necessarily always provable. That is neither controversial nor original. You seem to think that the existence of something "true but unprovable" contradicts this. IT DOESN'T, really. Each unprovable sentence actually FAILS to be true -- *EACH*ONE* -- in SOME model (maybe a different model for each unprovable sentence but the point is, provable sentences are true IN ALL models, and that "all"ness makes them MORE than MERELY true, makes them Necessarily true, i.e., provable). But the fact that "true" REQUIRES ANOTHER LEVEL -- requires the invocation of SEMANTICS AND MODELS -- in this paradign, is something You Just Didn't Know because you haven't taken the relevant courses. So we will just never get anywhere until you sit down, shut up, and pause to notice that there is another whole level of stuff that YOU HAVE NEVER EVEN HEARD OF, going on here. If you would spend even ONE hour even TRYING to understand WHAT A MODEL IS, then we MIGHT be able to move on.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-21 07:19 -0800 |
| Message-ID | <06a52a41-1cf3-447c-a983-7cfd89cc589f@googlegroups.com> |
| In reply to | #170561 |
On Friday, January 19, 2018 at 6:00:47 PM UTC-6, Ben Bacarisse wrote:
> peteolcott writes:
>
> > On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote:
> >> peteolcott writes:
> >>
> >> > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote:
> >> >> George Greene writes:
> >> >> <snip>
> >> >> > The ACTUAL correction would read something like
> >> >> > qx Wm Wm ⊢* Ĥ y1 qn y2 ,
> >> >> > since Linz's notation ALWAYS starts with the state where you are beginning.
> >> >> > You are just assuming continuation from the previous/last state,
> >> >> > which is correct, but again, the question is HOW TO WRITE it clearly,
> >> >> > and Linz just fails massively.
> >> >>
> >> >> Linz has a notation that could have been used to clear this up but it's
> >> >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it
> >> >> makes it clear what states belong to which machine that also obscures
> >> >> the fact the all the machines in the construction share a lot of states
> >> >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of
> >> >> H,
> >> >
> >> > That would be a neat trick since H and H' have mutually exclusive
> >> > states.
> >>
> >> No, H and H' may have non-intersecting state sets or they may not have.
> >
> > If a cat is defined to be an animal you are no longer free to define
> > a cat as a pile of bricks. H is defined with two final states, H' is and
> > adapted form of H where one of these final states has been converted
> > into an infinite loop.
> >
> >> You can define H' either way. The fact that you can't see this is very
> >> telling.
> >>
> > That is analogous to defining a cat as a pile of bricks, thus
> > positing this absurdity you are showing your lack of integrity.
>
> No. You analogy reveals you don't understand either what I wrote or
> what a TM is. Important facts about cats (such as they are not dogs) do
> not depend on the names given to their hairs.
>
> >> The states themselves have almost no significance for TMs. What matters
> >> is the state transition function.
> >
> > state ((qy)) that was converted to (qy) ∞, both transitions
> > having a defined semantics, equivalent to Boolean True.
>
> No again. The states have no semantics of any significance. We can call
> them the green and the purple states. The theorem then tells us of the
> non-existence of a TM that can decide which strings encode those TMs
> that enter a purple state (or, for that matter, a green state).
>
Definition 3.1 page 128, Sipster 1997
1. Q is the set of states,
2. ∑ is the input alphabet, not containing the special blank symbol ◻,
3. Γ is the tape alphabet, where {◻} ∈ Γ and ∑ ⊆ Γ,
4. δ: Q x Γ → Q x Γ x {L, R} is the transition function,
5. q0 ∈ Q is the start state,
6. qaccept ∈ Q is the accept state, and
7. qreject ∈ Q is the reject state, where qreject ≠ qaccept.
The last two are semantics of significance.
[toc] | [prev] | [next] | [standalone]
| From | Jim Burns <james.g.burns@att.net> |
|---|---|
| Date | 2018-01-21 21:32 -0500 |
| Message-ID | <e70e711f-8bed-549d-1f69-7c7649ba38ce@att.net> |
| In reply to | #170700 |
On 1/21/2018 10:19 AM, peteolcott wrote:
> On Friday, January 19, 2018 at 6:00:47 PM UTC-6,
> Ben Bacarisse wrote:
>> No again. The states have no semantics of any significance.
>> We can call them the green and the purple states. The
>> theorem then tells us of the non-existence of a TM that can
>> decide which strings encode those TMs that enter a purple
>> state (or, for that matter, a green state).
>
> Definition 3.1 page 128, Sipster 1997
> 1. Q is the set of states,
> 2. ∑ is the input alphabet, not containing the special blank
> symbol ◻,
> 3. Γ is the tape alphabet, where {◻} ∈ Γ and ∑ ⊆ Γ,
> 4. δ: Q x Γ → Q x Γ x {L, R} is the transition function,
> 5. q0 ∈ Q is the start state,
> 6. qaccept ∈ Q is the accept state, and
> 7. qreject ∈ Q is the reject state, where qreject ≠ qaccept.
>
> The last two are semantics of significance.
The semantics that _we give_ to "accept" and "reject" do not
affect the operation of the TM.
The states are how they are independently of whether they are
given the expected semantics, given some unexpected semantics,
or given no semantics at all. This is basically what we mean by
_syntax_ : the way things happen independently of what we mean
by them.
This is an opportunity for me to use my latest favorite toy:
a thoroughly syntactic description of "next prime".[1] I think
that the syntax for this "next prime" is sufficiently distant
from the concepts involved that we can usefully peel apart
syntax and semantics.
There is something we mean when we say "next prime" that
involves natural numbers and multiplication and order. It's
fair to say that there are some semantics there.
They don't matter, the semantics do not matter.
They don't matter when we apply the rule ^As ==> Bss to the
string Asss0 and get Bssss0 .
They don't matter when we apply the rule ^Bs ==> 0ttCs to the
string Bssss0 and get 0ttCssss0 .
They don't matter when we apply the rule tCs ==> +C+ to the
string 0ttCssss0 and get 0t+C+sss0 .
They don't matter when we apply the rule +s ==> s+ to the
string 0t+C+sss0 and get 0t+Cs+ss0 .
...
They don't matter when we apply the rule ^0Ks ==> Ks to the
string 0Ksssss0 and get Ksssss0 .
They don't matter when we apply the rule ^Ks ==> Ls to the
string Ksssss0 and get Lsssss0 .
The syntax below[1] generates a string Ls...s0 with a
next-prime-long string of 's' from a string As...s0 .
Semantics are not a part of that generating.
We could assign semantics to various strings. That's not a
bad idea, it would help us follow what's happening.
Asss0 == "What is the next prime after sss ?"
Bssss0 == "Is ssss prime?"
0ttCssss0 == "Does tt divide ssss ?"
0ttFssss0 == " tt divides ssss "
0ttGssss0 == " Is tt equal to ssss ?"
0ttHssss0 == " tt is not equal to ssss "
Jssss0 == " ssss is not prime"
Bsssss0 == "Is sssss prime?"
We _could_ assign semantics, but we don't _need_ to in order for
the string replacements to play out properly. The comments
(which is what, in effect, my "semantics" are) do not affect
their operation.
For the moment, I am talking about generating the next prime and,
by analogy, Turing machines and defining them syntactically. I
could as easily be talking about verifying a proof of the Diagonal
lemma. The rules for verifying a proof as correct are syntactic.
A proof is correct (or incorrect) by those rules independently of
any talk about truth or validity. Suggesting that a proof is in
error _because of its semantics_ is like suggesting that the
string 0ttCssss0 *does not* become 0t+C+sss0 when we apply
tCs ==> +C+ because 0ttCssss0 _does not_ mean "Does tt divide
ssss ?" It's a challenge to regard something like that seriously
enough to explain how it's wrong. (I like challenges.)
[1]
^A0 ==> Lss0
^As ==> Bss
^Bs ==> 0ttCs
tCs ==> +C+
xCs ==> -Ds
tCx ==> -E-
xCx ==> -F-
+s ==> s+
t+ ==> +t
0+ ==> 0x
+0 ==> x0
+x ==> xx
x+ ==> xx
-s ==> --
t- ==> --
-+ ==> --
+- ==> --
-x ==> --
x- ==> --
-0 ==> <0
0- ==> 0>
-< ==> <<
>- ==> >>
<< ==> <s
>> ==> t>
t>D ==> ttD
tDs ==> tCs
t>E ==> ttE
E<s ==> Ess
tEs ==> ttCs
t>F ==> ttF
F<s ==> Fss
tFs ==> tGs
tGs ==> +G+
xGs ==> -H-
tGx ==> -H-
xGx ==> -I-
t>H ==> ttH
H<s ==> Hss
tHs ==> tJs
t>I ==> ttI
I<s ==> Iss
tIs ==> tKs
tJs ==> Js
^0Js ==> Js
^Js ==> Bss
tKs ==> Ks
^0Ks ==> Ks
^Ks ==> Ls
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-22 15:22 -0800 |
| Message-ID | <4e801747-7941-4d22-8e14-f1fc56c22692@googlegroups.com> |
| In reply to | #170731 |
On Sunday, January 21, 2018 at 8:33:04 PM UTC-6, Jim Burns wrote:
> On 1/21/2018 10:19 AM, peteolcott wrote:
> > On Friday, January 19, 2018 at 6:00:47 PM UTC-6,
> > Ben Bacarisse wrote:
>
> >> No again. The states have no semantics of any significance.
> >> We can call them the green and the purple states. The
> >> theorem then tells us of the non-existence of a TM that can
> >> decide which strings encode those TMs that enter a purple
> >> state (or, for that matter, a green state).
> >
> > Definition 3.1 page 128, Sipster 1997
> > 1. Q is the set of states,
> > 2. ∑ is the input alphabet, not containing the special blank
> > symbol ◻,
> > 3. Γ is the tape alphabet, where {◻} ∈ Γ and ∑ ⊆ Γ,
> > 4. δ: Q x Γ → Q x Γ x {L, R} is the transition function,
> > 5. q0 ∈ Q is the start state,
> > 6. qaccept ∈ Q is the accept state, and
> > 7. qreject ∈ Q is the reject state, where qreject ≠ qaccept.
> >
> > The last two are semantics of significance.
>
> The semantics that _we give_ to "accept" and "reject" do not
> affect the operation of the TM.
>
> The states are how they are independently of whether they are
> given the expected semantics, given some unexpected semantics,
> or given no semantics at all. This is basically what we mean by
> _syntax_ : the way things happen independently of what we mean
> by them.
>
Since we are doing a semantic analysis semantics are necessary.
All logical analysis utterly depends upon the semantic notion
of True and False.
"5 > 3" is True
"3 > 5" is False
"5 > 3" is not Blue
"5 > 3" is not Green
∃x ∈ Turing_Machines
∀y ∈ Turing_Machine_Descriptions
∀z ∈ Finite_Strings Halts(x, y, z)
We are not asking if ∃x is Blue or Green we are asking if it is True or False.
[toc] | [prev] | [next] | [standalone]
| From | George Greene <greeneg@email.unc.edu> |
|---|---|
| Date | 2018-01-22 17:31 -0800 |
| Message-ID | <0ef97d45-dff9-449a-8e71-71fa9fd76598@googlegroups.com> |
| In reply to | #170777 |
On Monday, January 22, 2018 at 6:22:54 PM UTC-5, peteolcott wrote: > All logical analysis utterly What in THE FUCK is UP with you and these ABSOLUTES?? If you knew anything about "semantics" you would know that THERE IS MORE THAN ONE WAY TO SKIN A CAT and that people USE TERMS DIFFERENTLY in different contexts, ALL THE TIME! YOU DON"T GET to say "all" -- ANYbody can just CHOOSE TO DO IT ANOTHER WAY *IF*THEY*FEEL* like it! And more to the point, IF THERE WERE any actual rules that were commonly-enough-agreed to that you COULD say "all", YOUR DUMB CRANK ASS *WOULD*NOT*KNOW* them, as you LOUDLY prove here ALL the time! JUST STOP it with the overgeneralizations! IT DOES NOT MATTER whether "all" logical analysis has or lacks a certain property! JUST MAKE SURE *YOUR* logical analysis has the property and understands it correctly!
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-01-22 02:40 +0000 |
| Message-ID | <877esawr8u.fsf@bsb.me.uk> |
| In reply to | #170700 |
peteolcott <peterolcott2@gmail.com> writes:
> On Friday, January 19, 2018 at 6:00:47 PM UTC-6, Ben Bacarisse wrote:
>> peteolcott writes:
>>
>> > On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote:
>> >> peteolcott writes:
>> >>
>> >> > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote:
>> >> >> George Greene writes:
>> >> >> <snip>
>> >> >> > The ACTUAL correction would read something like
>> >> >> > qx Wm Wm ⊢* Ĥ y1 qn y2 ,
>> >> >> > since Linz's notation ALWAYS starts with the state where you are beginning.
>> >> >> > You are just assuming continuation from the previous/last state,
>> >> >> > which is correct, but again, the question is HOW TO WRITE it clearly,
>> >> >> > and Linz just fails massively.
>> >> >>
>> >> >> Linz has a notation that could have been used to clear this up but it's
>> >> >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it
>> >> >> makes it clear what states belong to which machine that also obscures
>> >> >> the fact the all the machines in the construction share a lot of states
>> >> >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of
>> >> >> H,
>> >> >
>> >> > That would be a neat trick since H and H' have mutually exclusive
>> >> > states.
>> >>
>> >> No, H and H' may have non-intersecting state sets or they may not have.
>> >
>> > If a cat is defined to be an animal you are no longer free to define
>> > a cat as a pile of bricks. H is defined with two final states, H' is and
>> > adapted form of H where one of these final states has been converted
>> > into an infinite loop.
>> >
>> >> You can define H' either way. The fact that you can't see this is very
>> >> telling.
>> >>
>> > That is analogous to defining a cat as a pile of bricks, thus
>> > positing this absurdity you are showing your lack of integrity.
>>
>> No. You analogy reveals you don't understand either what I wrote or
>> what a TM is. Important facts about cats (such as they are not dogs) do
>> not depend on the names given to their hairs.
>>
>> >> The states themselves have almost no significance for TMs. What matters
>> >> is the state transition function.
>> >
>> > state ((qy)) that was converted to (qy) ∞, both transitions
>> > having a defined semantics, equivalent to Boolean True.
>>
>> No again. The states have no semantics of any significance. We can call
>> them the green and the purple states. The theorem then tells us of the
>> non-existence of a TM that can decide which strings encode those TMs
>> that enter a purple state (or, for that matter, a green state).
>>
>
> Definition 3.1 page 128, Sipster 1997
> 1. Q is the set of states,
> 2. ∑ is the input alphabet, not containing the special blank symbol ◻,
> 3. Γ is the tape alphabet, where {◻} ∈ Γ and ∑ ⊆ Γ,
> 4. δ: Q x Γ → Q x Γ x {L, R} is the transition function,
> 5. q0 ∈ Q is the start state,
> 6. qaccept ∈ Q is the accept state, and
> 7. qreject ∈ Q is the reject state, where qreject ≠ qaccept.
>
> The last two are semantics of significance.
No. Here's my definition of a Ben Machine: (Q, S, G, d, q0, pp, qg).
Q is the set of states. S and G are the input and tape alphabet (with
space in G, space not in S and S a subset of G). d is the state
transition function (Q x G -> Q x G x {L,R}). q0 is the start state, qp
is the purple state and qg is the green state (q0, qp, qg all in Q with
pq =/= pg). Just as above, execution stops on entering either the
purple or the green state.
Now it's possible that, according to you, Ben machines have no
semantics. Are you therefore happy to accept the halting theorems for
Ben machines? I say theorems plural because there are two forms of it.
One states that there is no BM which enters the purple state if and only
if the input encodes a (BM,input) pair for a halting computation. The
other says that there is no BM which enters the green state if, and only
if, the input encodes a (BM,input) pair for a halting computation.
And I can keep going... Consider NTBM's (non-terminating Ben machines)
whose state transition functions are total (the always do something) and
which have *no halting states at all*. Instead, in addition to an
initial state there is a nominated yellow state which, apart form being
singled out as the yellow state, is the same as all the others.
NTBM's have no hating theorem, of course, because none of them halt.
But here is a theorem about them: there is no NTBM that enters its
yellow state at least once if, and only if, the input tape encodes a
(NTBM,input) pair representing a NTBM which would enter its yellow state
at least once when presented with "input" as it's initial tape.
Do you accept that this is a theorem? Do these machine and/or this
theorem have "semantics"? Can you see any connection to Turing's
theorem and/or Rice's theorem?
--
Ben.
[toc] | [prev] | [next] | [standalone]
| From | peteolcott <peterolcott2@gmail.com> |
|---|---|
| Date | 2018-01-22 14:59 -0800 |
| Message-ID | <f90b3364-a845-4b23-b3ec-d529a31609df@googlegroups.com> |
| In reply to | #170732 |
On Sunday, January 21, 2018 at 8:40:22 PM UTC-6, Ben Bacarisse wrote:
> peteolcott writes:
>
> > On Friday, January 19, 2018 at 6:00:47 PM UTC-6, Ben Bacarisse wrote:
> >> peteolcott writes:
> >>
> >> > On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote:
> >> >> peteolcott writes:
> >> >>
> >> >> > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote:
> >> >> >> George Greene writes:
> >> >> >> <snip>
> >> >> >> > The ACTUAL correction would read something like
> >> >> >> > qx Wm Wm ⊢* Ĥ y1 qn y2 ,
> >> >> >> > since Linz's notation ALWAYS starts with the state where you are beginning.
> >> >> >> > You are just assuming continuation from the previous/last state,
> >> >> >> > which is correct, but again, the question is HOW TO WRITE it clearly,
> >> >> >> > and Linz just fails massively.
> >> >> >>
> >> >> >> Linz has a notation that could have been used to clear this up but it's
> >> >> >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it
> >> >> >> makes it clear what states belong to which machine that also obscures
> >> >> >> the fact the all the machines in the construction share a lot of states
> >> >> >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of
> >> >> >> H,
> >> >> >
> >> >> > That would be a neat trick since H and H' have mutually exclusive
> >> >> > states.
> >> >>
> >> >> No, H and H' may have non-intersecting state sets or they may not have.
> >> >
> >> > If a cat is defined to be an animal you are no longer free to define
> >> > a cat as a pile of bricks. H is defined with two final states, H' is and
> >> > adapted form of H where one of these final states has been converted
> >> > into an infinite loop.
> >> >
> >> >> You can define H' either way. The fact that you can't see this is very
> >> >> telling.
> >> >>
> >> > That is analogous to defining a cat as a pile of bricks, thus
> >> > positing this absurdity you are showing your lack of integrity.
> >>
> >> No. You analogy reveals you don't understand either what I wrote or
> >> what a TM is. Important facts about cats (such as they are not dogs) do
> >> not depend on the names given to their hairs.
> >>
> >> >> The states themselves have almost no significance for TMs. What matters
> >> >> is the state transition function.
> >> >
> >> > state ((qy)) that was converted to (qy) ∞, both transitions
> >> > having a defined semantics, equivalent to Boolean True.
> >>
> >> No again. The states have no semantics of any significance. We can call
> >> them the green and the purple states. The theorem then tells us of the
> >> non-existence of a TM that can decide which strings encode those TMs
> >> that enter a purple state (or, for that matter, a green state).
> >>
> >
> > Definition 3.1 page 128, Sipster 1997
> > 1. Q is the set of states,
> > 2. ∑ is the input alphabet, not containing the special blank symbol ◻,
> > 3. Γ is the tape alphabet, where {◻} ∈ Γ and ∑ ⊆ Γ,
> > 4. δ: Q x Γ → Q x Γ x {L, R} is the transition function,
> > 5. q0 ∈ Q is the start state,
> > 6. qaccept ∈ Q is the accept state, and
> > 7. qreject ∈ Q is the reject state, where qreject ≠ qaccept.
> >
> > The last two are semantics of significance.
>
> No. Here's my definition of a Ben Machine: (Q, S, G, d, q0, pp, qg).
>
We aren't talking about Ben machines, and you know that Goofus.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2018-01-23 01:58 +0000 |
| Message-ID | <87r2qhtjxw.fsf@bsb.me.uk> |
| In reply to | #170776 |
peteolcott <peterolcott2@gmail.com> writes:
> On Sunday, January 21, 2018 at 8:40:22 PM UTC-6, Ben Bacarisse wrote:
>> peteolcott writes:
>>
>> > On Friday, January 19, 2018 at 6:00:47 PM UTC-6, Ben Bacarisse wrote:
>> >> peteolcott writes:
>> >>
>> >> > On Thursday, January 18, 2018 at 7:04:52 PM UTC-6, Ben Bacarisse wrote:
>> >> >> peteolcott writes:
>> >> >>
>> >> >> > On Tuesday, January 16, 2018 at 7:09:26 PM UTC-6, Ben Bacarisse wrote:
>> >> >> >> George Greene writes:
>> >> >> >> <snip>
>> >> >> >> > The ACTUAL correction would read something like
>> >> >> >> > qx Wm Wm ⊢* Ĥ y1 qn y2 ,
>> >> >> >> > since Linz's notation ALWAYS starts with the state where you are beginning.
>> >> >> >> > You are just assuming continuation from the previous/last state,
>> >> >> >> > which is correct, but again, the question is HOW TO WRITE it clearly,
>> >> >> >> > and Linz just fails massively.
>> >> >> >>
>> >> >> >> Linz has a notation that could have been used to clear this up but it's
>> >> >> >> even more cumbersome: q_(A,0) for state 0 of machine A. And while it
>> >> >> >> makes it clear what states belong to which machine that also obscures
>> >> >> >> the fact the all the machines in the construction share a lot of states
>> >> >> >> and transitions. Do you say that q_(H,i) = q_(H',i) for all n states of
>> >> >> >> H,
>> >> >> >
>> >> >> > That would be a neat trick since H and H' have mutually exclusive
>> >> >> > states.
>> >> >>
>> >> >> No, H and H' may have non-intersecting state sets or they may not have.
>> >> >
>> >> > If a cat is defined to be an animal you are no longer free to define
>> >> > a cat as a pile of bricks. H is defined with two final states, H' is and
>> >> > adapted form of H where one of these final states has been converted
>> >> > into an infinite loop.
>> >> >
>> >> >> You can define H' either way. The fact that you can't see this is very
>> >> >> telling.
>> >> >>
>> >> > That is analogous to defining a cat as a pile of bricks, thus
>> >> > positing this absurdity you are showing your lack of integrity.
>> >>
>> >> No. You analogy reveals you don't understand either what I wrote or
>> >> what a TM is. Important facts about cats (such as they are not dogs) do
>> >> not depend on the names given to their hairs.
>> >>
>> >> >> The states themselves have almost no significance for TMs. What matters
>> >> >> is the state transition function.
>> >> >
>> >> > state ((qy)) that was converted to (qy) ∞, both transitions
>> >> > having a defined semantics, equivalent to Boolean True.
>> >>
>> >> No again. The states have no semantics of any significance. We can call
>> >> them the green and the purple states. The theorem then tells us of the
>> >> non-existence of a TM that can decide which strings encode those TMs
>> >> that enter a purple state (or, for that matter, a green state).
>> >>
>> >
>> > Definition 3.1 page 128, Sipster 1997
>> > 1. Q is the set of states,
>> > 2. ∑ is the input alphabet, not containing the special blank symbol ◻,
>> > 3. Γ is the tape alphabet, where {◻} ∈ Γ and ∑ ⊆ Γ,
>> > 4. δ: Q x Γ → Q x Γ x {L, R} is the transition function,
>> > 5. q0 ∈ Q is the start state,
>> > 6. qaccept ∈ Q is the accept state, and
>> > 7. qreject ∈ Q is the reject state, where qreject ≠ qaccept.
>> >
>> > The last two are semantics of significance.
>>
>> No. Here's my definition of a Ben Machine: (Q, S, G, d, q0, pp, qg).
>
> We aren't talking about Ben machines, and you know that Goofus.
It's a discussion. I wanted to help you see that what you think of cast
in stone (machines halting or not halting, machines having apparently
significant names like "accepting" and "rejecting") are simply arbitrary
conventions that got frozen into the topic in about 1936. There's
nothing wrong with them, but they have no significance beyond
convention. To see that, you have to start thinking outside the tiny
box you've built to contain all you know about TMs. There's so much
more to the topic that you allow yourself to hear or see.
--
Ben.
[toc] | [prev] | [next] | [standalone]
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
Back to top | Article view | sci.logic
csiph-web