Abstract
Hidden Markov Models (HMMs) are one of the
most fundamental and widely used statistical tools
for modeling discrete time series. In general, learning HMMs from data is computationally hard (under cryptographic assumptions), and practitioners
typically resort to search heuristics which suffer
from the usual local optima issues. We prove that
under a natural separation condition (bounds on
the smallest singular value of the HMM parameters), there is an efficient and provably correct
algorithm for learning HMMs. The sample complexity of the algorithm does not explicitly depend
on the number of distinct (discrete) observations—
it implicitly depends on this quantity through spectral properties of the underlying HMM. This makes
the algorithm particularly applicable to settings with
a large number of observations, such as those in
natural language processing where the space of observation is sometimes the words in a language.
The algorithm is also simple: it employs only a
singular value decomposition and matrix multiplications.

1

Introduction

Hidden Markov Models (HMMs) [BE67] are the workhorse
statistical model for discrete time series, with widely diverse
applications including automatic speech recognition, natural
language processing (NLP), and genomic sequence modeling. In this model, a discrete hidden state evolves according
to some Markovian dynamics, and observations at particular
time depend only on the hidden state at that time. The learning problem is to estimate the model only with observation
samples from the underlying distribution. Thus far, the predominant learning algorithms have been local search heuristics, such as the Baum-Welch / EM algorithm [BPSW70,
DLR77].
It is not surprising that practical algorithms have resorted
to heuristics, as the general learning problem has been shown
to be hard under cryptographic assumptions [Ter02]. Fortunately, the hardness results are for HMMs that seem divorced
from those that we are likely to encounter in practical applications.

The situation is in many ways analogous to learning mixture distributions with samples from the underlying distribution. There, the general problem is believed to be hard.
However, much recent progress has been made when certain
separation assumptions are made with respect to the component mixture distributions (e.g. [Das99, DS07, VW02, CR08,
BV08]). Roughly speaking, these separation assumptions
imply that with high probability, given a point sampled from
the distribution, we can recover which component distribution generated this point. In fact, there is prevalent sentiment
that we are often only interested in clustering the data when
such a separation condition holds. Much of the theoretical
work here has been on how small this separation need be in
order to permit an efficient algorithm to recover the model.
We present a simple and efficient algorithm for learning
HMMs under a certain natural separation condition. We provide two results for learning. The first is that we can approximate the joint distribution over observation sequences
of length t (here, the quality of approximation is measured
by total variation distance). As t increases, the approximation quality degrades polynomially. Our second result is on
approximating the conditional distribution over a future observation, conditioned on some history of observations. We
show that this error is asymptotically bounded—i.e. for any
t, conditioned on the observations prior to time t, the error in
predicting the t-th outcome is controlled. Our algorithm can
be thought of as ‘improperly’ learning an HMM in that we do
not explicitly recover the transition and observation models.
However, our model does maintain a hidden state representation which is closely (in fact, linearly) related to the HMM’s,
and can be used for interpreting the hidden state.
The separation condition we require is a spectral condition on both the observation matrix and the transition matrix.
Roughly speaking, we require that the observation distributions arising from distinct hidden states be distinct (which
we formalize by singular value conditions on the observation matrix). This requirement can be thought of as being
weaker than the separation condition for clustering in that the
observation distributions can overlap quite a bit—given one
observation, we do not necessarily have the information to
determine which hidden state it was generated from (unlike
in the clustering literature). We also have a spectral condition
on the correlation between adjacent observations. We believe
both of these conditions to be quite reasonable in many practical applications. Furthermore, given our analysis, extensions to our algorithm which relax these assumptions should

be possible.
The algorithm we present has both polynomial sample
and computational complexity. Computationally, the algorithm is quite simple—at its core is a singular value decomposition (SVD) of a correlation matrix between past and future observations. This SVD can be viewed as a Canonical
Correlation Analysis (CCA) [Hot35] between past and future observations. The sample complexity results we present
do not explicitly depend on the number of distinct observations; rather, they implicitly depend on this number through
spectral properties of the HMM. This makes the algorithm
particularly applicable to settings with a large number of observations, such as those in NLP where the space of observations is sometimes the words in a language.
1.1

Related Work

There are two ideas closely related to this work. The first
comes from the subspace identification literature in control
theory [Lju87, OM96, Kat05]. The second idea is that, rather
than explicitly modeling the hidden states, we can represent
the probabilities of sequences of observations as products of
matrix observation operators, an idea which dates back to the
literature on multiplicity automata [Sch61, CP71, Fli74].
The subspace identification methods, used in control theory, use spectral approaches to discover the relationship between hidden states and the observations. In this literature,
the relationship is discovered for linear dynamical systems
such as Kalman filters. The basic idea is that the relationship between observations and hidden states can often be discovered by spectral/SVD methods correlating the past and
future observations (in particular, such methods often do a
CCA between the past and future observations). However,
algorithms presented in the literature cannot be directly used
to learn HMMs because they assume additive noise models
with noise distributions independent of the underlying states,
and such models are not suitable for HMMs (an exception
is [ARJ03]). In our setting, we use this idea of performing a
CCA between past and future observations to uncover information about the observation process (this is done through
an SVD on a correlation matrix between past and future observations). The state-independent additive noise condition
is avoided through the second idea.
The second idea is that we can represent the probability
of sequences as products of matrix operators, as in the literature on multiplicity automata [Sch61, CP71, Fli74] (see
[EDKM05] for discussion of this relationship). This idea
was re-used in both the Observable Operator Model of [Jae00]
and the Predictive State Representations of [LSS01], both
of which are closely related and both of which can model
HMMs. In fact, the former work by [Jae00] provides a noniterative algorithm for learning HMMs, with an asymptotic
analysis. However, this algorithm assumed knowing a set of
‘characteristic events’, which is a rather strong assumption
that effectively reveals some relationship between the hidden states and observations. In our algorithm, this problem
is avoided through the first idea.
Some of the techniques in the work in [EDKM07] for
tracking belief states in an HMM are used here. As discussed
earlier, we provide a result showing how the model’s conditional distributions over observations (conditioned on a his-

tory) do not asymptotically diverge. This result was proven
in [EDKM07] when an approximate model is already known.
Roughly speaking, the reason this error does not diverge is
that the previous observations are always revealing information about the next observation; so with some appropriate
contraction property, we would not expect our errors to diverge. Our work borrows from this contraction analysis.
Among recent efforts in various communities [ARJ03,
VWM07, ZJ07, CC08], the only previous efficient algorithm
shown to PAC-learn HMMs in a setting similar to ours is due
to [MR06]. Their algorithm for HMMs is a specialization of
a more general method for learning phylogenetic trees from
leaf observations. While both this algorithm and ours rely
on the same rank condition and compute similar statistics,
they differ in two significant regards. First, [MR06] were
not concerned with large observation spaces, and thus their
algorithm assumes the state and observation spaces to have
the same dimension. In addition, [MR06] take the more ambitious approach of learning the observation and transition
matrices explicitly, which unfortunately results in a less stable and less sample-efficient algorithm that injects noise to
artificially spread apart the eigenspectrum of a probability
matrix. Our algorithm avoids recovering the observation and
transition matrix explicitly1 , and instead uses subspace identification to learn an alternative representation.

2
2.1

Preliminaries
Hidden Markov Models

The HMM defines a probability distribution over sequences
of hidden states (ht ) and observations (xt ). We write the set
of hidden states as [m] = {1, . . . , m} and set of observations
as [n] = {1, . . . , n}, where m ≤ n.
Let T ∈ Rm×m be the state transition probability matrix
with Tij = Pr[ht+1 = i|ht = j], O ∈ Rn×m be the observation probability matrix with Oij = Pr[xt = i|ht = j], and
~π ∈ Rm be the initial state distribution with ~πi = Pr[h1 =
i]. The conditional independence properties that an HMM
satisfies are: 1) conditioned on the previous hidden state, the
current hidden state is sampled independently of all other
events in the history; and 2) conditioned on the current hidden state, the current observation is sampled independently
from all other events in the history. These conditional independence properties of the HMM imply that T and O fully
characterize the probability distribution of any sequence of
states and observations.
A useful way of computing the probability of sequences
is in terms of ‘observation operators’, an idea which dates
back to the literature on multiplicity automata (see [Sch61,
CP71, Fli74]). The following lemma is straightforward to
verify (see [Jae00, EDKM07]).
Lemma 1. For x = 1, . . . , n, define
Ax = T diag(Ox,1 , . . . , Ox,m ).
1
In Appendix A, we discuss the key step in [MR06], and also
show how to use their technique in conjunction with our algorithm
to recover the HMM observation and transition matrices. Our algorithm does not rely on this extra step—we believe it to be generally
unstable—but it can be taken if desired.

For any t:
Pr[x1 , . . . , xt ] = ~1>
π.
m Axt . . . Ax1 ~
Our algorithm learns a representation that is based on this
observable operator view of HMMs.
2.2 Notation
As already used in Lemma 1, the vector ~1m is the all-ones
vector in Rm . We denote by x1:t the sequence (x1 , . . . , xt ),
and by xt:1 its reverse (xt , . . . , x1 ). When we use a sequence
as a subscript, we mean the product of quantities indexed by
the sequence elements. So for example, the probability calculation in Lemma 1 can be written ~1>
π . We will use
m Axt:1 ~
~ht to denote a probability vector (a distribution over hidden
states), with the arrow distinguishing it from the random hidden state variable ht . Additional notation used in the theorem statements and proofs is listed in Table 1.
2.3 Assumptions
We assume the HMM obeys the following condition.
Condition 1 (HMM Rank Condition). ~π > 0 element-wise,
and O and T are rank m.
The conditions on ~π and T are satisfied if, say, the Markov
chain specified by T is ergodic and ~π is its stationary distribution. The condition on O rules out the problematic case in
which some state i has an output distribution equal to a convex combination (mixture) of some other states’ output distributions. Such a case could cause a learner to confuse state
i with a mixture of these other states. As mentioned before,
the general task of learning HMMs (even the specific goal
of simply accurately modeling the distribution probabilities
[Ter02]) is hard under cryptographic assumptions; the rank
condition is a natural way to exclude the malicious instances
created by the hardness reduction.
The rank condition of O can be relaxed through a simple
modification of our algorithm that looks at multiple observation symbols simultaneously to form the probability estimation tables. For example, if two hidden states have identical
observation probability in O but different transition probability in T , then they may be differentiated by using two consecutive observations. Although our analysis can be applied
in this case with minimal modifications, for clarity, we only
state our results for an algorithm that estimates probability
tables with rows and columns corresponding to single observations.
2.4 Learning Model
Our learning model is similar to those of [KMR+ 94, MR06]
for PAC-learning discrete probability distributions. We assume we can sample observation sequences from an HMM.
In particular, we assume each sequence is generated starting from the same initial state distribution (e.g. the stationary
distribution of the Markov chain specified by T ). This setting
is valid for practical applications including speech recognition, natural language processing, and DNA sequence modeling, where multiple independent sequences are available.
For simplicity, this paper only analyzes an algorithm that
uses the initial few observations of each sequence, and ignores the rest. We do this to avoid using concentration bounds

with complicated mixing conditions for Markov chains in
our sample complexity calculation, as these conditions are
not essential to the main ideas we present. In practice, however, one should use the full sequences to form the probability estimation tables required by our algorithm. In such
scenarios, a single long sequence is sufficient for learning,
and the effective sample size can be simply discounted by
the mixing rate of the underlying Markov chain.
Our goal is to derive accurate estimators for the cumulative (joint) distribution Pr[x1:t ] and the conditional distribution Pr[xt |x1:t−1 ] for any sequence length t. For the conditional distribution, we obtain an approximation that does not
depend on t, while for the joint distribution, the approximation quality degrades gracefully with t.

3

Observable Representations of Hidden
Markov Models

A typical strategy for learning HMMs is to estimate the observation and transition probabilities for each hidden state
(say, by maximizing the likelihood of a sample). However,
since the hidden states are not directly observed by the learner,
one often resorts to heuristics (e.g. EM) that alternate beb
tween imputing the hidden states and selecting parameters O
and Tb that maximize the likelihood of the sample and current state estimates. Such heuristics can suffer from local
optima issues and require careful initialization (e.g. an accurate guess of the hidden states) to avoid failure.
However, under Condition 1, HMMs admit an efficiently
learnable parameterization that depends only on observable
quantities. Because such quantities can be estimated from
data, learning this representation avoids any guesswork about
the hidden states and thus allows for algorithms with strong
guarantees of success.
This parameterization is natural in the context of Observable Operator Models [Jae00], but here we emphasize
its connection to subspace identification.
3.1

Definition

Our HMM representation is defined in terms of the following
vector and matrix quantities:
[P1 ]i
[P2,1 ]ij
[P3,x,1 ]ij

= Pr[x1 = i]
= Pr[x2 = i, x1 = j]
=

Pr[x3 = i, x2 = x, x1 = j] ∀x ∈ [n],

where P1 ∈ Rn is a vector, and P2,1 ∈ Rn×n and the
P3,x,1 ∈ Rn×n are matrices. These are the marginal probabilities of observation singletons, pairs, and triples.
The representation further depends on a matrix U ∈ Rn×m
that obeys the following condition.
Condition 2 (Invertibility Condition). U > O is invertible.
In other words, U defines an m-dimensional subspace
that preserves the state dynamics—this will become evident
in the next few lemmas.
A natural choice for U is given by the ‘thin’ SVD of P2,1 ,
as the next lemma exhibits.

Lemma 2. Assume ~π > 0 and that O and T have column
rank m. Then rank(P2,1 ) = m. Moreover, if U is the matrix of left singular vectors of P2,1 corresponding to non-zero
singular values, then range(U ) = range(O), so U ∈ Rn×m
obeys Condition 2.
Proof. Using the conditional independence properties of the
HMM, entries of the matrix P2,1 can be factored as
[P2,1 ]ij =
=

hidden states (though the following lemma shows that they
are linearly related). As per Lemma 3, the initial state is
~b1 = (U > O)~π .
Generally, for any t ≥ 1, given observations x1:t−1 with
Pr[x1:t−1 ] > 0, we define the internal state as:
~bt = ~bt (x1:t−1 ) =

Our algorithm is motivated by Lemma 2 in that we compute the SVD of an empirical estimate of P2,1 to discover a
U that satisfies Condition 2. We also note that this choice for
U can be thought of as a surrogate for the observation matrix
O (see Remark 5).
Now given such a matrix U , we can finally define the
observable representation:

3.2

~b1
~b∞

=
=

>
P2,1
U

Bx

=

U > P3,x,1

U > P1
+

P1

U > P2,1

+

∀x ∈ [n] .

.

The case t = 1 is consistent with the general definition of ~bt
~
~ > > −1 (U > O)~π =
because the denominator is ~b>
∞ b1 = 1m (U O)
~1>
π = 1. The following result shows how these interm~
nal states can be used to compute conditional probabilities
Pr[xt = i|x1:t−1 ].
Lemma 4 (Conditional Internal States). Assume the conditions in Lemma 3. Then, for any time t:
1. (Recursive update of states) If Pr[x1:t ] > 0, then

3.3 Proofs
Proof of Lemma 3. The first claim is immediate from the fact
P1 = O~π . For the second claim, we write P1 in the following unusual (but easily verified) form:

1. ~b1 = (U > O)~π .
~ > > −1 .
2. ~b>
∞ = 1m (U O)

P1>

3. Bx = (U > O)Ax (U > O)−1 ∀x ∈ [n].
~
4. Pr[x1:t ] = ~b>
∞ Bxt:1 b1 ∀t ∈ N, x1 , . . . , xt ∈ [n].
In addition to joint probabilities, we can compute conditional probabilities using the observable representation. We
do so through (normalized) conditional ‘internal states’ that
depend on a history of observations. We should emphasize
that these states are not in fact probability distributions over

The probability calculation in the fourth claim is now readily
seen as a telescoping product that reduces to the product in
Lemma 1.

2,1

bx = U
b > Pb3,x,1 (U
b > Pb2,1 )+ ∀x ∈ [n].
(c) B

Proof of Lemma 4. The first claim is a simple induction. The
second and third claims are also proved by induction as follows. The base case is clear from Lemma 3 since ~h1 = ~π and
~b1 = (U > O)~π , and also ~b> Bx ~b1 = ~1> Ax ~π = Pr[x1 ].
m
∞
1
1
For the inductive step,
~bt+1

The representation in the previous section suggests the algorithm L EARN HMM(m, N ) detailed in Figure 1, which
simply uses random samples to estimate the model parameters. Note that in practice, knowing m is not essential because the method presented here tolerates models that are
not exactly HMMs, and the parameter m may be tuned using
cross-validation. As we discussed earlier, the requirement
for independent samples is only for the convenience of our
sample complexity analysis.
The model returned by L EARN HMM(m, N ) can be used
as follows:
• To predict the probability of a sequence:
c 1 , . . . , xt ] = bb>
b
b b
Pr[x
∞ Bxt . . . Bx1 b1 .

by

bx bbt
B
t
.
bb> B
b
b
∞ x bt
t

• To predict the conditional probability of xt given x1:t−1 :
b> b b
c t |x1:t−1 ] = Pb∞ Bxt bt .
Pr[x
b> b b
x b∞ Bx bt
Aside from the random sampling, the running time of the
learning algorithm is dominated by the SVD computation of
an n×n matrix. The time required for computing joint probability calculations is O(tm2 ) for length t sequences—same
as if one used the ordinary HMM parameters (O and T ). For
conditional probabilities, we require some extra work (proportional to n) to compute the normalization factor. However, our analysis shows that this normalization factor is always close to 1 (see Lemma 13), so it can be safely omitted
in many applications.
4.2

Main Results

We now present our main results. The first result is a guarantee on the accuracy of our joint probability estimates for
observation sequences. The second result concerns the accuracy of conditional probability estimates — a much more
delicate quantity to bound due to conditioning on unlikely
events. We also remark that if the probability distribution is
only approximately modeled as an HMM, then our results
degrade gracefully based on this approximation quality.
4.2.1 Joint Probability Accuracy
Let σm (M ) denote the mth largest singular value of a matrix
M . Our sample complexity bound will depend polynomially
on 1/σm (P2,1 ) and 1/σm (O).

(1)
and let
n0 () = min{k : (k) â&#x2030;¤ /4}.
In other words, n0 () is the minimum number of observations that account for about 1 â&#x2C6;&#x2019; /4 of the total probability
mass. Clearly n0 () â&#x2030;¤ n, but it can often be much smaller
in real applications. For example, in many practical applications, the frequencies of observation symbols observe a
power law (called Zipfâ&#x20AC;&#x2122;s law) of the form f (k) â&#x2C6;? 1/k s ,
where f (k) is the frequency of the k-th most frequently observed symbol. If s > 1, then (k) = O(k 1â&#x2C6;&#x2019;s ), and n0 () =
O(1/(1â&#x2C6;&#x2019;s) ) becomes independent of the number of observations n. This means that for such problems, our analysis
below leads to a sample complexity bound for the cumulative distribution Pr[x1:t ] that can be independent of n. This
is useful in domains with large n such as natural language
processing.
Theorem 6. There exists a constant C > 0 such that the
following holds. Pick any 0 < , Îˇ < 1 and t â&#x2030;Ľ 1. Assume
the HMM obeys Condition 1, and
t2
m Âˇ log(1/Îˇ)
m Âˇ n0 () Âˇ log(1/Îˇ)
N â&#x2030;Ľ CÂˇ 2 Âˇ
+
.
Ď&#x192;m (O)2 Ď&#x192;m (P2,1 )4
Ď&#x192;m (O)2 Ď&#x192;m (P2,1 )2
With probability at least 1 â&#x2C6;&#x2019; Îˇ, the model returned by the
algorithm L EARN HMM(m, N ) satisfies
X
c 1 , . . . , xt ]| â&#x2030;¤ .
| Pr[x1 , . . . , xt ] â&#x2C6;&#x2019; Pr[x
x1 ,...,xt

The main challenge in proving Theorem 6 is understanding how the estimation errors accumulate in the algorithmâ&#x20AC;&#x2122;s
probability calculation. This would have been less problematic if we had estimates of the usual HMM parameters T and
O; the fully observable representation forces us to deal with
more cumbersome matrix and vector products.
4.2.2 Conditional Probability Accuracy
In this section, we analyze the accuracy of our conditional
c t |x1 , . . . , xtâ&#x2C6;&#x2019;1 ]. Intuitively, we might hope
predictions Pr[x
that these predictive distributions do not become arbitrarily
bad over time (as t â&#x2020;&#x2019; â&#x2C6;&#x17E;). The reason is that while estimation errors propagate into long-term probability predictions
(as evident in Theorem 6), the history of observations constantly provides feedback about the underlying hidden state,
and this information is incorporated using Bayesâ&#x20AC;&#x2122; rule (implicitly via our internal state updates).
This intuition was confirmed by [EDKM07], who showed
that if one has an approximate model of T and O for the
HMM, then under certain conditions, the conditional prediction does not diverge. This condition is the positivity of the
â&#x20AC;&#x2DC;value of observationâ&#x20AC;&#x2122; Îł, defined as
Îł =
inf kO~v k1 .
~
v :k~
v k1 =1

â&#x2C6;&#x161;

Note that Îł â&#x2030;Ľ Ď&#x192;m (O)/ n, so it is guaranteed to be positive
by Condition 1. However, Îł can be much larger than what
this crude lower bound suggests.

To interpret this quantity Îł, consider any two distributions over hidden states ~h, b
h â&#x2C6;&#x2C6; Rm . Then kO(~h â&#x2C6;&#x2019; b
h)k1 â&#x2030;Ľ
~
b
~
Îłkh â&#x2C6;&#x2019; hk1 . Regarding h as the true hidden state distribution
and b
h as the estimated hidden state distribution, this inequality gives a lower bound on the error of the estimated observation distributions under O. In other words, the observation
process, on average, reveal errors in our hidden state estimation. [EDKM07] uses this as a contraction property to show
how prediction errors (due to using an approximate model)
do not diverge. In our setting, this is more difficult as we
do not explicitly estimate O nor do we explicitly maintain
distributions over hidden states.
We also need the following assumption, which we discuss further following the theorem statement.
Condition 3 (Stochasticity Condition). For all observations
x and all states i and j, [Ax ]ij â&#x2030;Ľ Îą > 0.
Theorem 7. There exists a constant C > 0 such that the
following holds. Pick any 0 < , Îˇ < 1. Assume the HMM
obeys Conditions 1 and 3, and
m Âˇ n0 ()
m
N â&#x2030;ĽCÂˇ 2
+
Ď&#x192;m (O)2 Ď&#x192;m (P2,1 )2
Ď&#x192;m (O)2 Ď&#x192;m (P2,1 )4
m
(log(2/Îą))4
(log(2/Îą))4
1
Âˇ 2 2+
+
Âˇ log .
Îą
4 Îą 4 Îł 4
Îą10 Îł 4
Îˇ
With probability at least 1 â&#x2C6;&#x2019; Îˇ, then the model returned by
L EARN HMM(m, N ) satisfies, for any time t,
c t |x1 , . . . , xtâ&#x2C6;&#x2019;1 ])
KL(Pr[xt |x1 , . . . , xtâ&#x2C6;&#x2019;1 ] || Pr[x
"
#
Pr[xt |x1:tâ&#x2C6;&#x2019;1 ]
= Ex1:t ln
â&#x2030;¤ .
c t |x1:tâ&#x2C6;&#x2019;1 ]
Pr[x
To justify our choice of error measure, note that the problem of bounding the errors of conditional probabilities is
complicated by the issue of that, over the long run, we may
have to condition on a very low probability event. Thus we
need to control the relative accuracy of our predictions. This
makes the KL-divergence a natural choice for the error measure. Unfortunately, because our HMM conditions are more
naturally interpreted in terms of spectral and normed quantities, we end up switching back and forth between KL and
L1 errors via Pinsker-style inequalities (as in [EDKM07]). It
is not clear to us if a significantly better guarantee could be
obtained with a pure L1 error analysis (nor is it clear how to
do such an analysis).
The analysis in [EDKM07] (which assumed that approximations to T and O were provided) dealt with this problem
of dividing by zero (during a Bayesâ&#x20AC;&#x2122; rule update) by explicitly modifying the approximate model so that it never assigns
the probability of any event to be zero (since if this event occurred, then the conditional probability is no longer defined).
In our setting, Condition 3 ensures that true model never assigns the probability of any event to be zero. We can relax
this condition somewhat (so that we need not quantify over
all observations), though we do not discuss this here.
We should also remark that while our sample complexity bound is significantly larger than in Theorem 6, we are
also bounding the more stringent KL-error measure on conditional distributions.

for all t â&#x2030;¤ tmax . The second term is now bounded as in Theorem 6, with spectral parameters corresponding to PrHMM .

Proof ideas

We outline the main ideas for proving Theorems 6 and 7.
Full proofs can be found in a technical report available from
arXiv (http://arxiv.org/abs/0811.4413).
Throughout this section, we assume the HMM obeys Condition 1. Table 1 summarizes the notation that will be used
throughout the analysis in this section.
5.1 Estimation Errors
Define the following sampling error quantities:
1 = kPb1 â&#x2C6;&#x2019; P1 k2
2,1
3,x,1

Lemma 8. If the algorithm independently samples N observation triples from the HMM, then with probability at least
1 â&#x2C6;&#x2019; Îˇ:
r
1

We need to quantify how estimation errors propagate in the
probability calculation. Because the joint probability of a
length t sequence is computed by multiplying together t matrices, there is a danger of magnifying the estimation errors
exponentially. Fortunately, this is not the case: the following
lemma (readily proved by induction) shows that these errors
accumulate roughly additively.
b > O is invertible. For any time t:
Lemma 11. Assume U
X
b > O)â&#x2C6;&#x2019;1 B
bx bb1 â&#x2C6;&#x2019; B
ex eb1
(U
t:1
t:1
1

We introduce the following notation. Let the unnormalized estimated conditional hidden state distributions be
b
b > O)â&#x2C6;&#x2019;1bbt ,
ht = (U
and its normalized version,
b
gbt = b
ht /(~1>
m ht ).
Also, let
bx = (U
b > O)â&#x2C6;&#x2019;1 B
bx (U
b > O).
A
This notation lets us succinctly compare the updates made
by our estimated model to the updates of the true model. Our
algorithm never explicitly computes these hidden state distributions gbt (as it would require knowledge of the unobserved
O). However, under certain conditions (namely Conditions 1
and 3 and some estimation accuracy requirements), these distributions are well-defined and thus we use them for sake of
analysis.
The following lemma shows that if the estimated parameters are accurate, then the state updates behave much like
the true hidden state updates.
Lemma 13. For any probability vector w
~ â&#x2C6;&#x2C6; Rm and any
observation x,

All that remains is to bound the effect of errors in bbâ&#x2C6;&#x17E; .
Theorem 6 will follow from the following lemma combined
with the sampling error bounds of Lemma 8.

Lemma 13 and Corollary 14 can now be used to prove the
contraction property of the KL-divergence between the true
hidden states and the estimated hidden states. The analysis
shares ideas from [EDKM07], though the added difficulty is
due to the fact that the state maintained by our algorithm is
not a probability distribution.

Theorem 7 follows by combining the previous lemma
and the sampling error bounds of Lemma 8.
Acknowledgments
The authors would like to thank John Langford and Ruslan Salakhutdinov for earlier discussions on using bottleneck
methods to learn nonlinear dynamic systems. The linearization of the bottleneck idea was the basis of this paper. We
also thank Yishay Mansour for pointing out hardness results
for learning HMMs. This work was completed while the first
author was an intern at TTI-C in 2008.

[VWM07] B. Vanluyten, J. Willems, and B. De Moor. A
new approach for the identification of hidden
markov models. In Conference on Decision and
Control, 2007.
[ZJ07] MingJie Zhao and Herbert Jaeger. The error
controlling algorithm for learning OOMs. Technical Report 6, International University Bremen, 2007.

will be separated with high probability (though the separation is roughly on the same order as the failure probability; this is the main source of instability with this method).
Therefore an eigen-decomposition will recover the columns
of (U > OT ) up to a diagonal scaling matrix S, i.e. U > OT S.
Then for each x, we can diagonalize (U > P3,x,1 )(U > P3,1 )+ :
(U > OT S)−1 (U > P3,x,1 )(U > P3,1 )+ (U > OT S) = Ox .

and
O+ P2,1 (O+ )> diag(~π )−1
=
=

O+ (OT diag(~π )O> )(O+ )> diag(~π )−1
T.

Note that because [MR06] do not allow more observations than states, they do not need to work in a lower dimensional subspace such as range(U ). Thus, they perform an
eigen-decomposition of the matrix
!
X
X
−1
gx P3,x,1 P3,1 = (OT )
gx Ox (OT )−1 ,
x

x

and then use the eigenvectors to form the matrix OT . Thus
they rely on the stability of the eigenvectors, which depends
heavily on the spacing of the eigenvalues.