Linear Algebra 38 | Set of Solutions [dark version]

TL;DR

For Ax = B, solutions exist exactly when B lies in Range(A).

Briefing Cornell Notes

Briefing

For a linear system written as Ax = B, the solution set is either empty or forms an affine (shifted) subspace: once at least one solution exists, every other solution differs from it by a vector in the kernel of A. This matters because it turns the messy question “what are all solutions?” into two concrete tasks—check whether solutions exist at all, then compute the kernel to describe every possible solution.

The starting point is dimensional and geometric structure. A is an M×n matrix, so it defines a linear map f_A: R^n → R^m. The unknown vector x has n components, while B has M components. Existence of solutions depends on whether B lies in the range (image) of A: if B is not in Range(A), the system cannot reach B, so the solution set is empty. If B does lie in Range(A), at least one solution exists—call one such vector v0—meaning Av0 = B.

Once one solution v0 is known, the full solution set is described using the kernel. The kernel of A is the set of vectors x0 such that Ax0 = 0; it is a linear subspace. The key proposition states that the set of all solutions S is either empty or equals v0 + Ker(A). Here “v0 + Ker(A)” means an affine subspace: every element of S has the form v0 + x0 where x0 ranges over Ker(A). In other words, the system’s solutions are exactly the vectors that satisfy Ax = B, and plugging x = v0 + x0 into the equation yields Ax = Av0 + Ax0 = B + 0 = B precisely when x0 lies in Ker(A).

This characterization also clarifies uniqueness. The system has a unique solution exactly when the kernel is trivial—only the zero vector—because then v0 + Ker(A) collapses to just {v0}. If the kernel has nonzero vectors, there are infinitely many solutions, all obtained by shifting v0 along directions in Ker(A).

Finally, the affine-subspace description links directly to computation. Row operations do not change the solution set: they preserve the kernel (multiplying A on the left by an invertible matrix M doesn’t alter Ker(A)) and they preserve which vectors map to B (if Av0 = B, then (MA)v0 = MB). That invariance is why Gaussian elimination is the right tool: it can determine whether B is in Range(A), produce a particular solution v0 when it exists, and compute a basis for Ker(A). With those pieces, the entire solution set S can be written down as either empty or v0 + Ker(A).

Cornell Notes

For Ax = B, solutions exist only if B lies in the range of A. When at least one solution v0 exists, every solution has the form v0 + x0, where x0 is any vector in the kernel of A. This means the solution set is an affine (shifted) subspace: S = v0 + Ker(A). If no such v0 exists, then S is empty. Uniqueness happens exactly when Ker(A) is trivial (only the zero vector), because then S contains only v0. Row operations preserve both the kernel and the existence of solutions, so Gaussian elimination can be used to find a particular solution and a basis for the kernel, fully determining S.

How does one decide whether Ax = B has any solutions at all?

Existence hinges on whether B is in Range(A). Since A maps R^n to R^m, the system can only produce outputs that lie in the image of A. If B ∉ Range(A), there is no x with Ax = B, so the solution set S is empty. If B ∈ Range(A), at least one solution exists.

If one solution v0 is known, how can the entire solution set be generated?

Assume v0 satisfies Av0 = B. Any other solution x must satisfy A x = B, so write x = v0 + x0. Substituting gives A(v0 + x0) = Av0 + Ax0 = B + Ax0. For this to equal B, it must be that Ax0 = 0, meaning x0 ∈ Ker(A). Thus S = v0 + Ker(A).

What exactly does “v0 + Ker(A)” mean?

It denotes an affine subspace: the set of all vectors of the form v0 + x0 where x0 ranges over Ker(A). It is a translate of the linear subspace Ker(A) by the vector v0, so the solution set is “shifted” but still has the linear directions given by the kernel.

When is the solution to Ax = B unique?

Uniqueness occurs when Ker(A) is trivial, i.e., Ker(A) = {0}. Then S = v0 + Ker(A) becomes just {v0}. If Ker(A) contains nonzero vectors, then adding those kernel vectors to v0 produces distinct solutions, so there are infinitely many.

Why do row operations not change the solution set?

Row operations correspond to multiplying A on the left by an invertible matrix M. Multiplying by M does not change the kernel: Ker(MA) = Ker(A). Also, if Av0 = B, then (MA)v0 = MB, so the relationship between inputs and outputs is preserved under the same transformation. Together, these facts keep the solution set unchanged.

What three outputs does Gaussian elimination need to produce to fully describe S?

Gaussian elimination should (1) determine whether B lies in Range(A); if not, S is empty. If yes, it should (2) find a particular solution v0. Finally, it should (3) compute a basis for Ker(A). With v0 and a basis for Ker(A), the full solution set is S = v0 + Ker(A).

Review Questions

What condition on B relative to A determines whether the system Ax = B has any solutions?
How do you derive the form S = v0 + Ker(A) starting from Av0 = B?
Why does a nontrivial kernel imply infinitely many solutions rather than a unique one?

Key Points

1
For Ax = B, solutions exist exactly when B lies in Range(A).
2
If B ∈ Range(A) and v0 is one solution, then every solution is v0 + x0 with x0 ∈ Ker(A).
3
The solution set is either empty or an affine subspace S = v0 + Ker(A).
4
Uniqueness occurs iff Ker(A) is trivial (only the zero vector).
5
Row operations preserve the kernel and therefore preserve the entire solution set.
6
Gaussian elimination is the practical method to test B ∈ Range(A), find a particular solution v0, and compute a basis for Ker(A).

Highlights

Once a single solution v0 satisfies Av0 = B, the rest of the solutions are obtained by adding any vector from Ker(A).

The solution set is an affine subspace: S = v0 + Ker(A), not just a linear subspace.

If B is not in Range(A), the solution set is empty—no amount of algebra can produce a solution.

Row operations keep Ker(A) unchanged, which is why they don’t alter the solution set.

Gaussian elimination is positioned as the workflow to find existence, one solution, and the kernel basis. 