\documentclass{article}
\usepackage{amssymb}
\usepackage{amsmath}
\usepackage{slide-article-tom}
\ifx\pdfoutput\undefined
     \usepackage[dvips]{graphicx}
\else
     \usepackage[pdftex]{graphicx}
     \pdfcompresslevel9

\fi

\usepackage{hyperref}

\hypersetup{colorlinks,
            linkcolor=blue,
            %pdfpagemode=FullScreen
            pdfpagemode=None
            }



\def\pagedone{\newpage}

\def\tthdump#1{#1}

\tthdump{\def\sectionhead#1{\begin{center}{\LARGE\hypertarget{#1}
     {#1}\hyperlink{Our general topics:}{\hfil$\leftarrow$}}\end{center}}}
     
%%tth:\def\sectionhead#1{{\LARGE#1\hypertarget{#1}{#1}}
%%tth:     \special{html: <A NAME="#1"></A><a href="\#Top of file">       Top</a>}}

\tthdump{\def\quotesection#1{\begin{center}{\LARGE\hypertarget{#1}
     {#1}\hyperlink{The quotes}{\hfil$\twoheadleftarrow$}}\end{center}}}
     
%%tth:\def\quotesection#1{{\LARGE#1\hypertarget{#1}{#1}}
%%tth:     \special{html: <A NAME="#1"></A><a href="\#The quotes">       <-</a>}}

%%tth:\def\makehyperlink#1{\special{html: <a href="\##1">}{\large#1}\special{html: </a>}}

%%tth:\def\binom#1#2{\left(\begin{array}{c}#1\\#2\end{array}\right)}

%\def\sectionhead#1{\begin{center}{\LARGE #1}\end{center}}
%\def\sectionhead#1{\section{#1}}

% defines a 2 element column vector.
\def\col#1#2{\left(\begin{array}{c}#1\\#2\end{array}\right)}
\def\tcol#1#2{(#1, #2)^T}

\def\naturals{\mathbb{N}}

\begin{document}
\raggedright
%%tth:\special{html: <A NAME="Top of file"></A>}

\pagestyle{myfooters}
%\pagestyle{plain}

\thispagestyle{empty}


%%tth:\special{html:<title> Introduction to theory of computation</title>}

%Slide 1
\title{{\LARGE\bf Introduction to theory of computation}\newline \newline \newline}
\author{Tom Carter
\newline
\newline
\newline
\tthdump{\href{http://astarte.csustan.edu/\~tom/SFI-CSSS}
     {http://astarte.csustan.edu/\~\ tom/SFI-CSSS}}
%%tth:\href{http://astarte.csustan.edu/~tom/SFI-CSSS}{http://astarte.csustan.edu/\~tom/SFI-CSSS}
\vfill
Complex Systems Summer School
\newline
}
\date{June, 2005}
\maketitle

%Slide 2
\sectionhead{Our general topics:}
%%tth:\begin{itemize}
%%tth:\item
\tthdump{\hyperlink{Symbols, strings and languages}
               {\ $\circledcirc$ Symbols, strings and languages\newline}}
%%tth:\makehyperlink{Symbols, strings and languages}
%%tth:\item
\tthdump{\hyperlink{Finite automata}
	        {$\circledcirc$ Finite automata\newline}} 
%%tth:\makehyperlink{Finite automata}
%%tth:\item
\tthdump{\hyperlink{Regular expressions and languages}
	        {$\circledcirc$ Regular expressions and languages\newline}} 
%%tth:\makehyperlink{Regular expressions and languages}
%%tth:\item
\tthdump{\hyperlink{Markov models}
	        {$\circledcirc$ Markov models\newline}} 
%%tth:\makehyperlink{Markov models}
%%tth:\item
\tthdump{\hyperlink{Context free grammars and languages}
	        {$\circledcirc$ Context free grammars and languages\newline}} 
%%tth:\makehyperlink{Context free grammars and languages}
%%tth:\item
 \tthdump{\hyperlink{Language recognizers and generators}
	         {$\circledcirc$ Language recognizers and generators\newline}} 
%%tth:\makehyperlink{Language recognizers and generators}
%%tth:\item
\tthdump{\hyperlink{The Chomsky hierarchy}
	         {$\circledcirc$ The Chomsky hierarchy\newline}} 
%%tth:\makehyperlink{The Chomsky hierarchy}
%%tth:\item
 \tthdump{\hyperlink{Turing machines}
	         {$\circledcirc$ Turing machines\newline}} 
%%tth:\makehyperlink{Turing machines}
%%tth:\item
\tthdump{\hyperlink{Computability and tractability}
	         {$\circledcirc$ Computability and tractability\newline}} 
%%tth:\makehyperlink{Computability and tractability}
%%tth:\item
\tthdump{\hyperlink{Computational complexity}
	         {$\circledcirc$ Computational complexity\newline}} 
%%tth:\makehyperlink{Computational complexity}
%%tth:\item
\tthdump{\hyperlink{References}
	        {$\circledcirc$ References\newline}} 
%%tth:\makehyperlink{References}
%%tth:\end{itemize}

\pagedone

\quotesection{The quotes}
%%tth:\begin{itemize}

%%tth:\item
\tthdump{\hyperlink{No royal road}
               {\ $\circledcirc$ No royal road\newline}}
%%tth:\makehyperlink{No royal road}
%%tth:\item
	 \tthdump{\hyperlink{Mathematical certainty}
	        {$\circledcirc$ Mathematical certainty\newline}}
%%tth:\makehyperlink{Mathematical certainty}
%%tth:\item
	 \tthdump{\hyperlink{I had a feeling once about Mathematics}
	        {$\circledcirc$ I had a feeling once about Mathematics\newline}}
%%tth:\makehyperlink{I had a feeling once about Mathematics}
%%tth:\item
	 \tthdump{\hyperlink{Terminology (philosophy and math)}
	        {$\circledcirc$ Terminology (philosophy and math)\newline}}
%%tth:\makehyperlink{Terminology (philosophy and math)}
%%tth:\item
	 \tthdump{\hyperlink{Rewards}
	         {$\circledcirc$ Rewards\newline}}
%%tth:\makehyperlink{Rewards}
%%  %%tth:\item
%%   	 \tthdump{\hyperlink{Thermodynamics}
%%  	         {$\circledcirc$ Thermodynamics\newline}}
%%  %%tth:\makehyperlink{Thermodynamics}
%%  %%tth:\item
%%  	 \tthdump{\hyperlink{Language, and putting things together}
%%  	         {$\circledcirc$ Language, and putting things together\newline}}
%%  %%tth:\makehyperlink{Language, and putting things together}
%%  %%tth:\item
%%  	 \tthdump{\hyperlink{Tools}
%%  	         {$\circledcirc$ Tools}}
%%  %%tth:\makehyperlink{Tools}

%%tth:\end{itemize}
%\thepage


\tthdump{\hyperlink{Our general topics:}{\hfil To topics $\leftarrow$}}
%%tth:{\special{html: <a href="\#Top of file">       Back to top of file</a>}}

\pagedone

%Slide 3

\sectionhead{Introduction}

What follows is an extremely abbreviated look at some of the important ideas
of the general areas of automata theory, computability, and formal languages.
In various respects, this can be thought of as the elementary foundations of
much of computer science.  The area also includes a wide variety of tools, and
general categories of tools \ldots

\pagedone

\sectionhead{Symbols, strings and languages}

\begin{itemize}
       \item The classical theory of computation traditionally deals with processing
           an input string of symbols into an output string of symbols.  Note that
           in the special case where the set of possible output strings is just
           \{`yes', `no'\}, (often abbreviated \{T, F\} or \{1, 0\}), then we can
           think of the string processing as string (pattern) recognition.
           
           We should start with a few definitions.  The first step is to avoid
           defining the term `symbol' -- this leaves an open slot to connect the
           abstract theory to the world \ldots
           
%% \pagedone
           We define:
           \begin{enumerate}
                \item An {\em alphabet} is a finite set of symbols.
                \item A {\em string} over an alphabet ${\mathrm A}$ is
                     a finite ordered sequence of symbols from
                     ${\mathrm A}$.  Note that repetitions are allowed.
                     The length of a string is the number of symbols in
                     the string, with repetitions counted.  (e.g.,
                     $\vert \mathrm{aabbcc} \vert\ =\ 6$)
                \item The empty string, denoted by $\epsilon$, is the (unique)
                     string of length zero.  Note that the empty string $\epsilon$
                     is not the same as the empty set $\emptyset$.
                \item If $\mathrm{S}$ and $\mathrm{T}$ are sets of strings,
                     then $\mathrm{ST} = \{xy \vert\ x \in \mathrm{S\ and\ }
                     y \in \mathrm{T}\}$ 
                \item Given an alphabet $\mathrm{A}$, we define
                  \begin{eqnarray*}
                     \mathrm{A}^0 & = & \{\epsilon\}\\
                     \mathrm{A}^{n+1} & = & \mathrm{AA}^n\\
                     \mathrm{A}^* & = & \bigcup_{n=0}^\infty\ \mathrm{A}^n
                  \end{eqnarray*}
                \item A {\em language} $\mathrm{L}$ over an alphabet $\mathrm{A}$ is
                     a subset of $\mathrm{A}^*$.  That is, $\mathrm{L} \subset
                     \mathrm{A}^*$.
           \end{enumerate}

\pagedone

       \item We can define the natural numbers, $\naturals$, as follows:
       
          We let
            \begin{eqnarray*}
                 0 & = & \emptyset\\
                 1 & = & \{\emptyset\}\\
                 2 & = & \{\emptyset, \{\emptyset\}\}\\
                 \mathrm{and} & \mathrm{in} & \mathrm{general}\\
                 n+1 & = & \{0, 1, 2, \ldots , n\}.\\
                 \mathrm{Then} & &\\
                 \naturals & = & \{0, 1, 2, \ldots\}.
            \end{eqnarray*}

       \item Sizes of sets and countability:
           \begin{enumerate}
                \item Given two sets $\mathrm{S}$ and $\mathrm{T}$, we say that
                   they are the same size ($\vert \mathrm{S} \vert\ =\ \vert
                      \mathrm{T} \vert$)
                   if there is a one-to-one onto function $f:\ \mathrm{S} \to \mathrm{T}$.
                \item We write $\vert \mathrm{S} \vert\ \le\ \vert \mathrm{T}\vert$
                   if there is a one-to-one (not necessarily onto) function
                   $f:\ \mathrm{S} \to \mathrm{T}$.
                \item We write $\vert \mathrm{S} \vert\ <\ \vert \mathrm{T} \vert$
                   if there is a one-to-one function $f:\ \mathrm{S} \to \mathrm{T}$,
                   but there does not exist any such onto function.
                \item We call a set $\mathrm{S}$
                   \begin{enumerate}
                      \item Finite if $\vert \mathrm{S} \vert < \vert \naturals \vert$
                      \item Countable if $\vert \mathrm{S} \vert \le
                           \vert \naturals \vert$
                      \item Countably infinite if $\vert \mathrm{S} \vert =
                           \vert \naturals \vert$
                      \item Uncountable if $\vert \naturals \vert <
                           \vert \mathrm{S} \vert$.
                   \end{enumerate}
                \item Some examples:
                   \begin{enumerate}
                      \item The set of integers $\mathbb{Z} = \{0, 1, -1, 2, -2, \ldots\}$
                         is countable.
                      \item The set of rational numbers $\mathbb{Q} = \{p/q\ \vert\ 
                         p,q \in \mathbb{Z}, q \ne 0\}$ is countable.
                      \item If $\mathrm{S}$ is countable, then so is $\mathrm{SxS}$,
                         the cartesian product of $\mathrm{S}$ with itself, and so is
                         the general cartesian product $\mathrm{S}^n$ for any $n < \infty$.
                      \item For any nonempty alphabet $\mathrm{A}$, $\mathrm{A}^*$
                         is countably infinite.
                   \end{enumerate}
                   
                   Exercise:  Verify each of these statements.
                \item Recall that the {\em power set} of a set $\mathrm{S}$ is
                   the set of all subsets of $\mathrm{S}$:
                   $$\mathit{P}(\mathrm{S}) = \{\mathrm{T}\ \vert\ 
                          \mathrm{T} \subset \mathrm{S}\}.$$
                   We then have the fact that for any set $\mathrm{S}$,
                   $$\vert \mathrm{S} \vert < \vert \mathit{P}(\mathrm{S}) \vert.$$
                   
                   Pf:  First, it is easy to see that
                   $$\vert \mathrm{S} \vert \le \vert \mathit{P}(\mathrm{S})\vert$$
                   since there is the one-to-one function $f : \mathrm{S} \to 
                   \mathit{P}(\mathrm{S})$ given by $f(s) = \{s\}$ for
                   $s \in \mathrm{S}$.
                   
                   On the other hand, no function $f : \mathrm{S} \to
                   \mathit{P}(\mathrm{S})$ can be onto.  To show this, we need to
                   exhibit an element of $\mathit{P}(\mathrm{S})$ that is not in
                   the image of $f$.  For any given $f$, such an element (which must
                   be a subset of $\mathrm{S}$) is
                   $$\mathrm{R}_f = \{x \in \mathrm{S}\ \vert\ x \notin f(x)\}.$$
                   Now suppose, for contradiction, that there is some $s \in \mathrm{S}$
                   with $f(s) = \mathrm{R}_f$.  There are then two possibilities:
                   either $s \in f(s) = \mathrm{R}_f$ or $s \notin f(s) = \mathrm{R}_f$.
                   Each of these leads to a contradiction:
                   
                   If $s \in f(s) = \mathrm{R}_f$, then by the definition of
                   $\mathrm{R}_f$, $s \notin f(s)$.  This is a contradiction.
                   
                   If $s \notin f(s) = \mathrm{R}_f$, then by the definition of
                   $\mathrm{R}_f$, $s \in \mathrm{R}_f = f(s)$.  Again, a contradiction.
                   
                   Since each case leads to a contradiction, no such $s$ can exist, and
                   hence $f$ is not onto.  QED
           \end{enumerate}
\pagedone

       \item From this, we can conclude for any countably infinite set $\mathrm{S}$,
           $\mathit{P}(\mathrm{S})$ is uncountable.  Thus, for example,
           $\mathit{P}(\naturals)$ is uncountable.  It is not hard to see that
           the set of real numbers, $\mathbb{R}$, is the same size as
           $\mathit{P}(\naturals)$, and is therefore uncountable.
           
           Exercise:  Show this.  (Hint:  show that $\mathbb{R}$ is the same size
           as $(0,1) = \{x \in \mathbb{R}\ \vert\ 0 < x < 1\}$, and then use the
           binary representation of real numbers to show that
           $\vert \mathit{P}(\naturals) \vert = \vert (0,1) \vert$).
           
       \item We can also derive a fundamental (non)computability fact:
       
           There are languages that cannot be recognized by any computation.  In
           other words, there are languages for which there cannot exist any computer
           algorithm to determine whether an arbitrary string is in the language or not.
           
           To see this, we will take as given that any computer algorithm can be
           expressed as a computer program, and hence, in particular, can be
           expressed as a finite string of ascii characters.  Therefore, since
           $\mathrm{ASCII}^*$ is countably infinite, there are at most countably
           many computer algorithms/programs.  On the other hand,
           since a language is any arbitrary subset of $\mathrm{A}^*$ for some
           alphabet $\mathrm{A}$, there are uncountably many languages, since
           there are uncountably many subsets.
            
\end{itemize}
\pagedone

\quotesection{No royal road}
%%tth:\begin{quote}
There is no royal road to logic,
and really valuable ideas can only be had
at the price of close attention.
But I know that in the matter of ideas
the public prefer the cheap and nasty;
and in my next paper
I am going to return to the easily intelligible,
and not wander from it again.

-- C.S. Peirce in How to Make Our Ideas Clear, 1878

%%tth:\end{quote}
   
\pagedone
  
\sectionhead{Finite automata}

\begin{itemize}
	\item This will be a quick tour through some of the basics of the abstract theory
	     of computation.  We will start with a relatively straightforward class of
	     machines and languages -- deterministic finite automata and regular languages.
	     
	     In this context when we talk about a machine, we mean an abstract rather
	     than a physical machine, and in general will think in terms of a computer
	     algorithm that could be implemented in a physical machine.  Our descriptions
	     of machines will be abstract, but are intended to be sufficiently precise
	     that an implementation could be developed.

\pagedone

	\item A deterministic finite automaton (DFA) $\mathrm{M} = (\mathrm{S}, \mathrm{A},
         s_0, \delta, \mathrm{F})$ consists of the following:
	     \begin{description}
	        \item $\mathrm{S}$, a finite set of states,
	        \item $\mathrm{A}$, an alphabet,
	        \item $s_0 \in \mathrm{S}$, the start state,
	        \item $\delta : \mathrm{S} \mathrm{x} \mathrm{A} \to \mathrm{S}$,
	            the transition function, and
	        \item $\mathrm{F} \subset \mathrm{S}$, the set of final (or accepting)
	            states of the machine.
	     \end{description}
	     
	     We think in terms of feeding strings from $\mathrm{A}^*$ into the machine. 
         To do this, we extend the transition function to a function
         $$\hat{\delta} : \mathrm{S} \mathrm{x} \mathrm{A}^* \to \mathrm{S}$$
         by
         \begin{eqnarray*}
             \hat{\delta}(s, \epsilon) & = & s,\\
             \hat{\delta}(s, xa) & = & \hat{\delta}(\delta(s, a), x).
         \end{eqnarray*}
         
         We can then define the language of the machine by
         $$\mathit{L}(\mathrm{M}) = \{x \in \mathrm{A}^*\ \vert\ 
            \hat{\delta}(s_0, x) \in \mathrm{F}\}.$$
         In other words, $\mathit{L}(\mathrm{M})$ is the set of all strings
         in $\mathrm{A}^*$ that move the machine via its transition function from
         the start state $s_0$ into one of the final (accepting) states.
         
         We can think of the machine $\mathrm{M}$ as a recognizer for
         $\mathit{L}(\mathrm{M})$, or as a string processing function
         $$f_{\mathrm{M}} : \mathrm{A}^* \to \{1, 0\}$$
         where $f_{\mathrm{M}}(x) = 1$ exactly when $x \in \mathit{L}(\mathrm{M})$.

     \item There are several generalizations of DFAs that are useful in various contexts.
         A first important generalization is to add a nondeterministic capability to the
         machines.  A nondeterministic finite automaton (NFA)
         $\mathrm{M} = (\mathrm{S}, \mathrm{A},  s_0, \delta, \mathrm{F})$ is the same
         as a DFA except for the transition function:
	     \begin{description}
	        \item $\mathrm{S}$, a finite set of states,
	        \item $\mathrm{A}$, an alphabet,
	        \item $s_0 \in \mathrm{S}$, the start state,
	        \item $\delta : \mathrm{S} \mathrm{x} \mathrm{A} \to \mathit{P}(\mathrm{S})$,
	            the transition function,
	        \item $\mathrm{F} \subset \mathrm{S}$, the set of final (or accepting)
	            states of the machine.
	     \end{description}
	     For a given input symbol, the transition function can take us to any one of
	     a set of states.
	     
	     We extend the transition function to $\hat{\delta} : \mathrm{S} \mathrm{x}
         \mathrm{A}^* \to \mathit{P}(\mathrm{S})$ in much the same way:
	     \begin{eqnarray*}
             \hat{\delta}(s, \epsilon) & = & s,\\
             \hat{\delta}(s, xa) & = & \bigcup_{r \in \delta(s, a)}\hat{\delta}(r, x).
         \end{eqnarray*}
         We define the language of the machine by
         $$\mathit{L}(\mathrm{M}) = \{x \in \mathrm{A}^*\ \vert\ 
            \hat{\delta}(s_0, x) \cap \mathrm{F} \ne \emptyset \}.$$
         
         A useful fact is that DFAs and NFAs define the same class of languages.  In
         particular, given a language $\mathrm{L}$, we have that $\mathrm{L} =
         \mathit{L}(\mathrm{M})$ for some DFA $\mathrm{M}$ if and only if
         $\mathrm{L} = \mathit{L}(\mathrm{M'})$ for some NFA $\mathrm{M'}$.
         
         Exercise:  Prove this fact.
         
         In doing the proof, you will notice that if
         $\mathrm{L} = \mathit{L}(\mathrm{M}) = \mathit{L}(\mathrm{M'})$ for some DFA
         $\mathrm{M}$ and NFA $\mathrm{M'}$, and $\mathrm{M'}$ has $n$ states, then
         $\mathrm{M}$ might need to have as many as $2^n$ states.  In general, NFAs
         are relatively easy to write down, but DFAs can be directly implemented.
         
      \item Another useful generalization is to allow the machine to change states
         without any input (often called $\epsilon$-moves).  An NFA with $\epsilon$-moves
         would be defined similarly to an NFA, but with transition function
         $$\delta : \mathrm{S} \mathrm{x} (\mathrm{A} \cup \{\epsilon\}) \to
             \mathit{P}(\mathrm{S}).$$
         Exercise:  What would an appropriate extended transition function $\hat{\delta}$
         and language $\mathit{L}(\mathrm{M})$ be for an NFA with $\epsilon$-moves?
         
         Exercise:  Show that the class of languages defined by NFAs with $\epsilon$-moves
         is the same as that defined by DFAs and NFAs.
         
         Here is a simple example.  By convention, the states in F are double
         circled.  Labeled arrows indicate transitions.
         Exercise:  what is the language of this machine?
      
        \vspace{1cm}
             
        \centerline{\includegraphics[width = 4in]{DFA-even-odd}}
        
\end{itemize}


\pagedone


\sectionhead{Regular expressions and languages}
\begin{itemize}
	\item In the preceding section we defined a class of machines (Finite Automata) that
	   can be used to recognize members of a particular class of languages.  It would
	   be nice to have a concise way to describe such a language, and furthermore to
	   have a convenient way to generate strings in such a language (as opposed to
	   having to feed candidate strings into a machine, and hoping they are recognized
	   as being in the language \ldots).
	   
	   Fortunately, there is a nice way to do this.  The class of languages defined
	   by Finite Automata are called Regular Languages (or Regular Sets of strings).
	   These languages are described by Regular Expressions.  We define these as
	   follows.  We will use lower case letters for regular expressions, and upper case
	   for regular sets.
	   
	\item Definition:  Given an alphabet $\mathrm{A}$, the following are regular
       expressions / regular sets over $\mathrm{A}$:
       
	   $\begin{matrix}
	      \mathrm{Expressions:}              &  \mathrm{Sets:}\\
	      \emptyset                          &  \emptyset\\
	      \epsilon                           &  \{\epsilon\}\\
	      a,\ \mathrm{for}\ a \in \mathrm{A} &  \ \ \ \ \{a\},\ \mathrm{for}\ a \in
                                                    \mathrm{A}\\
                                             &  \\
	      \mathrm{If\ r\ and\ s\ are}        &  \ \ \ \ \mathrm{If\ R\ and\ S\ are}\\
	      \mathrm{regular,\ then}            &  \ \ \ \ \mathrm{regular,\ then}\\
	      \mathrm{so\ are:}                  &  \ \ \ \ \mathrm{so\ are:}\\
	                                         &  \\
	      \mathrm{r + s}                     &  \mathrm{R} \cup \mathrm{S} \\
	      \mathrm{rs}                        &  \mathrm{RS}\\
	      \mathrm{r}^*                       &  \mathrm{R}^*\\
	    \end{matrix}
	   $
	   
	   and nothing else is regular.
	   
	   We say that the regular expression on the left represents the corresponding
	   regular set on the right.  We say that a language is a regular language if the
	   set of strings in the language is a regular set.

\pagedone

	   A couple of examples:
	 \vspace{-1.25cm}
    \item The regular expression
	   $$(00 + 11)^*(101 + 110)$$
	   represents the regular set (regular language)
	   
	   $\{101, 110, 00101, 00110, 11101, 11110,\newline
	   0000101, 0000110, 0011101, 0011110, \ldots\}.$
	   
	   Exercise:  What are some other strings in this language?  Is $00110011110$
	   in the language?  How about $00111100101110$?
	   
	 \item A protein motif pattern, described as a (slight variation of our) regular
	   expression.
	   
	   \vspace{1cm}
	          
        \centerline{\includegraphics[width = 5in]{RNP-1-motif}}

\pagedone

	\item It is a nice fact that regular languages are exactly the languages of the finite
	   automata defined in the previous section.  In particular, a language
	   $\mathrm{L}$ is a regular set (as defined above) if and only if
	   $\mathrm{L} = \mathit{L}(\mathrm{M})$ for some finite automaton $\mathrm{M}$.
	   
	   The proof of this fact is relatively straightforward.
	
	   For the first half, we need to show that if $\mathrm{L}$ is a regular set (in
	   particular, if it is represented by a regular expression $\mathrm{r}$), then
	   $\mathrm{L} = \mathit{L}(\mathrm{M})$ for some finite automaton $\mathrm{M}$.
	   We can show this by induction on the size of the regular expression $\mathrm{r}$.
	   The basis for the induction is the three simplest cases: $\emptyset$,
	   $\{\epsilon\}$, and $\{a\}$.  (Exercise:  find machines for these three cases.)  We
	   then show that, if we know how to build machines for $\mathrm{R}$ and $\mathrm{S}$,
	   then we can build machines for $\mathrm{R} \cup \mathrm{S},\ \mathrm{RS}$, and
	   $\mathrm{R}^*$.  (Exercise:  Show how to do these three -- use NFAs with
       $\epsilon$-moves.)
       
       For the second half, we need to show that if we are given a DFA
       $\mathrm{M}$, then we can find a regular expression (or a regular set
       representation) for $\mathit{L}(\mathrm{M})$.  We can do this by looking
       at sets of strings of the form
       
       $\mathrm{R}_{ij}^k = \{x \in \mathrm{A}^*\ \vert\ x$ $\mathrm{takes\ M}$
                from state $s_i$ to state $s_j$ without going through (into and out of)
                any state $s_m$ with $m \ge k\}.$
                
       Note that if the states of $\mathrm{M}$ are $\{s_0, s_1, \ldots, s_{n-1}\}$, then
       $$\mathit{L}(\mathrm{M}) = \bigcup_{s_j \in \mathrm{F}}\mathrm{R}_{0j}^n.$$
       We also have
       $$\mathrm{R}_{ij}^0 = \{a \in \mathrm{A}\ \vert\ \delta(s_i, a) = s_j\}$$
       (for $i = j$, we also get $\epsilon$ \ldots),
       
       and, for $k \ge 0$,
       $$\mathrm{R}_{ij}^{k+1} = \mathrm{R}_{ij}^{k} \cup \mathrm{R}_{ik}^{k}
          (\mathrm{R}_{kk}^{k})^*\mathrm{R}_{kj}^{k}.$$
       Exercise:  Verify, and finish the proof.
	    



\end{itemize}
\pagedone

\quotesection{Mathematical certainty}
%%tth:\begin{quote}
I wanted certainty in the kind of way in which people want religious faith.
I thought that certainty is more likely to be found in mathematics than elsewhere.
But I discovered that many mathematical demonstrations, which my teachers expected me to accept,
were full of fallacies, and that, if certainty were indeed discoverable in mathematics,
it would be in a new field of mathematics, with more solid foundations than those
that had hitherto been thought secure. But as the work proceeded, I was continually reminded of the
fable about the elephant and the tortoise. Having constructed an elephant upon which the
mathematical world could rest, I found the elephant tottering, and proceeded to construct a
tortoise to keep the elephant from falling. But the tortoise was no more secure than the elephant,
and after some twenty years of very arduous toil, I came to the conclusion that there was nothing
more that I could do in the way of making mathematical knowledge indubitable.

-- Bertrand Russel in Portraits from Memory

%%tth:\end{quote}
   
\pagedone

\sectionhead{Markov models}
\begin{itemize}
	\item An important related class of systems are Markov models (often called
	   Markov chains).  These models are quite similar to finite automata, except
	   that the transitions from state to state are probabilistically determined,
	   and typically we do not concern ourselves with final or accepting states.
	   Often, in order to keep track of the (stochastic) transitions the system is
	   making, we have the system emit a symbol, based either on which transition
	   occurred, or which state the system arrived in.  These machines take no
	   input (except whatever drives the probabilities), but do give output strings.
	   
	   Markov models can often be thought of as models for discrete dynamical
	   systems.  We model the system as consisting of a finite set of states, with
	   a certain probability of transition from a state to any other state.
	   
\pagedone

	   The typical way to specify a Markov model is via a transition
	   matrix:
	   \[
          \mathrm{T} = 
          \left[ 
            \begin{array}{cccc}
	          p_{11} & p_{12} & \cdots & p_{1n} \\
	          p_{21} & p_{22} & \cdots & p_{2n} \\
	          \vdots & \vdots & \ddots & \vdots \\
	          p_{n1} & p_{n2} & \cdots & p_{nn} \\
	        \end{array}
	      \right]
       \]

       where $0 \le p_{ij} \le 1$, and $\sum_jp_{ij} = 1.$
       
       Each entry $p_{ij}$ tells the probability the system will go from
       state $s_i$ to state $s_j$ in the next time step.
       
       The transition probabilities over two steps are given by $\mathrm{T}^2$.
       Over $n$ steps, the probabilities are given by $\mathrm{T}^n$.
       
       Exercises:  Suppose we run the system for very many steps.  How might we
       estimate the relative probabilities of being in any given state?
       
       What information about the system might we get from eigenvalues and
       eigenvectors of the matrix $\mathrm{T}$?
       
\pagedone

     \item A couple of examples:
     
        First, a generic Markov model for DNA sequences:
       
        \centerline{\includegraphics[width = 2in]{ACGT-Markov}}

        An outline for a more complex model, of a type often called
        a hidden Markov model.
          
        \centerline{\includegraphics[width = 5in]{Pairwise-align-HMM}}

\end{itemize}
\pagedone

\quotesection{I had a feeling once about Mathematics}
%%tth:\begin{quote}
I had a feeling once about Mathematics - that I saw it all.
Depth beyond depth was revealed to me - the Byss and Abyss.
I saw - as one might see the transit of Venus or even the Lord Mayor's Show
- a quantity passing through infinity and changing its sign from plus to minus.
I saw exactly why it happened and why the tergiversation was inevitable
but it was after dinner and I let it go.

-- Sir Winston Churchill

%%tth:\end{quote}
   
\pagedone

\sectionhead{Context free grammars and languages}
\begin{itemize}
     \item While regular languages are very useful, not every interesting language
          is regular.  It is not hard to show that even such simple languages
          as balanced parentheses or palindromes are not regular.  (Here is probably
          a good place to remind ourselves again that in this context, a language
          is just a set of strings \ldots)
          
          A more general class of languages is the context free languages.  A
          straightforward way to specify a context free language is via a context
          free grammar.  Context free grammars can be thought of as being for
          context free languages the analogue of regular expressions for regular
          languages.  They provide a mechanism for generating elements on the
          language.
          
     \item A context free grammar G = (V, T, S, P) consists of a two alphabets V
          and T (called variables and terminals, respectively), an element S $\in$ V
          called the start symbol, and a finite set of production rules P.  Each
          production rule is of the form $A \to \alpha$,
          where A $\in$ V and $\alpha \in (\mathrm{V} \cup \mathrm{T})^*$.
          
          We can use such a production rule to generate new strings from old strings.
          In particular, if we have the string $\gamma A \delta \in
          (\mathrm{V} \cup \mathrm{T})^*$ with $\mathrm{A} \in \mathrm{V}$,
          then we can produce the new string $\gamma \alpha \delta$.  The application
          of a production rule from the grammar G is often
          written $\alpha \underset{\mathrm{G}}{\Rightarrow} \beta$, or just
          $\alpha \Rightarrow \beta$ if the grammar is clear.
          The application of 0 or more production rules one after the other is written
          $\alpha \overset{*}{\Rightarrow} \beta$.
          
          The language of the grammar G is then
          $$\mathit{L}(\mathrm{G}) = \{\alpha \in \mathrm{T}^*\ \vert \ 
               \mathrm{S} \overset{*}{\Rightarrow} \alpha\}.$$
          The language of such a grammar is called a context free language.
          
\pagedone

      \item Here, as an example, is the language consisting of strings of
          balanced parenthese.  Note that we can figure out which symbols
          are variables, since they all occur on the left side of some
          production.
          \begin{eqnarray*}
              \mathrm{S} & \to &  \mathrm{R}\\
              \mathrm{R} & \to &  \epsilon\\
              \mathrm{R} & \to &  (R)\\
              \mathrm{R} & \to &  RR\\
          \end{eqnarray*}
          Exercise:  Check this.  How would we modify the grammar if we wanted
          to include balanced `[]' and `\{\}' pairs also? 
      \item Here is a palindrome language over the alphabet T = \{a, b\}:
          \begin{eqnarray*}
              \mathrm{S} & \to &  \mathrm{R}\\
              \mathrm{R} & \to &  \epsilon\ \vert\ \mathrm{a}\ \vert\ \mathrm{b}\\
              \mathrm{R} & \to &  \mathrm{aRa}\ \vert\ \mathrm{bRb}\\
          \end{eqnarray*}
          (note the `$\vert$' to indicate alternatives \ldots)
          
\pagedone

          Exercise:  What would a grammar for simple algebraic expressions
          (with \newline terminals T = \{x, y, +, -, *, (, )\}) \newline
          look like?
          
      \item A couple of important facts are that any regular language is
          also context free, but there are context free languages that are
          not regular.
          
          Exercise:  How might one prove these facts?
          
      \item Context free grammars can easily be used to generate strings in
          the corresponsing language.  We would also like to have machines
          to recognize such languages.  We can build such machines through
          a slight generalization of finite automata.  The generalization is
          to add a `pushdown stack' to our finite automata.  These more
          powerful machines are called pushdown automata, or PDAs \ldots
          
      \item  Here is an example -- this is a grammar for the RNP-1 motif
          from an earlier example.  This also gives an example of what
          a grammar for a regular language might look like.  Question:
          what features of this grammar reflect the fact that it is for
          a regular language?
          
          \ \ \ RNP-1 motif grammar
          \begin{eqnarray*}
             S   & \to & rW_1\ \vert\ kW_1 \\
             W_1 & \to & gW_2 \\
             W_2 & \to & [afilmnqstvwy]W_3 \\
             W_3 & \to & [agsci]W_4 \\
             W_4 & \to & fW_5\ \vert\ yW_5\\
             W_5 & \to & [liva]W_6 \\
             W_6 & \to & [acdefghiklmnpqrstvwy]W_7 \\
             W_7 & \to & f\ \vert\ y\ \vert\ m \\ 
          \end{eqnarray*}

\pagedone

       \item Could we build a context free
          grammar for the primary structure of this tRNA that would reflect
          the secondary structure?  What features could be variable, and
          which must be fixed in order for the tRNA to function appropriately
          in context?         
        \centerline{\includegraphics[width = 5in]{yeast-tRNA-Phe}}
        

        
        
\end{itemize}
\pagedone

\quotesection{Terminology (philosophy and math)}
%%tth:\begin{quote}
Somebody once said that philosophy is the misuse of a terminology
which was invented just for this purpose.
In the same vein, I would say that mathematics is the science
of skillful operations with concepts and rules
invented just for this purpose.

-- Eugene Wigner

%%tth:\end{quote}
   
\pagedone

\sectionhead{Language recognizers and generators}

\begin{itemize}

     \item There is a nice duality between the processes of generating and recognizing
         elements of a language.  Often what we want is a (reasonably efficient) machine
         for recognizing elements of the language.  These machines are sometimes called
         parsers, or syntax checkers, or lexical analyzers.  If you have a language
         compiler (for C++, for example), typically a first pass of the compiler does
         this syntax checking.
         
         The other thing we are likely to want is a concise specification of the syntax
         rules for the language.  These specifications are often called grammars.  We
         have looked briefly at context free grammars.  A more general form of grammars
         are the context sensitive grammars.
         
     \item A grammar for a language gives a concise specification of the pattern a string
         must reflect in order to be part of the language.  We have described grammars
         as generators of the languages, in the sense that given the grammar, we can
         (ordinarily) generate strings in the language in a methodical way.
         
         In practice, we often use grammars as guides in generating language strings
         to accomplish particular tasks.  When we write a C++ program, the grammar tells
         us which symbols are allowed next in our program.  We choose the particular
         symbol -- we generate the string, constrained by the grammar.
         
         Another thing we would like our grammar to do is provide a mechanism for
         constructing a corresponding language recognizing machine.  This process
         has largely been automated for classes of languages like the regular, context
         free, and context sensitive languages.  For unix people, the `re' in `grep'
         stands for `regular expression,' and the tool `lex' is a lexical analyzer
         constructor.
         
     \item Of course by now you are wondering about the relationships between languages
         and meaning \ldots
         
         In the context of at least some computer languages, there is a way we can begin
         to approach this question.  We can say that the meaning of a language element
         is the effect it has in the world (in particular, in a computer when the program
         is run).  Thus, for example, in C++, the statement (language element)
         $$j = 5;$$
         has the effect of finding the memory location associated with the name `j',
         and updating that location to the value 5.
         
         There are some useful tools, such as `yacc' (yet another compiler compiler)
         (the Gnu public license version of this is called Bison \ldots)
         that do a decent job of automating the process of carrying out these
         linkages between language elements and hardware effects \ldots
         
         Perhaps another day I'll write another section (or another piece) on `meaning.'
         
         For now, let me just leave this with Wittgenstein's contention that
         meaning is use \ldots

\end{itemize}

\pagedone

\quotesection{Rewards}
%%tth:\begin{quote}
Down the line, you can find all kinds of constraints and openings for
freedom, limitations on violence, and so on that can be attributed to
popular dissidence to which many individuals have contributed, each in a
small way. And those are tremendous rewards. There are no President's Medals
of Honour, or citations, or front pages in the New York Review of Books. But
I don't think those are much in the way of genuine rewards, to tell you the
truth. Those are the visible signs of prestige; but the sense of community
and solidarity, of working together with people whose opinions and feelings
really matter to you... that's much more of a reward than the
institutionally-accepted ones.

-- Noam Chomsky
%%tth:\end{quote}
   
\pagedone

\sectionhead{The Chomsky hierarchy}

\begin{itemize}

       \item  The tools and techniques we have been talking about here are often
           used to develop a specialized language for a particular task.
           
           A potentially more interesting (and likely more difficult) task is to
           work with an existing or observed language (or language system) and try
           to develop
           a grammar or recognizer for the language.  One typical example of this
           might be to work with a natural (human?) language such as English or
           Spanish.
           
           In a more general form, we would be looking at any system that can be
           represented by strings of symbols, and we would attempt to discover
           and represent patterns and structures within the collection of observed
           strings (i.e., within the language of the system).
           
       \item In the 1950's, linguists applied the approaches of formal language
           theory to human languages.  Noam Chomsky in particular looked at the
           relative power of various formal language systems (i.e., the range of
           languages that could be specified by various formal systems).  He is
           typically credited with establishing relationships among various formal
           language systems -- now known as the Chomsky Hierarchy.
           
           Chomsky and other linguists had observed that very young children
           acquire language fluency much more rapidly and easily than one would
           expect from typical ``learning algorithms,'' and therefore he hypothesized
           that the brain must embody some sort of ``general language machine''
           which would, during early language exposure, be particularized to the
           specific language the child acquired.  He therefore studied possible
           ``general language machines.''  His hope was that by characterizing
           various such machine types, linguists would be able to develop
           abstract formal grammars for human languages, and thus understand
           much more about languages in general and in particular.
           
           In many respects, this project is still in process.  On the next page
           is a slightly generalized outline of the classical Chomsky Hierarchy
           of formal languages.  Human languages don't fit neatly into any one
           of the categories -- at the very least, human languages are context
           sensitive, but with additional features.  Also, though, since Chomsky's
           work in the 1950s, many more language categories have been identified
           (probably in the hundreds by now).
           
           An interesting (and relatively deep) question is whether it fully makes
           sense to expect there to be a concise formal grammar for a particular
           human language such as English -- and what exactly that would mean \ldots
           
\pagedone
         
        \vspace{2cm}
             
        \centerline{\includegraphics[width = 6in]{Chomsky-hierarchy}}
   
        \vspace{.5cm}        
        
        \begin{tabular}{|l|l|} \hline
          Languages & Machines\\ \hline \hline
          Regular  &  DFA or NFA \\ \hline
          Deterministic & Deterministic push-down \\
          \ \ context free & \ \ automata\\ \hline
          Context free & Nondeterministic PDA \\ \hline
          Context & Linear bounded automata \\
          \ \ sensitive & \ (Turing, bounded tape)\\ \hline
          Recursive & Turing machines that\\
                    & \ \ halt on every input \\ \hline
          Recursively & General Turing machines \\
          \ \ enumerable & \\
          \hline 
        \end{tabular}       

\pagedone

    \item For purposes of research, it is worthwhile to be aware of the
        wide variety of formal language types that have been studied and
        written about.  Often, though, it makes sense to restrict one's
        attention to a particular language class, and see which portions
        of the problem at hand are amenable to that class.
        
        For example, the regular languages are very concise, easy to work
        with, and many relevant tools and techniques have been developed.
        In particular, there has been much research on Markov models.  It
        thus often makes sense to try to develop a regular or Markov approach
        to your problem, such as the work by Jim Crutchfield on $\epsilon$-machines
        \ldots
        
        Another important example (as indicated above) is work that has been done
        appliying hidden Markov models to the analysis of genome sequence problems \ldots
        
\end{itemize}
\pagedone

\sectionhead{Turing machines}
\begin{itemize}

	\item During the 1930s, the mathematician Alan Turing worked on the general problem
	   of characterizing computable mathematical functions.  In particular, he started
	   by constructing a precise definition of ``computability.''  The essence of his
	   definition is the specification of a general computing machine -- what is today
	   called the Turing machine.
	   
	   Once having specified a particular definition of ``computability,'' Turing
	   was able to prove that there are mathematical functions that are not computable.
	   Of course, one cannot ``prove'' that a definition itself is ``correct,'' but can only
	   observe that it is useful for some particular purposes, and maybe that it seems
	   to do a good job of capturing essential features of some pre-existing general
	   notions or intuitions.  See, though, the Church-Turing thesis \ldots
	   
    \item The basic elements of the Turing machine are a (potentially) infinite ``tape''
	   on which symbols can be written (and re-written), and a finite state control
	   with a read/write head for accessing and updating the tape.  Turing
	   used as his intuitive model a mathematician working on a problem.  The mathematician
	   (finite state control) would read a page (the symbol in one cell on the tape),
	   think a bit (change state), possibly rewrite the page (change the
	   symbol in the cell), and then turn either back or forward
	   a page.
        
            
 \vspace{1cm}
             
        \centerline{\includegraphics[width = 5in]{Turing-Machine}}
        
\pagedone

    \item More formally, a Turing machine \newline
       $T = (\mathrm{S}, A, \delta, s_0, b, F)$ consists of:

    $   \mathrm{S}  =  \mathrm{a\ finite\ set\ of\ states}, \newline
        A  =  \mathrm{an\ alphabet}, \newline
        \delta  :  \mathrm{S x (A \cup \{b\}) \to S x (A \cup \{b\}) x \{L, R\}}, \newline
        \mathrm{\ \ \ \ \ \ the\ transition\ function}, \newline
        s_0  \in  \mathrm{S,\ the\ start\ state}, \newline
        b\mathrm{,\ marking\ unused\ tape\ cells,\ and} \newline
        F  \subset  \mathrm{S,\ halting\ and/or\ accepting\ states}.
   $
   
       To run the machine, it is first set up with a finite input string
       (from $A^*$) written on the tape (and
       the rest of the tape initialized to the blank symbol '$b$').  The machine
       is started in the start state ($s_0$) with its read/write head pointing
       at the first symbol in the input string.  The machine then follows the
       instructions of the $\delta$ function -- depending on its current state
       and the symbol being read in the current tape cell, the machine changes state,
       writes a (possibly) new symbol in the current tape cell, and then moves the read/write
       head one cell either left or right.  The machine continues processing until
       it enters a halting state (in $F$).  Note that it is possible that the
       machine will go into an infinite loop and never get to a halting state \ldots
       
       There are several generic ways to think about what computation is being done
       by the machine:
       
       \begin{enumerate}
         \item Language recognizer:  an input string from $A^*$ is in the language L(T)
             of the machine if the machine enters a halting (accepting) state.
             The string is not in the language otherwise.  Languages of such machines
             are called {\em recursively enumerable} languages.
    
         \item Language recognizer (special): a subset of the halting states are
             declared to be `accepting' states (and the rest of the halting state
             are `rejecting' states).  If the machine halts in an accepting state,
             the string is in the language L(T).  If the machine halts in a rejecting state,
             or never halts, the string is not in the language.  
             In this special case, there are some
             particular machines that enter some halting state for every input
             string in $A^*$.  Languages of these particular 
             machines which halt on every input are called {\em recursive} languages.
             
         \item String processor:  given an input string, the result of the computation
             is the contents of the tape when the machine enters a halting state.
             Note that it may be that the machine gives no result for some input
             strings (i.e., never enters a halting state).  For these machines,
             the partial function computed by the machine is a {\em partial recursive}
             function.
             
         \item String processor (special):  If the machine halts on every input
             string, the function computed by the machine is a {\em recursive}
             function.
       \end{enumerate}
       
       \item Turing proved a number of important facts about such machines.  One
           of his deepest insights was that it is possible to encode a Turing
           machine as a finite string of symbols.  Consider a machine
           $T = (\mathrm{S}, A, \delta, s_0, b, F)$.  Each of
           $\mathrm{S}, A,\mathrm{\ and\ } F$ is a finite set, and thus can
           be encoded as a single number (the number of elements in the set).
           We can assume that $s_0$ is the first of the states, so we don't need
           to encode that.  We can assume (possibly by reordering) that the
           states $F$ are at the end of the list of states, so we only need to
           know how many there are.  The symbols in $A$ are arbitrary, so we
           only need to know how many there are.  The blank symbol $b$ can be
           encoded as though it were an extra last symbol in A.  The only slightly tricky part
           is the transition function $\delta$, but we can think of $\delta$ as
           being a (finite) set of ordered 5-tuples $(s_i, a_i, s_j, a_j, d)$
           where $d$ (direction) is either L or R.  There will be $\vert S \vert
           *(\vert A \vert + 1)$ such 5-tuples.  Thus, an example
           Turing machine might be encoded by \newline
           $(3, 2, 1,\newline
           (0, 0, 0, 1, R), (0, 1, 2, 1, L), (0, 2, 2, 2, R),\newline
           (1, 0, 0, 0, R), (1, 1, 1, 0, R), (1, 2, 2, 2, L), \newline
           (2, 0, 0, 1, L), (2, 1, 2, 0, R), (2, 2, 1, 1, R))$
           
           where there are three states, two alphabet symbols, and one halting state
           (state 2, but not states 0 or 1).  We have encoded $b$ as `2'.
           
           Exercise:  Draw the finite state control for this machine. (Can you
           figure out what the language of this machine is?)
           
\pagedone

       \item Turing's next insight was that since we can encode a machine as
           a finite string of symbols, we could use that string of symbols
           as the input to some other Turing machine.  In fact, if we are careful,
           we can construct a Universal Turing Machine -- a Turing machine that
           can simulate any other Turing machine!  Turing gave the specifications
           of such a machine.  We can call the universal Turing machine UTM.
           
           In particular, if we have a specific Turing machine $T$ and a specific
           input string $\sigma$ for the machine $T$, we work out the encoding
           for the machine $T$ in the alphabet symbols of the UTM, and the encoding
           of the string $\sigma$ in the alphabet symbols of the UTM, concatenate the
           two strings together, and use that as the input string to the UTM.  The
           UTM then shuttles back and forth between the encoding of the string $\sigma$
           and the `instructions' in the encoding of $T$, simulating the computation
           of $T$ on $\sigma$.

\pagedone

       \item Turing proved a variety of important facts about Turing machines.  For example,
           he proved that there cannot be a does-it-halt machine -- that is, the question
           of whether or not a given Turing machine halts on a given input is noncomputable.
           No machine can be guaranteed to halt giving us a yes/no answer to this question
           for all machines and strings.  In effect, the only sure way to tell if a given
           Turing machine halts on a given string is to run it -- of course, the problem
           is that if it doesn't halt (goes into an infinite loop), you can't know for
           sure it's in an infinite loop until you wait forever!
           
           In fact, it turns out that almost all interesting questions about Turing
           machines (in fact, essentially any non-trivial question) is noncomputable
           (in the language of art, these are called {\em undecidable} questions).
           In effect, in trying to answer any non-trivial question, you might fall
           into an infinite loop, and there is no sure way to know when you are in
           an infinite loop!
           
       \item Some other important theoretical work being done almost the same time as
           Turing's work was Kurt G\"odel's work on the incompleteness of logical
           systems.  G\"odel showed that in any (sufficiently general) formal logical
           system, there are true statements that are not provable within the system.
           
           If we put Turing's results together with G\"odel's, we can say in effect
           that Truth is a noncomputable function.  Mathematically, Turing's and
           G\"odel's fundamental results are equivalent to each other.  You
           can't be guaranteed to know what's true, and sometimes the best you can
           do is run the simulation and see what happens \ldots
\end{itemize}
\pagedone

\sectionhead{Computability and tractability}

\begin{itemize}

    \item We have already observed that there are some problems that are not
       computable -- in particular, we showed the existence of languages for
       which there cannot be an algorithmic recognizer to determine which
       strings are in the language.  Another important example of a noncomputable
       problem is the so-called halting problem.  In simple terms, the question is,
       given a computer program, does the program contain an infinite loop?  There
       cannot be an algorithm that is guaranteed to correctly answer this question
       for all programs.
       
       More practically, however, we often are interested in whether a program can
       be executed in a `reasonable' length of time, using a reasonable amount of
       resources such as system memory.
       
	\item We can generally categorize computational algorithms according to how the
	     resources needed for execution of the algorithm increase as we increase the
	     size of the input.  Typical resources are time and (storage) space.  In
	     different contexts, we may be interested in worst-case or average-case
	     performance of the algorithm.  For theoretical purposes, we will typically
	     be interested in large input sets \ldots

\pagedone
	\item A standard mechanism for comparing the growth of functions with domain
	    $\mathbb{N}$ is ``big-Oh.''  One way of defining this notion is to associate
	    each function with a set of functions.  We can then compare algorithms by
	    looking at their ``big-Oh'' categories.  
	\item Given a function $f$, we define $O(f)$ by:
$$ g \in O(f) \iff $$
\centerline{there exist $c > 0$ and $N \ge 0$ such that}
\centerline{$\vert g(n) \vert \le c\vert f(n) \vert $ for all $n \ge N$.}
	\item We further define $\theta(f)$ by:
	
\centerline{$g \in \theta(f)$ iff $g \in O(f)$ and $f \in O(g)$.}
\pagedone
	\item In general we will consider the run-time of algorithms in terms of the growth
	    of the number of elementary computer operations as a function of the number of
	    bits in the (encoded) input.  Some important categories -- an algorithm's run-time
	    $f$ is:
	
	\begin{enumerate}
		\item Logarithmic if $f \in \theta(\log(n))$.	
		\item Linear if $f \in \theta(n)$.	
		\item Quadratic if $f \in \theta(n^2)$.	
		\item Polynomial if $f \in \theta(P(n))$ for some polynomial $P(n)$.	
		\item Exponential if $f \in \theta(b^n)$ for some constant $b > 1$.	
		\item Factorial if $f \in \theta(n!)$.
	
	\end{enumerate}
\pagedone
	\item Typically we say that a problem is {\em tractable} if (we know) there
	    exists an algorithm whose run-time is (at worst) polynomial that solves the
	    problem.  Otherwise, we call the problem {\em intractable}.

	\item There are many problems which have the interesting property that if someone
	    (an oracle?) provides you with a solution to the problem, you can tell in
	    polynomial time whether what they provided you actually is a solution.  Problems
	    with this property are called Non-deterministically Polynomial, or NP, problems.
	    One way to think about this property is to imagine that we have arbitrarily many
	    machines available.  We let each machine work on one possible solution, and
	    whichever machine finds the (a) solution lets us know.
	\item There are some even more interesting NP problems which are universal for
	    the class of NP problems.  These are called NP-complete problems.  A problem
	    $S$ is NP-complete if $S$ is NP and, there exists a polynomial time algorithm
	    that allows us to translate any NP problem into an instance of $S$.  If we could
	    find a polynomial time algorithm to solve a single NP-complete problem, we would
	    then have a polynomial time solution for each NP problem.
\pagedone
	\item Some examples:
	
	\begin{enumerate}
		\item Factoring a number is NP.  First, we recognize that if $M$ is the number
		    we want to factor, then the input size $m$ is approximately $\log(M)$
		    (that is, the input size is the number of digits in the number).  The
		    elementary school algorithm (try dividing by each number less than $\sqrt M$)
		    has run-time approximately $10^{\frac{m}{2}}$, which is exponential in the
		    number of digits.  On the other hand, if someone hands you two numbers they
		    claim are factors of $M$, you can check by multiplying, which takes on the
		    order of $m^2$ operations.

            It is worth noting that there is a polynomial time algorithm to determine
            whether or not a number is prime, but for composite numbers, this algorithm
            does not provide a factorization.  Factoring is a particularly important
            example because various encryption algorithms such as RSA (used in the PGP
            software, for example) depend for their security on the difficulty of factoring
            numbers with several hundred digits.
\pagedone
		\item Satisfiability of a boolean expression is NP-complete.  Suppose we have
		    $n$ boolean variables $\{b_1,b_2,\ldots,b_n\}$ (each with the possible
		    values 0 and 1).  We can form a general boolean expression from these
		    variables and their negations:
            $$ f(b_1,b_2,\ldots,b_n) = \bigwedge_k(\bigvee_{i,j\le n}(b_i,\sim b_j)).$$
            A solution to such a problem is an assignment of values 0 or 1 to each of
            the $b_i$ such that $f(b_1,b_2,\ldots,b_n) = $1.  There are $2^n$ possible
            assignments of values.  We can check an individual possible solution in
            polynomial time, but there are exponentially many possibilities to check.
            If we could develop a feasible computation for this problem, we would have
            resolved the traditional P$\overset{?}=$NP problem \ldots

\end{enumerate}

\end{itemize}

\pagedone

\sectionhead{Computational complexity}

\begin{itemize}
       \item  Suppose we have some system we are observing for a fixed length of time.
           We can imagine that we have set up a collection of instruments (perhaps
           just our eyes and ears), and are encoding the output of our instruments
           as a finite string of bits (zeros and ones).  Let's call the string of
           bits $\beta$.  Can we somehow determine
           (or meaningfully assign a numerical value of) the complexity of the system,
           just by looking at the string $\beta$?
           
       \item One approach is to calculate the information entropy of $\beta$.
           This approach, unfortunately, carries with it the dilemma that any entropy
           calculation will have to be relative to a probability model for the system,
           and there will be many possible probability models we could use.  For example,
           if we use as our model an unbiased coin, then $\beta$ is a possible
           outcome from that model (i.e., {\em a priori} we cannot
           exclude the random model), and the information entropy of $\beta$ is just
           the number of bits in $\beta$.  (What this really says is that the
           upper bound on the information entropy of $\beta$ is the number of
           bits \ldots)  On the other hand, there is a probability model where $\beta$
           has probability one, and all other strings have probability zero.
           Under this model, the entropy is zero.  Again, not particularly useful.
           (What this really says is that the lower bound on the entropy is zero \ldots)
           
           In order to use this approach effectively, we will have to run the system
           several times, and use the results together to build a probability model.
           What we will be looking for is the `best' probability model for the system --
           in effect, the limit as we observe the system infinitely many times.
           
       \item Another approach we might take is a Universal Turing Machine approach.
           What we do is this.  We pick a particular implementation of the UTM.  We
           now ask, ``What is the minimum length ($T, \sigma$) Turing machine / input
           string pair which will leave as output on the UTM tape the string $(T, \beta)$?''
           This minimal length is called the {\em computational complexity} of the
           string $\beta$.  There is, of course, some dependence on the details of
           the particular UTM chosen, but we can assume that we just use some standard
           UTM.
           
           Clearly a lower bound is zero (the same as the lower bound for entropy).
           As an upper bound, consider the machine $T_0$ which just halts immediately,
           no matter what input it is given.  Suppose we give as input to our UTM
           the string pair $(T_0, \beta)$.  This pair has the required property
           (it leaves $(T_0, \beta)$ as output on the UTM), and its length is
           essentially just the length of $\beta$ (this problem is only interesting
           if $\beta$ is reasonably long, and in fact the coding for $T_0$ is very short --
           exercise: write a typical encoding for the machine $T_0$).  Note that the upper
           bound also agrees with the entropy.
           
           In theory, the computational complexity of any string $\beta$ is well-defined
           (and exists?).  There is a nonempty set of Natural numbers which are the
           lengths of ($T, \sigma$) pairs which have our required property (the set is
           nonempty because ($T_0, \beta$) works), and therefore there is a (unique) 
           smallest element of the set.  QED.  (At some level, this satisfies the
           mathematician in me :-)
           
           In practice?  Ah, in practice.  Remember that by Turing's result on the
           halting problem, there is no guaranteed way to tell if a given Turing
           machine will even halt on a given input string, and hence, if you give
           me an arbitrary $(T, \sigma)$, I may just have to run it, and wait forever
           to know that it doesn't leave $(T, \beta)$ as output.  What that means is
           that the computational complexity is a noncomputable function!  However,
           we may be able to reduce the upper bound, by judicious choice of machines
           to test, putting reasonable limits on how long we let them run before we
           throw them out, and pure luck.  (At some level, this satisfies the computer
           scientist in me :-)
           
           The two parts, theory and practice, give the philosopher in me plenty to
           chew over :-)
           
       \item In the case of the entropy measure, we either have to observe the system
           for an infinitely long time to be sure we have the right probability model,
           or accept an incomplete result based on partial observations.  If we can
           only run the system for a limited time, we may be able to improve our
           entropy estimates by judicious subsampling of $\beta$.
           
           In the case of the computational complexity measure, we either have to run
           some machines for an infinitely long time in order to exclude them from
           consideration, or accept an incomplete result based on output from some
           but not all machines.
           
           We are in principle prevented from knowing some things!
            On the other hand, it has been shown that although in practice we can't
           be guaranteed to get the right answer to either the entropy or computational
           complexity values, we can be sure that they are (essentially) equal to
           each other, so both methods can be useful, depending on what we know about
           the system, and what our local goals are.
           

\end{itemize}

\pagedone

\footnotesize
 \bibliographystyle{plain}
\tthdump{\hypertarget{References}{}\hyperlink{Our general topics:}{\hfil \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ To top $\leftarrow$}}
%%tth:{\special{html: <A NAME="References"></A><a href="\#Top of file">       Top</a>}}


\vspace{-1.0 in}

\begin{thebibliography}{12}
%%tth:{\special{html: <font size="+0">}}

% \bibitem{bennett2}
% Bennett, C. H., 
% The Thermodynamics of Computation - a Review, 
% {\em International Journal of Theoretical Physics}, 
% {\bf 21}, No. 12, p. 905, 1982.
 
\bibitem{bennett3}
Bennett, C. H. and Landauer, R., 
The fundamental physical limits of computation,
{\em Scientific American,} July 38--46, 1985.
 
 \bibitem{bennett4}
 Bennett, C. H., 
 Demons, engines and the second law,
 {\em Scientific American} {\bf 257} no. 5 (November) pp 88--96,
 1987.

%  \bibitem{brillouin}
%  Brillouin, L.,
%  {\em Science and information theory}
%  Academic Press, New York, 1956.
% 
% \bibitem{brooks}
% Brooks, Daniel R., and Wiley, E. O.,
% {\em Evolution as Entropy}, Toward a Unified Theory of Biology,
% Second Edition,
% University of Chicago Press, Chicago, 1988.

\bibitem{campbell}
Campbell, Jeremy,
{\em Grammatical Man}, Information, Entropy, Language, and Life,
Simon and Schuster, New York, 1982.

\bibitem{chaitin}
Chaitin, G.,
{\em Algorithmic Information Theory},
Cambridge University Press, Cambridge, UK, 1990.

\bibitem{chomsky}
Chomsky, Noam,
Three models for a description of a language, {\em IRE Trans. on Information Theory},
2:3, 113-124, 1956.

\bibitem{chomsky2}
Chomsky, Noam,
On certain formal properties of grammars, {\em Information and Control},
2:2, 137-167, 1959.

\bibitem{church}
Church, Alonzo, 
An unsolvable problem of elementary number theory,
{\em Amer. J. Math.} {\bf 58} 345--363, 1936.

% \bibitem{clausen}
% Clausen, M., 
% Fast Generalized Fourier transforms, 
% {\em Theoret. Comput. Sci.} {\bf 56} 55--63 1989.

% \bibitem{cover}
% Cover, T. M., and Thomas J. A., 
% {\em Elements of Information Theory,}
% John Wiley and Sons, New York, 1991.

\bibitem{delillo}
DeLillo, Don,
{\em White Noise},
Viking/Penguin, New York, 1984.

\bibitem{durbin}
Durbin, R., Eddy, S., Krogh, A., Mitchison, G.
{\em Biological Sequence Analysis: Probabilistic Models of Proteins and Nucleic Acids}
Cambridge University Press, Cambridge, 1999.

\bibitem{eilenberg}
Eilenberg, S., and Elgot, C. C.,
{\em Recursiveness},
Academic Press, New York, 1970.

\bibitem{feller}
Feller, W.,
{\em An Introduction to Probability Theory and Its Applications},
Wiley, New York, 1957.
 
\bibitem{feynman-96}
Feynman, Richard,
{\em Feynman lectures on computation},
Addison-Wesley, Reading, 1996.

\bibitem{garey}
Garey M R and Johnson D S,
{\em Computers and Intractability}, 
Freeman and Company, New York, 1979.

% \bibitem{gatlin}
% Gatlin, L. L.,
% {\em Information Theory and the Living System},
% Columbia University Press, New York, 1972.

\bibitem{godel}
G\"odel, K.,
\"Uber formal unentscheidbare S\"atze der Principia Mathematica und
verwandter Systeme, I,
{\em Monatshefte f\"ur Math. und Physik},
38, 173-198, 1931.

% \bibitem{golay}
% Golay, M. J. E.,
% Notes on digital coding,
% {\em Proc. IEEE} {\bf 37} 657, 1949.
% 


% \bibitem{haken}
% Haken, Hermann,
% {\em Information and Self-Organization, a Macroscopic Approach to Complex Systems},
% Springer-Verlag, Berlin/New York, 1988.
% 
% \bibitem{hamming1}
% Hamming, R. W.,
% Error detecting and error correcting codes,
% {\em Bell Syst. Tech. J.} {\bf 29} 147, 1950.
% 
% \bibitem{hamming2}
% Hamming, R. W.,
% {\em Coding and information theory}, 2nd ed,
% Prentice-Hall, Englewood Cliffs, 1986.

% \bibitem{hardy}
% Hardy, G. H. and Wright, E. M.,
% {\em An introduction to the theory of numbers}
% Clarendon Press, Oxford, 1979.

% \bibitem{hill}
% Hill, R.,
% {\em A first course in coding theory}
% Clarendon Press, Oxford, 1986.

\bibitem{hodges}
Hodges, A.,
{\em Alan Turing: the enigma},
Vintage, London, 1983.

\bibitem{hofstadter}
Hofstadter, Douglas R.,
{\em Metamagical Themas:  Questing for the Essence of Mind and Pattern},
Basic Books, New York, 1985.

\bibitem{hopcroft}
Hopcroft, John E. and Ullman, Jeffrey D.,
{\em Introduction to Automata Theory, Languages, and Computation},
Addison-Wesley, Reading, Massachusetts, 1979.


% \bibitem{hopcroft2}
% Hopcroft, John E., Motwani, Rajeev, and Ullman, Jeffrey D.,
% {\em Introduction to Automata Theory, Languages, and Computation}, 2nd ed.,
% Addison-Wesley, Boston, Massachusetts, 2001.

% \bibitem{jones}
% Jones, D. S.,
% {\em Elementary information theory}
% Clarendon Press, Oxford, 1979.

\bibitem{knuthd} 
Knuth, D. E.,
{\em The Art of Computer Programming, Vol. 2: Seminumerical Algorithms},
2nd ed, Addison-Wesley, Reading, 1981.

% \bibitem{knuthe}
% Knuth, Eldon L.,
% {\em Introduction to Statistical Thermodynamics},
% McGraw-Hill, New York, 1966.
% 
% \bibitem{landauer3}
% Landauer, R.,
% Information is physical,
% {\em Phys. Today}, May 1991 23-29.
% 
% \bibitem{landauer4} 
% Landauer, R.,
% The physical nature of information,
% {\em Phys. Lett. A}, {\bf 217} 188, 1996.
% 
% \bibitem{lint}
% van Lint, J. H.,
% {\em Coding Theory},
% Springer-Verlag, New York/Berlin, 1982.

\bibitem{linz}
Linz, Peter, 
{\em An Introduction to Formal Languages and Automata}, 3rd Ed., 
Jones and Bartlett, Boston, 2000.

\bibitem{lipton}
Lipton, R. J., 
Using DNA to solve NP-complete problems, 
{\em Science}, {\bf 268} 542--545, Apr. 28, 1995.

% \bibitem{macwilliams}
% MacWilliams, F. J., and Sloane, N. J. A.,
% {\em The theory of error correcting codes},
% Elsevier Science, Amsterdam, 1977.
% 
% \bibitem{martin}
% Martin, N. F. G., and England, J. W.,
% {\em Mathematical Theory of Entropy},
% Addison-Wesley, Reading, 1981.
% 
% \bibitem{maxwell}
% Maxwell, J. C.,
% {\em Theory of heat}
% Longmans, Green and Co, London, 1871.

\bibitem{minsky}
Minsky, M. L.,
{\em Computation: Finite and Infinite Machines}
Prentice-Hall, Inc., Englewood Cliffs, N. J. (also London 1972), 1967.

\bibitem{moret}
Moret, Bernard M.,
{\em The Theory of Computation}
Addison-Wesley, Reading, Massachusetts, 1998.

\bibitem{neumann}
von Neumann, John,
Probabilistic logic and the synthesis of reliable organisms
		  from unreliable components,
in {\em automata studies( Shannon, McCarthy eds)}, 1956 .

\bibitem{papa}
Papadimitriou, C. H., 
{\em Computational Complexity}, 
Addison-Wesley, Reading, 1994.

% \bibitem{pierce}
% Pierce, John R.,
% {\em An Introduction to Information Theory -- Symbols, Signals and Noise},
% (second revised edition),
% Dover Publications, New York, 1980.

\bibitem{rabin79} 
Rabin, M. O., 
Probabilistic Algorithms,
{\em  Algorithms and Complexity: New Directions 
and Recent Results}, pp. 21-39,
   Academic Press, 1976.

% \bibitem{roman}
% Roman, Steven, 
% {\em Introduction to Coding and Information Theory},
% Springer-Verlag, Berlin/New York, 1997.
% 
% \bibitem{sampson}
% Sampson, Jeffrey R.,
% {\em Adaptive Information Processing, an Introductory Survey},
% Springer-Verlag, Berlin/New York, 1976.

\bibitem{schroeder1}
Schroeder, Manfred,
{\em Fractals, Chaos, Power Laws, Minutes from an Infinite Paradise},
W. H. Freeman, New York, 1991.

\bibitem{schroeder2}
Schroeder, M. R., 1984
{\em Number theory in science and communication}
Springer-Verlag, New York/Berlin/Heidelberg, 1984.

% \bibitem{shannon}
% Shannon, C. E.,
% A mathematical theory of communication
% {\em Bell Syst. Tech. J.} {\bf 27} 379; also p. 623, 1948.
% 
% \bibitem{slepian}
% Slepian, D., ed.,
% {\em Key papers in the development of information theory}
% IEEE Press, New York, 1974.

% \bibitem{szilard}
% Szilard L 1929 Z. Phys. {\bf 53} 840;
% translated in Wheeler and Zurek (1983).

\bibitem{turing}
Turing, A. M.,
On computable numbers, with an application to the
Entscheidungsproblem,
{\em Proc. Lond. Math. Soc. Ser. 2} {\bf 42}, 230 ; see also
{\em Proc. Lond. Math. Soc. Ser. 2} {\bf 43}, 544, 1936.

\bibitem{vergis} 
Vergis, A., Steiglitz, K., and Dickinson, B.,
The Complexity of Analog Computation,
{\em Math. Comput. Simulation 28}, pp. 91-113. 1986.

\bibitem{zurek2}
Zurek, W. H.,
Thermodynamic cost of computation, algorithmic complexity and the
information metric,
{\em Nature} {\bf 341} 119-124, 1989.

\end{thebibliography}

\tthdump{\hyperlink{Our general topics:}{\hfil To top $\leftarrow$}}
%%tth:{\special{html: <a href="\#Top of file">       Back to top of file</a>}}

% 
% \sectionhead{On-line references}
% 
% 
% Some of the references listed above are available on line.  They are listed again here for easy access:
% 
% %\bibitem{abrams2}
% Abrams D S and Lloyd S, 
% Non-Linear Quantum Mechanics implies Polynomial Time 
% solution for NP-complete and $\#$P problems,
% %in {\it LANL e-print} quant-ph/9801041, http://xxx.lanl.gov (1998)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9801041}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9801041}
% {http://xxx.lanl.gov/abs/quant-ph/9801041}
% 
% 
% %\bibitem{aharonov5}
% Aharonov D, Beckman D, Chuang I and  Nielsen M,
% What Makes Quantum Computers Powerful? 
% \hyperref{http://wwwcas.phys.unm.edu/\~mnielsen/science.html}{}{}
% %\hyperURL{http}{wwwcas.phys.unm.edu/~mnielsen}{science.html}
% {http://wwwcas.phys.unm.edu/\~mnielsen/science.html}
% % 
% % 
% 
% %\bibitem{decoherence2}
%  Chuang I L, Laflamme R and Paz J P, 
% Effects of Loss and Decoherence on a Simple Quantum Computer,
% %in {\it LANL e-print} quant-ph/9602018,  http://xxx.lanl.gov (1996)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9602018}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9602018}
% {http://xxx.lanl.gov/abs/quant-ph/9602018}
% 
% %\bibitem{grover2}
%  Grover L K, 
% A framework for fast quantum mechanical algorithms,
% %in {\it LANL e-print} quant-ph/9711043,  http://xxx.lanl.gov (1997)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9711043}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9711043}
% {http://xxx.lanl.gov/abs/quant-ph/9711043}
% 
% %\bibitem{grover4}
%  Grover L K, 
% A fast quantum mechanical algorithm for estimating the median,
% %in {\it LANL e-print} quant-ph/9607024,  http://xxx.lanl.gov (1997)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9607024}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9607024}
% {http://xxx.lanl.gov/abs/quant-ph/9607024}
% 
% 
% %\bibitem{knill4}
% Knill E, Laflamme R and Zurek W H 1997
% Resilient quantum computation: error models and thresholds
% %in {\it LANL e-print} quant-ph/9702058,  http://xxx.lanl.gov (1997)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9702058}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9702058}
% {http://xxx.lanl.gov/abs/quant-ph/9702058}
% 
% \pagedone
% 
% 
% %\bibitem{preskill2}
% Preskill J 1997
% Fault tolerant quantum computation,
% %in {\it LANL e-print} quant-ph/9712048,  http://xxx.lanl.gov (1997), 
% to appear in {\it Introduction to Quantum
% Computation},  edited by H.-K. Lo, S. Popescu, and T. P. Spiller
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9712048}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9712048}
% {http://xxx.lanl.gov/abs/quant-ph/9712048}
% 
% %\bibitem{preskill3}
% Preskill J, Kitaev A, Course notes for Physics 229, Fall 1998, Caltech Univ.,
% \hyperref{http://www.theory.caltech.edu/people/preskill/ph229}{}{}
% %\hyperURL{http}{www.theory.caltech.edu/people/preskill}{ph229}
% {http://www.theory.caltech.edu/people/preskill/ph229}
% 
% 
% %\bibitem{rieffel}
% Rieffel E, Polak W
% An Introduction to Quantum Computing for Non-Physicists
% %{\it LANL e-print} quant-ph/9809016,  http://xxx.lanl.gov (1998),
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9809016}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9809016}
% {http://xxx.lanl.gov/abs/quant-ph/9809016}
% 
% %\bibitem{Steane-97}
% Steane A,
% Quantum Computation, Reports on Progress in Physics 61 (1998) 117,
% %(preprint in {\it LANL e-print} quant-ph/9708022, http://xxx.lanl.gov)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9708022}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9708022}
% {http://xxx.lanl.gov/abs/quant-ph/9708022}
% 
% %\bibitem{zalka2}
% Zalka C, 
% Grover's quantum searching algorithm is optimal,
% %in {\it LANL e-print} quant-ph/9711070http://xxx.lanl.gov (1997)
% \hyperref{http://xxx.lanl.gov/abs/quant-ph/9711070}{}{}
% %\hyperURL{http}{xxx.lanl.gov/abs/quant-ph}{9711070}
% {http://xxx.lanl.gov/abs/quant-ph/9711070}
% 

\end{document}
