\documentclass[11pt]{article}

\usepackage{amsmath,amssymb,complexity}

\textwidth=6in
\oddsidemargin=0.25in
\evensidemargin=0.25in
\topmargin=-0.1in
\footskip=0.8in
\parindent=0.0cm
\parskip=0.3cm
\textheight=8.00in
\setcounter{tocdepth} {3}
\setcounter{secnumdepth} {2}
\sloppy


\newtheorem{example}{Example}
\newtheorem{open-problem}{Open Problem}

\newcommand{\ATIME}{\ComplexityFont{ATIME}}
\newcommand{\ASPACE}{\ComplexityFont{ASPACE}}

\begin{document}
\input{preamble.tex}
\lecture{7}{Mar 18, 2009}{Jayalal Sarma M.N.}{Hao Song}

\section{Non-deterministic Oracle Turing Machines}
In the previous lectures, we have introduced the concept of deterministic oracle Turing 
machines.
The concept of non-deterministic oracle Turing machines is just a direct extension of that
to the non-deterministic case.

To be precise, a non-deterministic oracle Turing machine (sometimes abbreviated to ``oracle
NTM'') is just like a deterministic oracle TM, but with a non-deterministic transition function
(\emph{with some restrictions which we will discuss below}). It has
\begin{itemize}
  \item a finite state set, which contains two special states called the \emph{query state}
and the \emph{answer state}, aside from those states of an ordinary NTM
  \item a finite alphabet, which contains two special symbols $0$ and $1$, among other things
  \item one input tape, which is read-only
  \item one output tape, which is write-only
  \item a finite number of working tapes
  \item a \emph{query tape}, which is considered to be a special working tape, and is
included in the computation of the machine's space consumption
  \item an oracle which computes a language \lang{L}
  \item a non-deterministic transition function
\end{itemize}

The machine is allowed to query the oracle many times, and use the answers from the oracle
to facilitate its own computation. Each of those queries works as follows
\begin{enumerate}
  \item the machine writes a query string $s$ onto the \emph{query tape}, and enters the 
\emph{query state}. 
  \item the oracle decides if $s$ is in the language \lang{L}, and if so, it replaces everything
on the \emph{query tape} with the symbol $1$; otherwise, it replaces everything on the
\emph{query tape} with the symbol $0$. After that, the oracle puts the machine into the
\emph{answer state}. This counts as one single step for the machine.
\end{enumerate}

Please take note! To ensure that the only thing the NTM can do upon entering the 
\emph{query state} is to query the oracle, we allow the transition function to be
non-deterministic if and only if the current state is not the \emph{query state}.

Just like any other computational model, we can define complexity classes based on oracle NTMs.

\begin{definition}
For any complexity class \ComplexityFont{A} defined on NTMs and any complexity class 
\ComplexityFont{B}, we define the complexity class $\ComplexityFont{A}^{\ComplexityFont{B}}$ to
be the set of all languages \lang{L} that satisfy the following conditions 
\begin{enumerate}
  \item there is an oracle NTM \textbf{M} that runs within the resouce constraints specified by 
\ComplexityFont{A}
  \item there is an oracle \textbf{O} that's capable of computing a language \lang{L'}
in \ComplexityFont{B}.
  \item \textbf{M} with access to \textbf{O} computes \lang{L}
\end{enumerate}
\end{definition}

\section{The Polynomial-Time Hierarchy}
Before introducing the main concept of this lecture, the polynomial-time hierarchy, we first 
need to present a lemma, which lays the groundwork for understanding the hierarchy.
\begin{lemma}
we have the following relationships between oracle NTM complexity classes and ordinary DTM and
NTM complexity classes
\begin{enumerate}
  \item $\NP^{\P}\subseteq\NP$ \label{lemitem:PH-property-prep:NP}
  \item $\NP^{\PSPACE}\subseteq\PSPACE$ \label{lemitem:PH-property-prep:PSPACE}
\end{enumerate}
\label{lem:PH-property-prep}
\end{lemma}
\begin{proof}
\begin{enumerate}
  \item this is trivial
  \item in previous lectures we have proved that for any (fully space-constructible) function
$f(n)\geq n$, we have
    $$\NTIME(f(n))\subseteq\DSPACE(f(n))$$
    which implies that
    $$\NP\subseteq\PSPACE$$
    by \emph{relativization}, we have
    $$\NP^{\PSPACE}\subseteq\PSPACE^{\PSPACE}$$
    which, combined with
    $$\PSPACE^{\PSPACE}\subseteq\PSPACE$$
    gives us the result we want.
\end{enumerate}
\end{proof}

\subsection{Defining the Polynomial-Time Hierarchy with Oracle TMs}
The polynomial-time hierarchy (or ``PH'' for short) is the polynomial analog of the arithmetic 
hierarchy in recursion theory. It consists of a series of complexity classes, and can be 
defined inductively by oracle TMs

\begin{definition}
For non-negative integers $n$, we define complexity classes $\Sigma_{n}^{\P}$ and $\Pi_{n}^{\P}$
as follows
\begin{itemize}
  \item $\Sigma_{0}^{\P}=\Pi_{0}^{\P}=\P$
  \item $\Sigma_{n+1}^{\P}=\NP^{\Sigma_{n}^{\P}}$ for all $n\geq 0$
  \item $\Pi_{n+1}^{\P}=\co-\Sigma_{n+1}^{\P}$ for all $n\geq 0$
\end{itemize}
In addition, we define
$$\PH=\bigcup_{k\geq 0}{\Sigma_{k}^{\P}}$$
\end{definition}

In the following proposition, we summarize some of the basic properties of PH
\begin{proposition}[Basic Properties of the Polynomial Time Hierarchy]
we have
\begin{enumerate}
  \item $\Sigma_{1}^{\P}=\NP$, $\Pi_{1}^{\P}=\coNP$
  \item $\Sigma_{i}^{\P}=\NP^{\Sigma_{i-1}^{\P}}=\NP^{\Pi_{i-1}^{\P}}$ for any integer $i>0$
  \item $\Pi_{i}^{\P}=\co-\NP^{\Sigma_{i-1}^{\P}}=\co-\NP^{\Pi_{i-1}^{\P}}$ for any integer $i>0$
  \item for any integer $i>0$, $\Sigma_{i-1}^{\P}\cup\Pi_{i-1}^{\P}\subseteq\Sigma_{i}^{\P}\cap\Pi_{i}^{\P}$
  \item for any integer $i\geq 0$, $\Sigma_{i}^{\P}\subseteq\PSPACE$ \label{propitem:PH-properties:Sigma-PSPACE-upperbound}
  \item for any integer $i\geq 0$, $\Pi_{i}^{\P}\subseteq\PSPACE$
  \item $\PH\subseteq\PSPACE$ \label{propitem:PH-properties:PSPACE-upperbound}
\end{enumerate}
\label{prop:PH-properties}
\end{proposition}
\begin{proof}
\begin{enumerate}
  \item from the clause~\ref{lemitem:PH-property-prep:NP} of lemma~\ref{lem:PH-property-prep},
we know that
$$\NP^{\P}\subseteq\NP$$
and it's trivial to show that $\NP\subseteq\NP^{\P}$, thus
$$\Sigma_{1}^{\P}=\NP^{\P}=\NP$$
and
$$\Pi_{1}^{\P}=\co-\Sigma_{1}^{\P}=\coNP$$
  \item from the definitions of oracle NTMs, it's obvious that for any complexity class 
\ComplexityFont{C}, we have
$$\NP^{\ComplexityFont{C}}=\NP^{\co\ComplexityFont{C}}$$
Specifically, for any positive integer $i$
$$\Sigma_{i}^{\P}=\NP^{\Sigma_{i-1}^{\P}}=\NP^{\co-\Sigma_{i-1}^{\P}}=\NP^{\Pi_{i-1}^{\P}}$$
  \item from the definition of PH and the previous clause, for any positive integer $i$
$$\Pi_{i}^{\P}=\co-\Sigma_{i}^{\P}=\co-\NP^{\Sigma_{i-1}^{\P}}=\co-\NP^{\Pi_{i-1}^{\P}}$$
  \item this is an immediate corollary of the previous two clauses
  \item this can be proved using an induction on $i$
    \begin{description}
      \item [the base step] for $i=0$, this is just the fact that $\Sigma_{0}^{\P}=\P\subseteq\PSPACE$
      \item [the induction step] suppose the statement is true for $i=k$, for $i=k+1$, we have, from
clause~\ref{lemitem:PH-property-prep:PSPACE} of lemma~\ref{lem:PH-property-prep}
$$\Sigma_{k+1}^{\P}=\NP^{\Sigma_{k}^{\P}}\subseteq\NP^{\PSPACE}\subseteq\PSPACE$$
    \end{description}
    Thus the statement is proved for all non-negative integers $i$
  \item this follows from the previous clause and the fact that $\PSPACE=\co\PSPACE$.
  \item this follows from clause~\ref{propitem:PH-properties:Sigma-PSPACE-upperbound} and the 
definition of \PH
\end{enumerate}
\end{proof}

\subsection{Open Problems Related to the Polynomial-Time Hierarchy}
There are several open problems concerning the basic structure of PH, with the notorious
``\P~versus \NP'' being the most commonly known. Besides that, we just want to list two
of them below, both weaker than ``\P~versus \NP''.

\begin{open-problem}
Is there some non-negative integer $k$ such that $\PH=\Sigma_{k}^{\P}$?
\end{open-problem}
This phenomenon is commonly referred to as the ``collapse'' of the polynomial-time hierarchy.

\begin{open-problem}
Is $\P^{\NP}\subseteq\NP$?
\end{open-problem}
You need to convince yourself that the containment is noway obvious from the definition.
Actually we can define a (non-trivial) new member of the polynomial-time hierarchy because
of this uncertainty
\begin{definition}
For non-negative integers $n$, we define complexity classes $\Delta_{n}^{\P}$ as follows
\begin{itemize}
  \item $\Delta_{0}^{\P}=\P$
  \item $\Delta_{n+1}^{\P}=\P^{\Sigma_{n}^{\P}}$ for any integer $n\geq 0$
\end{itemize}
\end{definition}

\subsection{The Alternative Definition of PH Based on Alternating Quantifiers}
In this subsection, we want to develop an alternative formulation of the polynomial time hierarchy.
In order to establish the equivalence between this formulation and the definition we have just
described above, we need some theorems.

\begin{theorem}
For any positive integer $k$, a language \lang{A} is in the complexity class $\Sigma_{k}^{\P}$ if and
only if there is a language \lang{B} in $\Pi_{k-1}^{\P}$ and a polynomial $p(\cdot)$ such that
$$x\in\lang{A}\quad\Leftrightarrow\quad\exists y, |y|\leq p(|x|)\mbox{ and }(x, y)\in \lang{B}$$
\label{thm:PH-one-level-quantifier}
\end{theorem}

In order to prove this theorem, we'll need the following two lemmas, which we will list here without
proofs. For the proofs, please read page 79 and 80 of Du and Ko's book \cite{duandkobook}

\begin{lemma}
Let $k\geq 0$
\begin{enumerate}
  \item If $\lang{A}, \lang{B}\in\Sigma_{k}^{\P}$, then $\lang{A}\cup\lang{B}, \lang{A}\cap\lang{B}\in\Sigma_{k}^{\P}$,
and $\bar{\lang{A}}\in\Pi_{k}^{\P}$. \label{lemitem:union-of-PH-languages:Sigma}
  \item If $\lang{A}, \lang{B}\in\Pi_{k}^{\P}$, then $\lang{A}\cup\lang{B}, \lang{A}\cap\lang{B}\in\Pi_{k}^{\P}$, and
$\bar{\lang{A}}\in\Sigma_{k}^{\P}$. \label{lemitem:union-of-PH-languages:Pi}
  \item If $\lang{A}, \lang{B}\in\Delta_{k}^{\P}$, then $\lang{A}\cup\lang{B}, \lang{A}\cap\lang{B}, \bar{\lang{A}}\in\Delta_{k}^{\P}$. \label{lemitem:union-of-PH-languages:Delta}
\end{enumerate}
\label{lem:union-of-PH-languages}
\end{lemma}

\begin{lemma}
For any set \lang{A} and any $m>0$, define $A_{m}=\{\langle x_{1}, x_{2}, \ldots, x_{m}\rangle :(\exists i, 1\leq i \leq m) x_{i}\in\lang{A}\}$ and $A'_{m}=\{\langle x_{1}, x_{2}, \ldots, x_{m}\rangle :(\forall i,1\leq i \leq m) x_{i}\in A\}$. for any $k, m>0$
\begin{enumerate}
  \item $A\in\Sigma_{k}^{\P} \quad \Rightarrow \quad A_{m}, A'_{m}\in\Sigma_{k}^{\P}$ 
    \label{lemitem:self-product-of-PH-languages:Sigma}
  \item $A\in\Pi_{k}^{\P} \quad \Rightarrow \quad A_{m}, A'_{m}\in\Pi_{k}^{\P}$
    \label{lemitem:self-product-of-PH-languages:Pi}
\label{lem:self-product-of-PH-languages}
\end{enumerate}
\end{lemma}

\begin{proof}[Proof of Theorem~\ref{thm:PH-one-level-quantifier}]
\begin{itemize}
  \item \textbf{the ``backward'' direction}

    Suppose for the language \lang{A} we can find a language \lang{B} and a polynomial $p(n)$
that satisfy the specified condition, then we can construct an oracle NTM that computes \lang{A} as
follows: for an input $x$, first use the NTM to ``guess'' a witness string up to length $p(|x|)$, call
this string $y$, then use an oracle that computes \lang{B} to test whether $(x, y)\in\lang{B}$ is true, 
accepts $x$ if and only if the oracle answers ``yes''.

This is clearly an oracle NTM running in polynomial time and computes \lang{A}. Thus we have
$$\lang{A}\in\NP^{\Pi_{k-1}^{\P}}=\Sigma_{k}^{\P}$$
  
  \item \textbf{the ``forward'' direction}
    
    This proof is a little convoluted, but the main theme is clear, suppose the language \lang{A} is
in $\Sigma_{k}^{\P}$, then there should be an oracle NTM that's able to compute it. A string $x$ is in
\lang{A} if and only if there is an accepting path of this oracle NTM on the input $x$. Our job is to
find an encoding scheme of possible accepting paths that meets the following criteria
\begin{description}
  \item [complete] The encoding scheme should be able to correctly encode every possible accepting
path of the oracle NTM on every possible input string.
  \item [concise] Given the fact that the oracle NTM is polynomial-time bounded,
the length of the encoding of an accepting path is also polynomially bounded
  \item [easy to verify] Given an input string $x$ and the encoding string of an accepting path
$y$, we can verify that $y$ is indeed a valid encoding of an accepting path of the oracle NTM on input
string $x$, with the help of an oracle in $\Pi_{k-1}^{\P}$.
\end{description}

  Now the actual proof, it's a proof by induction
\begin{description}
  \item [the base step] when $k=1$, it's just the definition of \NP~using \P~and witnesses. We have proved
the validity of that before.
  \item [the induction step] suppose the statement is proved to be true for everything less than a particular $k$,
now we want prove it for $k$.

  In this case, by definition, we have access to an oracle $\lang{D}\in\Sigma_{k-1}^{\P}$

  Our first attempt to encode an accepting path is, not surprisingly, to capture the configuration
sequence along the way. We denote the configuration sequence as $\alpha=\langle \alpha_{1}, \alpha_{2}, \ldots,
\alpha_{m}\rangle $, where $m\leq q(|x|)$, where $x$ is the input string, and $q(\cdot)$ is the polynomial bounding
the running time of the oracle NTM. $\alpha$ must satisfy the following conditions
\begin{enumerate}
  \item $\alpha_{1}$ is the initial configuration
    \label{item:initial-configuration-condition}
  \item $\alpha_{m}$ is an accepting configuration
    \label{item:final-configuration-condition}
  \item for any $1\leq i <m$, $\alpha_{i}\mapsto\alpha_{i+1}$ is a valid transition of the oracle NTM
    \label{item:transition-validity-condition}
  \item for any $1\leq i <m$, if $\alpha_{i}$ is in the query state
    \begin{itemize}
      \item if the query string in $\alpha_{i}$ is in \lang{D}, then the content on the query tape in 
$\alpha_{i+1}$ denotes a ``yes'' answer
      \item if the query string in $\alpha_{i}$ is not in \lang{D}, then the content on the query tape
in $\alpha_{i+1}$ denotes a ``no'' answer
    \end{itemize}
    \label{item:query-result-condition}
\end{enumerate}

This is indeed a complete and concise encoding. And the first three conditions above can be verified in
polynomial time. But unfortunately, there is no clear evidence that the last condition can be verified
easily with a $\Pi_{k-1}^{\P}$ oracle. 
To address this issue, we need to evolve our encoding scheme a little bit, and transform the condition
accordingly.
We can collect all the query strings the machine has used along the way
into two tuples, namely $u=\langle u_{1}, u_{2}, \ldots, u_{l}\rangle $ and $v=\langle v_{1}, v_{2}, \ldots, v_{n}\rangle $. Then we
can replace condition~\ref{item:query-result-condition} with the following conditions:
\begin{enumerate}
  \setcounter{enumi}{4}
  \item for any $\alpha_{i}$ in the query state, the query string in $\alpha_{i}$ is either in $u$ or in
$v$ and
    \begin{itemize}
      \item if it's in $u$, then the content of the query tape in $\alpha_{i}$ denotes a ``yes'' answer
      \item if it's in $v$, then the content of the query tape in $\alpha_{i}$ denotes a ``no'' answer 
    \end{itemize}
    \label{item:query-list-complete-condition}
  \item for any $1\leq i \leq l$, $u_{i}\in\lang{D}$ \label{item:positive-results-condition}
  \item for any $1\leq i \leq n$, $v_{i}\notin\lang{D}$ \label{item:negative-results-condition}
\end{enumerate}
note that we can certainly make $l, n\leq m \leq q(|x|)$. And the length of each query string in
$u$ and $v$ can be polynomially bounded. Condition~\ref{item:query-list-complete-condition} can be
verified in polynomial time. And according to clause~\ref{lemitem:self-product-of-PH-languages:Pi} of lemma
~\ref{lem:self-product-of-PH-languages}, we can construct a language \lang{B_{2}} in $\Pi_{k-1}^{\P}$ as
follows
$$\lang{B_{2}}=\{v:v\mbox{ satisfies condition~\ref{item:negative-results-condition}}\}$$
We know that for condition~\ref{item:positive-results-condition} to hold, every string in $u$ must be
in \lang{D}, which is a $\Sigma_{k-1}^{\P}$ class language. By our induction hypothesis, we have a language
$\lang{B'_{3}}\in\Pi_{k-2}^{\P}$ and a polynomial $r(\cdot)$ such that
$$u_{i}\in\lang{D} \quad \Leftrightarrow \quad \exists w_{i}, |w_{i}|\leq r(|u_{i}|), \langle u_{i}, w_{i}\rangle \in\lang{B'_{3}}$$
We can collect all the $w_{i}$ into one single tuple $w=\langle w_{1}, w_{2}, \ldots, w_{l}\rangle $. Again using clause
~\ref{lemitem:self-product-of-PH-languages:Pi} of lemma~\ref{lem:self-product-of-PH-languages}, we know the
language defined by
$$\lang{B_{3}}=\{\langle u, w\rangle :(\forall i, 1\leq i \leq l)\langle u_{i}, w_{i}\rangle \in\lang{B'_{3}}\}$$
is a language in $\Pi_{k-2}^{\P}\subseteq\Pi_{k-1}^{\P}$.

We can collect all the conditions mentioned above that can be verified in polynomial time into one language
$$\lang{B_{1}}=\{\langle x, \alpha, u, v\rangle :\mbox{conditions~\ref{item:initial-configuration-condition},
~\ref{item:final-configuration-condition},~\ref{item:transition-validity-condition},
~\ref{item:query-list-complete-condition} hold}\}$$
then clearly $\lang{B_{1}}\in\P\subseteq\Pi_{k-1}^{\P}$.

Finally we can define the $\Pi_{k-1}^{\P}$ language \lang{B} contained in the statement we want to prove in
the first place
$$\lang{B}=\{\langle x, y\rangle :y=\langle \alpha, u, v, w\rangle , \langle x, \alpha, u, v\rangle \in\lang{B_{1}}, v\in\lang{B_{2}}, \langle u, w\rangle \in\lang{B_{3}}\}$$
according to clause~\ref{lemitem:union-of-PH-languages:Pi} of lemma~\ref{lem:union-of-PH-languages}, 
$\lang{B}\in\Pi_{k-1}^{\P}$. And the length of the witness $|y|$ can be polynomially bounded by $|\alpha|$,
$|u|$, $|v|$ and $|w|$, which, in turn, can all be polynomially bounded by $|x|$.

This concludes our induction step.
\end{description}
And that concludes our prove for the ``forward'' direction
\end{itemize}
Thus the equivalence.
\end{proof}

\begin{corollary}
For any positive integer $k$, a language \lang{A} is in the complexity class $\Pi_{k}^{\P}$ if and
only if there is a language \lang{B} in $\Sigma_{k-1}^{\P}$ and a polynomial $p(n)$ such that
$$x\in\lang{A} \quad \Leftrightarrow \quad\forall y, |y|\leq p(n)\mbox{ and }(x, y)\in \lang{B}$$
\end{corollary}

\begin{corollary}[Alternation of Quantifiers]
For any positive integer $k$
\begin{itemize}
\item a language \lang{A} is in $\Sigma_{k}^{\P}$ if and only if there exists
a language $\lang{B}\in\P$ and a polynomial $p$ such that for any string $x$
\begin{eqnarray*}
x\in\lang{A} \quad \Leftrightarrow & & (\exists y_{1},|y_{1}|\leq p(|x|))(\forall y_{2}, |y_{2}|\leq p(|x|)) \\
& & \ldots (Q_{k}y_{k}, |y_{k}|\leq p(|x|))\langle x, y_{1}, y_{2}, \ldots, y_{k}\rangle \in\lang{B}
\end{eqnarray*}
where $Q_{k}$ is the quantifier $\exists$ if $k$ is odd, and it is $\forall$ if $k$ is even.
\item a language \lang{A} is in $\Pi_{k}^{\P}$ if and only if there exists
a language $\lang{B}\in\P$ and a polynomial $p$ such that for any string $x$
\begin{eqnarray*}
x\in\lang{A} \quad \Leftrightarrow & & (\forall y_{1},|y_{1}|\leq p(|x|))(\exists y_{2}, |y_{2}|\leq p(|x|)) \\
& & \ldots (Q_{k}y_{k}, |y_{k}|\leq p(|x|))\langle x, y_{1}, y_{2}, \ldots, y_{k}\rangle \in\lang{B}
\end{eqnarray*}
where $Q_{k}$ is the quantifier $\forall$ if $k$ is odd, and it is $\exists$ if $k$ is even.
\end{itemize}
\end{corollary}

Thus we can redefine the complexity classes $\Sigma_{k}^{\P}$ and $\Pi_{k}^{\P}$ of the polynomial time hierarchy
directly from the familiar class \P, without the need to introduce oracle NTMs. And as we have just proved, this
definition is equivalent to our original definition based on oracle NTMs.

\section{Alternating Turing Machines}
In light of the alternating quantifier formulation of PH, we can define a new computational model called the
\emph{alternating Turing machines} (or NTM for short). They can be seen as a combination of non-deterministic 
Turing machines and \co-non-deterministic Turing machines.

The defining feature of an \emph{alternating Turing machine} is that its states are divided into two groups, called
$\forall$-states and $\exists$-states.
Like a non-deterministic TM, the computation of an \emph{alternating Turing machine} on an input string can be
conceptualized as a configuration tree. Each node in the tree corresponds to a possible configuration the machine
may enter during the computation on the given input string. A configuration can be classified as a
$\forall$-configuration or a $\exists$-configuration, according to the state it's in. 
A $\forall$-configuration accepts if and only if all children 
configurations accept; an $\exists$-configuration accepts if and only if  any children configuration accepts. 

We can define complexity classes based on \emph{alternating Turing machines}. Like DTMs and NTMs, we use terms
like $\ATIME$ and $\ASPACE$ to describe these complexity classes.

We have the following relationships between complexity classes defined on ATMs and complexity classes defined on
DTMs and NTMs
\begin{theorem}
For any (fully time constructible) function $t$, with $t(n)\geq n$, $\ATIME(t(n))\subseteq \DSPACE((t(n))^{2})$.
\end{theorem}
This is theorem 3.17 on page 91 of Du and Ko's book \cite{duandkobook}. You can read that for the proof.

\begin{theorem}
For any (fully space constructible) function $s$, with $s(n)\geq n$, $\NSPACE(s(n))\subseteq \ATIME((s(n))^{2})$.
\end{theorem}
This is theorem 3.18 on page 92 of Du and Ko's book \cite{duandkobook}. You can read that for the proof.

A unique resource measure for ATMs is the number of alternations (from $\forall$-configurations to 
$\exists$-configurations or vice versa) on any computational path. If this number is bounded by a constant
$k$, then we will get complexity classes $\Sigma_{k}^{\P}$ and $\Pi_{k}^{\P}$.

For more connections between the ATMs and the polynomial time hierarchy, we have the following relationships

\begin{theorem}
$\cup_{k>0}\ATIME(n^{k})=\PSPACE$
\end{theorem}
Again the scriber refers to Du and Ko's book \cite{duandkobook} (corollary 3.19 on page 93) for the proof.

\begin{theorem}
$\cup_{c>0}\ASPACE(c\log{n})=\P$
\end{theorem}
Please see corollary 3.22 clause (a) on page 95 of Du and Ko's book \cite{duandkobook} for the proof.

\bibliographystyle{plain}
\bibliography{complexity}
\end{document}
