Gram-Schmidt Process & QR Decomposition

The Goal

The input is a set of linearly independent vectors

\{\mathbf{v}_1, \mathbf{v}_2, \dots, \mathbf{v}_k\}

in an inner product space. The output is an orthogonal set

\{\mathbf{u}_1, \mathbf{u}_2, \dots, \mathbf{u}_k\}

satisfying two conditions: the vectors are pairwise perpendicular (

\mathbf{u}_i \cdot \mathbf{u}_j = 0

for

i \neq j

), and they span the same subspace (

\text{Span}\{\mathbf{u}_1, \dots, \mathbf{u}_j\} = \text{Span}\{\mathbf{v}_1, \dots, \mathbf{v}_j\}

at every step

j

).

Optionally, each

\mathbf{u}_i

is normalized to unit length, producing an orthonormal set

\{\mathbf{q}_1, \dots, \mathbf{q}_k\}

.

The process is the constructive proof that every finite-dimensional inner product space has an orthonormal basis. Given any basis, Gram-Schmidt produces an orthonormal one for the same space.

The Algorithm: Two Vectors

Start with two independent vectors

\mathbf{v}_1

and

\mathbf{v}_2

.

Set

\mathbf{u}_1 = \mathbf{v}_1

.

Subtract the projection of

\mathbf{v}_2

onto

\mathbf{u}_1

:

\mathbf{u}_2 = \mathbf{v}_2 - \frac{\mathbf{u}_1 \cdot \mathbf{v}_2}{\mathbf{u}_1 \cdot \mathbf{u}_1}\,\mathbf{u}_1

The subtracted term is the component of

\mathbf{v}_2

along

\mathbf{u}_1

. Removing it leaves only the component perpendicular to

\mathbf{u}_1

, so

\mathbf{u}_1 \cdot \mathbf{u}_2 = 0

.

Worked Example

\mathbf{v}_1 = (1, 1, 0)

,

\mathbf{v}_2 = (1, 0, 1)

.

\mathbf{u}_1 = (1, 1, 0)

.

\frac{\mathbf{u}_1 \cdot \mathbf{v}_2}{\mathbf{u}_1 \cdot \mathbf{u}_1} = \frac{1}{2}

.

\mathbf{u}_2 = (1, 0, 1) - \frac{1}{2}(1, 1, 0) = (\frac{1}{2}, -\frac{1}{2}, 1)

.

Check:

\mathbf{u}_1 \cdot \mathbf{u}_2 = \frac{1}{2} - \frac{1}{2} + 0 = 0

.

The overlap removed from the second vector

The projection of this vector onto the direction already fixed is being subtracted away. What survives is orthogonal to that direction by construction, not by luck — the subtraction removes precisely the component that would have made the dot product non-zero. Watch the next vector go through the same treatment on the Gram-Schmidt visualizer.

The general case below repeats this step once per vector already fixed, which is the only way the algorithm grows.

The Algorithm: General Case

For

k

independent vectors

\mathbf{v}_1, \dots, \mathbf{v}_k

:

\mathbf{u}_1 = \mathbf{v}_1

Gram-Schmidt Process

\mathbf{u}_j = \mathbf{v}_j - \sum_{i=1}^{j-1} \frac{\mathbf{u}_i \cdot \mathbf{v}_j}{\mathbf{u}_i \cdot \mathbf{u}_i}\,\mathbf{u}_i \quad \text{for } j = 2, 3, \dots, k

Gram schmidt process →

At each step,

\mathbf{v}_j

has its projections onto all previously computed orthogonal vectors subtracted. What remains is the component of

\mathbf{v}_j

perpendicular to

\text{Span}\{\mathbf{u}_1, \dots, \mathbf{u}_{j-1}\}

.

Because

\mathbf{v}_j

is independent of

\{\mathbf{v}_1, \dots, \mathbf{v}_{j-1}\}

— and therefore not in

\text{Span}\{\mathbf{u}_1, \dots, \mathbf{u}_{j-1}\}

— this perpendicular component is nonzero. So each

\mathbf{u}_j \neq \mathbf{0}

, and the process never breaks down.

At every stage,

\text{Span}\{\mathbf{u}_1, \dots, \mathbf{u}_j\} = \text{Span}\{\mathbf{v}_1, \dots, \mathbf{v}_j\}

. The span is preserved because each

\mathbf{u}_j

is a linear combination of

\mathbf{v}_j

and the earlier

\mathbf{u}_i

's (which are themselves combinations of

\mathbf{v}_1, \dots, \mathbf{v}_{j-1}

).

Gram-Schmidt Notation

Notation

Gram-Schmidt Notation

An algorithm's notation has to record not just what the objects are but the order they were built in — so this page runs three letters for three stages of the same vector, and a sum whose upper limit moves with the step it appears in. All catalogued among the linear algebra symbols.

\operatorname{proj}

and its subscript come from projection notation; the dot from dot product notation;

\|\mathbf{v}\|

and the unit hat from norm notation;

\operatorname{Span}

from span notation;

\delta_{ij}

and

Q

from orthogonal set notation.

\mathbf{v}_j \to \mathbf{u}_j \to \mathbf{e}_j

input, orthogonalised, normalised

Three letters for three stages of the same vector:

\mathbf{v}_j

is what you started with,

\mathbf{u}_j

what survives after the projections are removed, and

\mathbf{e}_j

the unit version — Normalization below performs that last step. The subscript stays fixed across all three; only the letter records how far the vector has been processed.

CasesSources that skip the orthogonal stage write

\mathbf{q}_j

directly for the normalised output, matching the

Q

of the decomposition below; others reuse

\mathbf{v}_j

throughout and overwrite in place, which is how the algorithm is actually implemented but loses the ability to refer to an earlier stage.

Do not confuse

\mathbf{e}_j

as a standard basis vector. Here it is the

j

-th vector this process produced, not the

j

-th axis — the letter is borrowed for "unit vector", and only the surrounding construction says which unit vector is meant.

\mathbf{u}_j = \mathbf{v}_j - \sum_{i=1}^{j-1} \operatorname{proj}_{\mathbf{u}_i}(\mathbf{v}_j)

subtract the projections onto everything built so far

The upper limit is the notational content:

j-1

means everything already constructed, so the sum's length grows as the algorithm proceeds and the formula refers to its own earlier outputs. This is a recursive definition written as a formula, not a closed expression.

CasesThe first step is the empty case — at

j = 1

the sum has no terms, which is why

\mathbf{u}_1 = \mathbf{v}_1

needs no separate rule; and the projections are onto the

\mathbf{u}_i

, never the

\mathbf{v}_i

, which is the one substitution that silently breaks the algorithm.

Do not confuseA fixed sum over all

k

vectors. Reading the limit as

k

rather than

j-1

asks the formula to use vectors that do not exist yet — the range is the whole reason the construction terminates.

A = QR

A factors into an orthonormal Q and an upper-triangular R

Letters as a contract, in the family pattern decomposition notation describes:

Q

carries the orthonormal columns this process produces,

R

collects the coefficients it discarded along the way — The QR Decomposition below reads them off directly.

Cases

R

comes out upper triangular for a reason the notation encodes:

\mathbf{v}_j

is built only from

\mathbf{u}_1, \dots, \mathbf{u}_j

, so every entry below the diagonal is a coefficient that was never used.

Do not confuse

R

as the real numbers. Blackboard

\mathbb{R}

is the field; italic

R

here is one specific triangular matrix, and the two sit close together in exactly the equations where both appear.

All linear algebra symbols →↑ Orthogonality

Normalization

After computing the orthogonal set

\{\mathbf{u}_1, \dots, \mathbf{u}_k\}

, normalization produces an orthonormal set:

\mathbf{q}_i = \frac{\mathbf{u}_i}{\|\mathbf{u}_i\|}

Each vector is divided by its length, making

\|\mathbf{q}_i\| = 1

while preserving direction. The resulting set satisfies

\mathbf{q}_i \cdot \mathbf{q}_j = \delta_{ij}

.

Normalization can be done at each step (normalize

\mathbf{u}_j

immediately before moving to

\mathbf{v}_{j+1}

) or all at the end. The result is the same in exact arithmetic. In practice, normalizing at each step is slightly preferable for numerical stability, as it keeps the vectors well-scaled throughout the computation.

Scaling the survivor to unit length

Orthogonality was settled by the subtraction; this step only fixes the length. Splitting the two concerns is why the algorithm can be stated for an orthogonal basis and then upgraded to an orthonormal one without changing its structure. Toggle normalisation on and off on the Gram-Schmidt visualizer.

Dividing by a very small length is where the classical algorithm loses accuracy, which is the subject of the stability section later.

Worked Example: Three Vectors in R³

Orthogonalize

\mathbf{v}_1 = (1, 1, 1)

,

\mathbf{v}_2 = (1, 0, 1)

,

\mathbf{v}_3 = (0, 1, 1)

.

\mathbf{u}_1 = (1, 1, 1)

.

For

\mathbf{u}_2

:

\frac{\mathbf{u}_1 \cdot \mathbf{v}_2}{\mathbf{u}_1 \cdot \mathbf{u}_1} = \frac{1 + 0 + 1}{3} = \frac{2}{3}

.

\mathbf{u}_2 = (1, 0, 1) - \frac{2}{3}(1, 1, 1) = (\frac{1}{3}, -\frac{2}{3}, \frac{1}{3})

.

Check:

\mathbf{u}_1 \cdot \mathbf{u}_2 = \frac{1}{3} - \frac{2}{3} + \frac{1}{3} = 0

.

For

\mathbf{u}_3

:

\frac{\mathbf{u}_1 \cdot \mathbf{v}_3}{\mathbf{u}_1 \cdot \mathbf{u}_1} = \frac{0 + 1 + 1}{3} = \frac{2}{3}

and

\frac{\mathbf{u}_2 \cdot \mathbf{v}_3}{\mathbf{u}_2 \cdot \mathbf{u}_2} = \frac{0 - \frac{2}{3} + \frac{1}{3}}{\frac{1}{9} + \frac{4}{9} + \frac{1}{9}} = \frac{-\frac{1}{3}}{\frac{6}{9}} = \frac{-1}{2}

.

\mathbf{u}_3 = (0, 1, 1) - \frac{2}{3}(1, 1, 1) - (-\frac{1}{2})(\frac{1}{3}, -\frac{2}{3}, \frac{1}{3}) = (0, 1, 1) - (\frac{2}{3}, \frac{2}{3}, \frac{2}{3}) + (\frac{1}{6}, -\frac{1}{3}, \frac{1}{6}) = (-\frac{1}{2}, 0, \frac{1}{2})

.

Check:

\mathbf{u}_1 \cdot \mathbf{u}_3 = -\frac{1}{2} + 0 + \frac{1}{2} = 0

and

\mathbf{u}_2 \cdot \mathbf{u}_3 = -\frac{1}{6} + 0 + \frac{1}{6} = 0

.

Normalizing:

\|\mathbf{u}_1\| = \sqrt{3}

,

\|\mathbf{u}_2\| = \sqrt{6}/3

,

\|\mathbf{u}_3\| = 1/\sqrt{2}

. The orthonormal basis is

\{\mathbf{u}_1/\sqrt{3}, \; 3\mathbf{u}_2/\sqrt{6}, \; \sqrt{2}\,\mathbf{u}_3\}

.

Why It Works

At each step,

\mathbf{u}_j

is constructed as

\mathbf{v}_j

minus everything in

\mathbf{v}_j

that lies in the subspace

W_{j-1} = \text{Span}\{\mathbf{u}_1, \dots, \mathbf{u}_{j-1}\}

. Since

\{\mathbf{u}_1, \dots, \mathbf{u}_{j-1}\}

is orthogonal, the projection formula decomposes cleanly into independent terms — one projection per basis vector.

What remains after subtraction is the component of

\mathbf{v}_j

orthogonal to

W_{j-1}

. This component is nonzero because

\mathbf{v}_j \notin W_{j-1}

— guaranteed by the independence of the original set.

The span is preserved at each step. Each

\mathbf{u}_j

is a linear combination of

\mathbf{v}_j

and

\mathbf{u}_1, \dots, \mathbf{u}_{j-1}

, and each earlier

\mathbf{u}_i

is a combination of

\mathbf{v}_1, \dots, \mathbf{v}_i

. So

\mathbf{u}_j \in \text{Span}\{\mathbf{v}_1, \dots, \mathbf{v}_j\}

, and the reverse inclusion follows because

\mathbf{v}_j

can be recovered from

\mathbf{u}_j

and the earlier

\mathbf{u}_i

's.

The QR Decomposition

Applying Gram-Schmidt to the columns

\mathbf{a}_1, \dots, \mathbf{a}_n

of an

m \times n

matrix

A

(with independent columns) produces the QR decomposition:

A = QR

Q

is

m \times n

with orthonormal columns (the normalized

\mathbf{q}_i

's).

R

is

n \times n

upper triangular with positive diagonal entries.

The entries of

R

are the dot products computed during Gram-Schmidt:

R_{ij} = \mathbf{q}_i \cdot \mathbf{a}_j

for

i \leq j

, and

R_{ij} = 0

for

i > j

(because

\mathbf{a}_j

's projection onto

\mathbf{q}_i

is zero when

i > j

— that direction hasn't been subtracted yet).

The factorization captures two complementary pieces of information.

Q

stores the orthonormal directions.

R

stores the coefficients that express the original columns in terms of those directions:

\mathbf{a}_j = R_{1j}\mathbf{q}_1 + R_{2j}\mathbf{q}_2 + \cdots + R_{jj}\mathbf{q}_j

.

Download

PNGRaster · 2×PDFPrint quality

Orthogonality · QR

Where each factor comes from

Running Gram–Schmidt on the columns of $A$ produces both factors at once. $Q$ is the output and $R$ is the bookkeeping — the coefficients that were subtracted along the way, kept rather than discarded.

2factors

Type	Condition	entries	properties	what it records
The output
Q — orthonormal columns§ 7	$m \times n$	$\mathbf{q}_j = \mathbf{u}_j / \\|\mathbf{u}_j\\|$	$Q^{\mathsf{T}}Q = I_n$	an orthonormal basis for $\operatorname{Col}(A)$
The bookkeeping
R — upper triangular§ 7	$n \times n$	$r_{ij} = \mathbf{q}_i \cdot \mathbf{v}_j$	diagonal $r_{jj} = \\|\mathbf{u}_j\\|>0$	the coefficients discarded during orthogonalization

This is why QR is not a separate algorithm from Gram–Schmidt so much as its record. Every projection coefficient computed during orthogonalization is an entry of

R

, and

R

is triangular precisely because

\mathbf{v}_j

is only ever projected onto vectors that came before it.

Where each factor comes from·/linear-algebra/orthogonality/gram-schmidtLearn Math Class

The triangularity of

R

is worth seeing as a consequence rather than a condition. At step

j

the algorithm projects

\mathbf{v}_j

onto

\mathbf{q}_1, \ldots, \mathbf{q}_{j-1}

and no others, so every coefficient with

i > j

is zero because that projection was never computed. Nothing was imposed on the shape — it fell out of processing the columns in order.

The same run, recorded as two factors

The orthonormal vectors produced have become the columns of Q, and the coefficients subtracted along the way have become the entries of R. The triangularity of R is not imposed: it reflects the fact that each vector was only ever corrected against the ones before it. Compare the two views on the QR decomposition visualizer.

Gram-Schmidt and QR are therefore one computation with two names, depending on whether the vectors or the factors are what you are after.

QR and Least Squares

The QR decomposition provides a numerically superior method for solving least-squares problems.

The normal equations

A^TA\hat{\mathbf{x}} = A^T\mathbf{b}

can be rewritten using

A = QR

. Since

A^TA = R^TQ^TQR = R^TR

and

A^T\mathbf{b} = R^TQ^T\mathbf{b}

, the normal equations become

R^TR\hat{\mathbf{x}} = R^TQ^T\mathbf{b}

. Canceling

R^T

(which is invertible since

R

has positive diagonal):

R\hat{\mathbf{x}} = Q^T\mathbf{b}

This is an upper triangular system, solved by back substitution. The computation

Q^T\mathbf{b}

is just

n

dot products (one per column of

Q

).

The QR approach avoids forming

A^TA

explicitly. This matters because the condition number of

A^TA

is the square of the condition number of

A

— squaring amplifies rounding errors. Working with

Q

and

R

directly preserves the original conditioning and is the standard method for least squares in numerical software.

Numerical Stability

Classical Gram-Schmidt (as presented above) can lose orthogonality in floating-point arithmetic. When the input vectors are nearly dependent, the computed

\mathbf{u}_j

's may fail to be perpendicular to machine precision, and the errors accumulate with each step.

Modified Gram-Schmidt addresses this by reorganizing the computation. Instead of computing all projections using the original

\mathbf{v}_j

, modified Gram-Schmidt updates

\mathbf{v}_j

in place after each projection is subtracted. At step

j

, first subtract the projection onto

\mathbf{u}_1

from

\mathbf{v}_j

, then subtract the projection onto

\mathbf{u}_2

from the updated

\mathbf{v}_j

, and so on. The mathematical result is identical in exact arithmetic, but the modified version is significantly more stable numerically.

Householder reflections provide an even more robust alternative for computing the QR factorization. Householder-based QR achieves backward stability — the gold standard in numerical linear algebra — and is the default algorithm in most software libraries.

Method	How it computes the orthogonal set / QR	Numerical stability	Typical use
Classical Gram–Schmidt	at step j, all projections of the original v_j onto u₁, …, u_j−1 are computed and subtracted at once	poor — orthogonality can be lost when input vectors are nearly dependent; errors accumulate	textbook / illustrative use; abstract inner product spaces where exact arithmetic is available
Modified Gram–Schmidt	v_j is updated in place after each individual projection is subtracted	significantly better than classical; identical result in exact arithmetic	educational software, moderate-precision floating-point work
Householder reflections	a sequence of orthogonal reflections is applied to A to zero out below-diagonal entries column by column	backward stable — the gold standard in numerical linear algebra	default QR routine in LAPACK, NumPy, MATLAB, and most numerical libraries
Givens rotations	a sequence of 2 × 2 plane rotations zeros out individual entries one at a time	backward stable; lets the algorithm target nonzero entries only	sparse matrices with structured zeros; updating an existing QR factorization

Gram-Schmidt on Abstract Inner Product Spaces

The algorithm works in any inner product space — the dot product is replaced by the general inner product

\langle \cdot, \cdot \rangle

, and the formulas are otherwise identical:

\mathbf{u}_j = \mathbf{v}_j - \sum_{i=1}^{j-1} \frac{\langle \mathbf{u}_i, \mathbf{v}_j \rangle}{\langle \mathbf{u}_i, \mathbf{u}_i \rangle}\,\mathbf{u}_i

Orthogonalizing

\{1, x, x^2\}

in the polynomial space

\mathcal{P}_2

with the inner product

\langle p, q \rangle = \int_{-1}^{1} p(x)q(x)\,dx

produces the Legendre polynomials (up to normalization):

P_0(x) = 1

,

P_1(x) = x

,

P_2(x) = \frac{1}{2}(3x^2 - 1)

. The polynomial

x

is already orthogonal to

1

under this inner product (the integral of an odd function over a symmetric interval is zero), so the first subtraction has no effect.

On the function space

C[0, 2\pi]

with

\langle f, g \rangle = \int_0^{2\pi} f(x)g(x)\,dx

, orthogonalizing appropriate function sets produces Fourier bases. The algorithm is identical in structure to the

\mathbb{R}^n

version — only the inner product changes.

Summary: Gram-Schmidt Across Settings

Gram-Schmidt operates uniformly across many settings — ℝⁿ with the standard dot product, polynomial spaces with integral inner products, function spaces in Fourier analysis, and abstract inner product spaces in general. The table below collects the main contexts in which the process is applied, alongside the input, the inner product used, and what the algorithm produces in each case.

What follows is one algorithm listed six times. The steps are identical in every row — subtract the projections onto what has already been processed, then optionally divide by the length. The only thing that varies is which inner product those projections are computed with, and the grouping below separates the familiar dot product from the integrals that replace it elsewhere.

Download

PNGRaster · 2×PDFPrint quality

Orthogonality · Gram–Schmidt

The same algorithm across settings

The procedure never changes — subtract projections, optionally normalise. What changes from row to row is only the inner product being used, and with it what the word "orthogonal" turns out to mean.

6settings

The dot product on ℝⁿ3

1

Orthogonal basis§ 3

input independent

\mathbf{u}_j = \mathbf{v}_j - \sum_{i<j} \operatorname{proj}_{\mathbf{u}_i}(\mathbf{v}_j)

Each vector loses everything it shares with the ones already processed, leaving the perpendicular remainder. The span is preserved at every prefix, so the output describes the same subspace as the input — differently oriented, not differently sized.

2

Orthonormal basis§ 4

one extra division per vector

\mathbf{q}_j = \mathbf{u}_j / \|\mathbf{u}_j\|

Normalisation is a separate step and strictly optional — orthogonality is already achieved. It is worth doing because projection onto an orthonormal set is a bare dot product, with no denominator to carry.

3

QR decomposition§ 7

A

of full column rank

A = QR

,

R

upper triangular

Run the algorithm on the columns of

A

and the outputs are the columns of

Q

; the projection coefficients discarded along the way are exactly the entries of

R

. The factorization is the algorithm with its bookkeeping written down — see QR.

Other inner products3

4

Polynomials§ 10

applied to

\{1, x, x^2, \ldots\}

\langle p, q \rangle = \int_{-1}^{1} p(x)q(x)\,dx

The monomials are independent but not orthogonal under this product. Orthogonalizing them produces the Legendre polynomials — which is to say Legendre polynomials are not a discovery so much as what Gram–Schmidt returns when handed the obvious basis.

5

Functions§ 10

sines and cosines

\langle f, g \rangle = \int_0^{2\pi} f(x)g(x)\,dx

Here the algorithm has almost nothing to do: distinct frequencies are already orthogonal under this product, so it only normalises. That is the fact the Fourier basis rests on, and the reason a Fourier coefficient is a single integral rather than a linear system.

6

Any inner product space§ 10

finite-dimensional, any

\langle \cdot, \cdot \rangle

orthonormal

\{\mathbf{q}_1, \ldots, \mathbf{q}_n\}

The general statement the rows above are instances of. Because the algorithm terminates and uses only the axioms, it proves the existence of an orthonormal basis rather than assuming it — a constructive proof, not an abstract one.

The algorithm only ever calls two things: the inner product and scalar multiplication. It never inspects what a vector is, which is why the same code orthogonalizes tuples, polynomials and functions without modification — and why it constitutes a constructive proof that every finite-dimensional inner product space has an orthonormal basis.

The same algorithm across settings·/linear-algebra/orthogonality/gram-schmidtLearn Math Class

The second group is where the generality earns its keep. Under the integral inner product on

[-1, 1]

the monomials

1, x, x^2

are independent but not orthogonal, and orthogonalizing them yields the Legendre polynomials — so those are not a separate construction but simply what this algorithm returns when handed the obvious basis. Under the inner product on

[0, 2\pi]

, sines and cosines of distinct frequencies are already orthogonal, and the algorithm finds nothing to subtract.

That last observation is why a Fourier coefficient is a single integral rather than the solution of a linear system: the basis was orthogonal before anyone asked. The algorithm never inspects what a vector is — it calls the inner product and scalar multiplication and nothing else — which is what lets the same procedure serve tuples, polynomials and functions, and what makes it a constructive proof that every finite-dimensional inner product space has an orthonormal basis.

Gram-Schmidt FAQ

Why does the sum stop at $j-1$ rather than running over all the vectors?

+

Because the later vectors have not been produced yet. At step

j

only

\mathbf{u}_1

through

\mathbf{u}_{j-1}

exist, so a fixed upper limit would ask the formula to use things that do not exist. The moving limit is also why the construction terminates, and at

j = 1

the empty sum makes

\mathbf{u}_1 = \mathbf{v}_1

automatic.Read more →

Are the $\mathbf{e}_j$ here the standard basis vectors?

+

No, they are the unit vectors this process produced, not the coordinate axes. The letter is borrowed for its association with unit length, and only the surrounding construction says which unit vector is meant. Watch the projections too: they must be onto the

\mathbf{u}_i

, never the original

\mathbf{v}_i

, which is the substitution that silently breaks the algorithm.Read more →

Why does $R$ come out upper triangular?

+

Because of what the algorithm builds. Each

\mathbf{v}_j

is assembled from only the first

j

orthogonal vectors, so any coefficient below the diagonal would refer to a vector that never contributed. Those entries are zero not by construction but by absence. Note that italic

R

here is one triangular matrix, unrelated to blackboard

\mathbb{R}

.Read more →

Gram Schmidt Process

Converting Any Basis into an Orthogonal One

The Goal

The Algorithm: Two Vectors

Worked Example

The Algorithm: General Case

Gram-Schmidt Notation

Gram-Schmidt Notation

Normalization

Worked Example: Three Vectors in R³

Why It Works

The QR Decomposition

Where each factor comes from

QR and Least Squares

Numerical Stability

Gram-Schmidt on Abstract Inner Product Spaces

Summary: Gram-Schmidt Across Settings

The same algorithm across settings

Gram-Schmidt FAQ

Why does the sum stop at $j-1$ rather than running over all the vectors?

Are the $\mathbf{e}_j$ here the standard basis vectors?

Why does $R$ come out upper triangular?

Gram Schmidt Process

Converting Any Basis into an Orthogonal One

The Goal

The Algorithm: Two Vectors

Worked Example

The Algorithm: General Case

Gram-Schmidt Notation

Gram-Schmidt Notation

Normalization

Worked Example: Three Vectors in R³

Why It Works

The QR Decomposition

Where each factor comes from

QR and Least Squares

Numerical Stability

Gram-Schmidt on Abstract Inner Product Spaces

Summary: Gram-Schmidt Across Settings

The same algorithm across settings

Gram-Schmidt FAQ

Why does the sum stop at j−1j-1j−1 rather than running over all the vectors?

Are the ej\mathbf{e}_jej​ here the standard basis vectors?

Why does RRR come out upper triangular?

Why does the sum stop at $j-1$ rather than running over all the vectors?

Are the $\mathbf{e}_j$ here the standard basis vectors?

Why does $R$ come out upper triangular?