Aq k 1 q k r k q k a k r 1 1 r 1 2 r 1 k in version 2

.
.
AQ
k - 1
= Q
k
R
k
⇒ Q
k
= A
k
R
- 1
1
R
- 1
2
· · · R
- 1
k
.
In version 2, we have
A = U
1
R
1
A
2
= U
1
R
1
U
1
R
1
= U
1
U
2
R
2
R
1
A
3
= U
1
R
1
U
1
U
2
R
2
R
1
= U
1
U
2
R
2
U
2
R
2
R
1
= U
1
U
2
U
3
R
3
R
2
R
1
.
.
.
A
k
= U
1
U
2
· · · U
k
R
k
R
k - 1
· · · R
1
,
which is the same thing as version 1 with
Q
k
= U
1
U
2
· · · U
k
.
To keep track of the eigenvectors, we can restate the QR algorithm
as follows.
Let Γ
0
= A , Q
0
= I . For k = 1 , 2 , . . . , do
[ U
k
, R
k
] = qr( Γ
k - 1
) (so Γ
k - 1
= U
k
R
k
)
Γ
k
= R
k
U
k
Q
k
= Q
k - 1
U
k
Then Γ
k
→ Λ and Q
k
→ V .
12
Georgia Tech ECE 6250 Fall 2019; Notes by J. Romberg and M. Davenport. Last updated 13:22, November 13, 2019

Comments on computational complexity
The methods above have been the object of intense study over the
past 50-60 years, and their cost and stability is very well understood.
Notice that all of the methods cost O ( N 3 ) in the general case — this
is the essential cost of solving a system of linear equations.
When N is small, O ( N 3 ) is OK. For example, I have a nice desktop
system (a 3.8 GHz Intel i7 with 8 cores and 64 GB memory), and
this about how long it takes MATLAB to solve Ax = b for different
N :
N = 100: 0.0003 seconds (300 μ s)
N = 1 000: 0.01 seconds (10ms)
N = 5 000: 0.5 seconds
N = 10 000: 2.6 seconds
N = 50 000: 190 seconds (3.2 min)
There are many applications where N is in the millions (or even
billions). In these situations, solving Ax = b directly is infeasible.
You can roughly divide problems into three categories:
Small scale. N
.
10 3 . Here O ( N 3 ) algorithms are OK, and exact
algorithms are appropriate.
Medium scale. N ∼ 10 4 . Here O ( N 3 ) is not OK, O ( N 2 ) is OK. It
may be hard to even store the matrix in memory at this point.
Large scale. N
&
10 5 . Here O ( N 2 ) is not OK, O ( N 3 ) is typ-
ically unthinkable. We need algorithms that are O ( N ) or
O ( N log N ), possibly at the cost of finding an exact solution.
13
Georgia Tech ECE 6250 Fall 2019; Notes by J. Romberg and M. Davenport. Last updated 13:22, November 13, 2019

We will start by looking at certain types of structured symmetric
matrices. This structure allows us to solve Ax = b significantly
faster than O ( N 3 ).
After this, we will consider iterative algorithms for finding an
appropriate solution to Ax = b when A is sym+def. These algo-
rithms have the nice feature that the matrix A does not need to be
held in memory — all we need is a “black box” that computes Ax
given x as input. This is especially nice if you have a fast implicit
method for computing Ax (e.g A involved FFTs, or is sparse).
Structured matrices
We will discuss three types of structured matrices, although plenty of
other types exist. In each of these cases, the structure of the system
allows us to do a solve in much better than O ( N 3 ) operations.
Identity + low rank
Consider a system of the form
( γ I + BB
T
) x = b ,
where γ > 0 is some scalar, and B is a N × R matrix with R < N .