Number of vectors
3
Number of coordinates
2
 v = ( a1, a2 ) w = ( b1, b2 ) u = ( c1, c2 )
First vector
a₁
a₂
Second vector
b₁
b₂
Third vector
c₁
c₂

# Linear Independence Calculator

By Maciej Kowalski, PhD candidate
Last updated: Mar 26, 2021

Welcome to the linear independence calculator, where we'll learn how to check if you're dealing with linearly independent vectors or not.

In essence, the world around us is a vector space and sometimes it is useful to limit ourselves to a smaller section of it. For example, a sphere is a 3-dimensional shape, but a circle exists in just two dimensions, so why bother with calculations in three?

Linear dependence allows us to do just that - work in a smaller space, the so-called span of the vectors in question. But don't you worry if you've found all these fancy words fuzzy so far. In a second, we'll slowly go through all of this together.

So grab your morning/evening snack for the road, and let's get going!

## What is a vector?

When you ask someone, "What is a vector?" quite often, you'll get the answer "an arrow." After all, we usually denote them with an arrow over a small letter:

Well, let's just say that this answer will not score you 100 on a test. Formally, a vector is an element of vector space. End of definition. Easy enough. We can finish studying. Everything is clear now.

But what is a vector space, then? Again, the mathematical definition leaves a lot to be desired: it's a set of elements with some operations (addition and multiplication by scalar), which must have several specific properties. So, why don't we just leave the formalism and look at some real examples?

The Cartesian space is an example of a vector space. This means that the numerical line, the plane, and the 3-dimensional space we live in are all vector spaces. Their elements are, respectively, numbers, pairs of numbers, and triples of numbers, which, in each case, describe the location of a point (an element of the space). For instance, the number `-1` or point `A = (2, 3)` are elements of (different!) vector spaces. Often, when drawing the forces that act on an object, like velocity or gravitational pull, we use straight arrows to describe their direction and value, and that's where the "arrow definition" comes from.

What is quite important is that we have well-defined operations on the vectors mentioned above. There are some slightly more sophisticated ones like the dot product and the cross product. However, fortunately, we'll limit ourselves to two basic ones which follow similar rules to the same matrix operations (vectors are, in fact, one-row matrices). First of all, we can add them:

`-1 + 4 = 3`,

`(2,3) + (-3, 11) = (2 + (-3), 3 + 11) = (-1, 14)`,

and we can multiply them by a scalar (a real or complex number) to change their magnitude:

`3 * (-1) = -3`,

`7 * (2, 3) = (7 * 2, 7 * 3) = (14, 21)`.

Truth be told, a vector space doesn't have to contain numbers. It can be a space of sequences, functions, or permutations. Even the scalars don't have to be numerical! But let's leave that abstract mumbo-jumbo to scientists. We're quite fine with just the numbers, aren't we?

## Linear combination of vectors

Let's say that we're given a bunch of vectors (from the same space): `v₁`, `v₂`, `v₃`,..., `vₙ`. As we've seen in the above section, we can add them and multiply them by scalars. Any expression that is obtained this way is called a linear combination of the vectors. In other words, any vector `w`, that can be written as

`w = 𝛼₁*v₁ + 𝛼₂*v₂ + 𝛼₃*v₃ + ... + 𝛼ₙ*vₙ`

where `𝛼₁, 𝛼₂, 𝛼₃,..., 𝛼ₙ` are arbitrary real numbers is said to be a linear combination of the vectors `v₁`, `v₂`, `v₃`,..., `vₙ`. Note, that `w` is indeed a vector since it's a sum of vectors.

Okay, so why do all that? There are several things in life, like helium balloons and hammocks, that are fun to have but aren't all that useful on a daily basis. Is it the case here?

Let's consider the Cartesian plane, i.e., the 2-dimensional space of points `A = (x,y)` with two coordinates, where `x` and `y` are arbitrary real numbers. We already know that such points are vectors, so why don't we take two very special ones: `e₁ = (1,0)` and `e₂ = (0,1)`. Now, observe that:

`A = (x,y) = (x,0) + (0,y) = x*(1,0) + y*(0,1) = x*e₁ + y*e₂`.

In other words, any point (vector) of our space is a linear combination of vectors `e₁` and `e₂`. These vectors then form a basis (and an orthonormal basis at that) of the space. And believe us, in applications and calculations, it's often easier to work with a basis you know rather than some random vectors you don't.

But what if we added another vector to the pile and wanted to describe linear combinations of the vectors `e₁`, `e₂`, and, say, `v`? We've seen that `e₁` and `e₂` proved enough to find all points. So adding `v` shouldn't change anything, should it? Actually, it seems quite redundant. And that's exactly where linear dependence comes into play.

## Linearly independent vectors

No, it has nothing to do with your 4th of July BBQs. We say that `v₁`, `v₂`, `v₃`,..., `vₙ` are linearly independent vectors if the equation

`𝛼₁*v₁ + 𝛼₂*v₂ + 𝛼₃*v₃ + ... + 𝛼ₙ*vₙ = 0`

(here `0` is the vector with zeros in all coordinates) holds if and only if `𝛼₁ = 𝛼₂ = 𝛼₃ = ... = 𝛼ₙ = 0`. Otherwise, we say that the vectors are linearly dependent.

The above definition can be understood as follows: the only linear combination of the vectors that gives the zero vector is trivial. For instance, recall the vectors from the above section: `e₁ = (1,0)`, `e₂ = (0,1)`, and then also take `v = (2,-1)`. Then

`(-2)*e₁ + 1*e₂ + 1*v = (-2)*(1,0) + 1*(0,1) + 1*(2,-1) = (-2,0) + (0,1) + (2,-1) = (0,0)`,

so we've found a non-trivial linear combination of the vectors that gives zero. Therefore, they are linearly dependent. Also, we can easily see that `e₁` and `e₂` themselves without the problematic `v` are linearly independent vectors.

## The span of vectors in linear algebra

The set of all elements that can be written as a linear combination of vectors `v₁`, `v₂`, `v₃`,..., `vₙ` is called the span of the vectors and is denoted `span(v₁, v₂, v₃,..., vₙ)`. Coming back to the vectors from the above section, i.e., `e₁ = (1,0)`, `e₂ = (0,1)`, and `v = (2,-1)`, we see that

`span(e₁, e₂, v) = span(e₁, e₂) = ℝ²`,

where `ℝ²` is the set of points on the Cartesian plane, i.e., all possible pairs of real numbers. In essence, this means that the span of the vectors is the same for `e₁`, `e₂`, and `v`, and for just `e₁` and `e₂`. This suggests that `v` is redundant and doesn't change anything. Yes, you guessed it - that's precisely because of linear dependence.

The span in linear algebra describes the space where our vectors live. In particular, the smallest number of elements that is enough to do it is called the dimension of the vector space. In the above example, it was `2` because we can't get fewer elements than `e₁` and `e₂`.

A keen eye will observe that, in fact, the dimension of the span of vectors is equal to the number of linearly independent vectors in the bunch. In the example above, it was pretty simple: the vectors `e₁` and `e₂` were the easiest possible (in fact, they even have their own name: the standard basis). But what if we have something different? How can we check linear dependence and describe the span of vectors in every case? In a minute, we'll find out just that and so much more!

## How to check linear dependence

To check linear dependence, we'll translate our problem from the language of vectors into the language of matrices (arrays of numbers). For instance, say that we're given three vectors in a 2-dimensional space (with two coordinates): `v = (a₁, a₂)`, `w = (b₁, b₂)`, and `u = (c₁, c₂)`. Now let's write their coordinates as one big matrix with each row (or column, it doesn't matter) corresponding to one of the vectors:

A =
 ⌈ a₁ a₂ ⌉ | b₁ b₂ ｜ ⌊ c₁ c₂ ⌋

Then the rank of the matrix is equal to the maximal number of linearly independent vectors among `v`, `w`, and `u`. In other words, their span in linear algebra is of dimension `rank(A)`. In particular, they are linearly independent vectors if, and only if, the rank of `A` is equal to the number of vectors.

So how do we find the rank? Arguably, the easiest method is Gaussian elimination (or its refinement, the Gauss-Jordan elimination). It is the same algorithm that is often used to solve systems of linear equations, especially when trying to find the (reduced) row echelon form of the system.

The Gaussian elimination relies on so-called elementary row operations:

1. Exchange two rows of the matrix.
2. Multiply a row by a non-zero constant.
3. Add to a row a non-zero multiple of a different row.

The trick here is that although the operations change the matrix, they don't change its rank and, therefore, the dimension of the span of the vectors.

The algorithm tries to eliminate (i.e., make them `0`) as many entries of `A` as possible. In the above case, provided that `a₁` is non-zero, the first step of Gaussian elimination will transform the matrix into something in the form:

 ⌈ a₁ a₂ ⌉ | 0 s₂ ｜ ⌊ 0 t₂ ⌋

where `s₂` and `t₂` are some real numbers. Then, as long as `s₂` is not zero, the second step will give the matrix

 ⌈ a₁ a₂ ⌉ | 0 s₂ ｜ ⌊ 0 0 ⌋

Now we need to observe that the bottom row represents the zero vector (it has `0`'s in every cell), which is linearly dependent with any vector. Therefore, the rank of our matrix will simply be the number of non-zero rows of the array we obtained, which in this case is `2`.

That was quite enough time spent on theory, wouldn't you say? Let's try out an example to see the linear independence calculator in action!

## Example: using the linear independence calculator

Let's say that you've finally made your dreams come true - you bought a drone. You're finally able to take pictures and videos of the places you visit from far above. All you need to do is program its movements. The drone requires you to give it three vectors along which it'll be able to move.

The world we live in is 3-dimensional, so the vectors will have three coordinates. Not thinking too much, you take some random vectors that come to mind: `(1, 3, -2)`, `(4, 7, 1)`, and `(3, -1, 12)`. But is it really worth it just closing your eyes, flipping a coin, and picking random numbers? After all, most of your savings went into the thing, so we'd better do it well.

Well, if you did choose the numbers randomly, you might find that the vectors you chose are linearly dependent, and the span of the vectors is, for instance, only 2-dimensional. This means that your drone wouldn't be able to move around however you wish, but be limited to moving along a plane. It might just happen that it would be able to move left and right, front and back, but not up and down. And how would we get those award-winning shots of the hike back if the drone can't even fly up?

It is fortunate then that we have the linear independence calculator! With it, we can quickly and effortlessly check whether our choice was a good one. So, let's go through how to use it.

We have `3` vectors with `3` coordinates each, so we start by telling the calculator that fact by choosing the appropriate options under "number of vectors" and "number of coordinates." This will show us a symbolic example of such vectors with the notation used in the linear independence calculator. For instance, the first vector is given by `v = (a₁, a₂, a₃)`. Therefore, since in our case the first one was `(1, 3, -2)`, we input

`a₁ = 1`, `a₂ = 3`, `a₃ = -2`.

Similarly for the two other ones we get:

`b₁ = 4`, `b₂ = 7`, `b₃ = 1`,

`c₁ = 3`, `c₂ = -1`, `c₃ = 12`.

Once we input the last number, the linear independence calculator will instantly tell us if we have linearly independent vectors or not, and what is the dimension of the span of the vectors. Nevertheless, let's grab a piece of paper and try to do it all independently by hand to see how the calculator arrived at its answer.

As mentioned in the above section, we'd like to calculate the rank of a matrix formed by our vectors. We'll construct the array of size 3×3 by writing the coordinates of consecutive vectors in consecutive rows. This way, we arrive at a matrix

A =
 ⌈ 1 3 -2 ⌉ | 4 7 1 ｜ ⌊ 3 -1 12 ⌋

We'll now use Gaussian elimination. First of all, we'd like to have zeros in the bottom two rows of the first column. To obtain them, we use elementary row operations and the `1` from the top row. In other words, we add a suitable multiple of the first row to the other two so that their first entry will become zero. Since `4 + (-4)*1 = 0` and `3 + (-3)*1 = 0`, we add a multiple of `(-4)` and `(-3)` of the first row to the second and third row, respectively. This gives a matrix

 ⌈ 1 3 -2 ⌉ | 4 + (-4)*1 7 + (-4)*3 1 + (-4)*(-2) ｜ ⌊ 3 + (-3)*1 -1 + (-3)*3 12 + (-3)*(-2) ⌋
=
=
 ⌈ 1 3 -2 ⌉ | 0 -5 9 ｜ ⌊ 0 -10 18 ⌋

Next, we'd like to get `0` in the bottom row in the middle column and use the `-5` to do it. Again, we add a suitable multiple of the second row to the third one. Since `-10 + (-2)*(-5) = 0`, the multiple is `(-2)`. Therefore,

 ⌈ 1 3 -2 ⌉ | 0 -5 9 ｜ ⌊ 0 -10 + (-2)*(-5) 18 + (-2)*9 ⌋
=
=
 ⌈ 1 3 -2 ⌉ | 0 -5 9 ｜ ⌊ 0 0 0 ⌋

We've obtained zeros in the bottom rows. We know that the matrix's rank, and therefore linear dependence and the span in linear algebra, are determined by the number of non-zero rows. This means that in our case, we have `rank(A) = 2`, which is less than the number of vectors, and implies that they are linearly dependent and span a 2-dimensional space.

So the very thing that we feared might happen happened - our drone will have no freedom of movement. But we can't miss out on this chance to film all those aerial shots! Fortunately, we have the linear independence calculator at hand and can play around with the vectors to find a suitable vector combination. And once we have that, we pack up, get in the car, and go on an adventure!

Maciej Kowalski, PhD candidate