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


Groups > sci.logic > #170308 > unrolled thread

Re: Infinitely Recursive input on HP Proofs

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


Contents

  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 →


#170458

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


#170460

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170463

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


#170465

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170472

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


#170475

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170479

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


#170591

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170467

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170462

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


#170468

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170561

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


#170592

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170700

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


#170731

FromJim Burns <james.g.burns@att.net>
Date2018-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]


#170777

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


#170782

FromGeorge Greene <greeneg@email.unc.edu>
Date2018-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]


#170732

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


#170776

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


#170785

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