Quivers: a year of linear algebra by drawing arrows

Quivers: a year of linear algebra by drawing arrows 2026 Jun 9

Disclaimer: if your first instinct was to think about string diagrams, that's not was this post is about. Cool guess, though.

In algebra there's this idea of representations of some object, especially linear representations. It's so important that even chemists typically have the representation theory of finite groups in their curriculum, because those have a profound influence on the structure of atoms and molecules.

And it just so happens that studying representations of a particular kind of object (namely, quivers) can be seen as a generalization of a typical 1-year university linear algebra course :)

Contents

Representations

First, lets talk about representations a bit more.

The idea is that some objects are easier to study and understand than others. For example, permutations are easier to work with than elements of a general group, and there's a theorem that any group can be represented as a group of some permutations.

One of the things we understand the best in math are matrices — they seem to be in the perfect sweet spot between showing up everywhere and also having a deep, rich, and useful theory. It turns out that we can represent many objects as matrices, in which case we call them linear representations, though often the word representation means a linear representation by default.

As a simple example, consider complex numbers: how can we represent the number \(i\) as a real-valued matrix? Well, \(i\) is defined as being a root of the equation \(i^2=-1\), so we just need to find a matrix that satisfies this equation. Note that we'll need to replace the number \(-1\) with the scalar matrix having \(-1\) on the diagonal (because this matrix effectively acts as the number \(-1\) in the matrix algebra).

It's not hard to find a matrix which squares to \(-1\):

\[ \begin{pmatrix}0 & -1 \\ 1 & 0\end{pmatrix}^2 = \begin{pmatrix}-1 & 0 \\ 0 & -1\end{pmatrix} \]

You can notice that it's the matrix of rotation by \(90^\circ\), and that's not a coincidence!

If we also represent real numbers \(a\) as scalar matrices \(\begin{pmatrix}a & 0 \\ 0 & a\end{pmatrix}\), we can represent the complex number \(a+bi\) as a matrix

\[ a+bi \mapsto \begin{pmatrix}a & -b \\ b & a\end{pmatrix} \]

and matrices of this form act exacly like complex numbers — the addition and multiplication formulas are the same, as are all the other properties (the technical term is that the algebra of such matrices is isomorphic to the complex numbers).

In general, representations are easiest to define via category theory. For example, take a group, turn it into a one-object category with elements of this group as morphisms (i.e. categorify the group to obtain a groupoid), and then representations of this group are simply functors from this groupoid into some other category. Functors to \(\operatorname{Set}\) give permutation representations, while functors to \(\operatorname{Vect}_K\) give linear representations.

Matrices vs operators

I want to stress one thing which might sound like obvious truth, a boring technicality, or useless garbage, depending on your background. We commonly represent vectors using coordinates, which is especially convenient for direct computations, but an abstract vector isn't the same as a list of coordinates. We can always choose a different basis, and the coordinates of a specific vector will change, but the vector itself won't change — it represents some specific (albeit abstract) geometric object which doesn't depend on a particular encoding scheme that we've arbitrarily chosen.

The same goes for matrices and operators. A matrix is just a table with numbers; it only means something geometric once we've selected the basis vectors — specifically, it means a linear operator acting on these vectors. If we change the basis, the vectors and operators don't change, but the vector coordinates and matrix entries can change.

How important this is depends entirely on your domain of work. I'm bringing this up because it does matter here: by choosing a basis in a clever way, we can see how some complicated object ends up looking very simple. In fact, keeping track of bases will be very important in what follows.

So, what exactly is a quiver? It's a directed graph. That's it, that's the definition.

OK, there are a dozen different things that people call a directed graph.

Does it allow for multiple edges? Does it allow loops? For a quiver, the answers are yes and yes. In other words, there are no restrictions on edges: there can be several edges between two vertices, and edges can start and end in the same vertex. This type of a directed graph is often called a multidigraph.

Here are a few examples of quivers:

These were made with an online tool called — you wouldn't believe it — q.uiver.app.

Ok, a quiver is a multidigraph, i.e. a directed graph with multi-edges and loops allowed. If we already have a name for it, why call them quivers?

It boils down to the perspective that we're interested in. If you want to find shortest paths, count connected components, check if it is planar, etc, you'd call it a multidigraph. But if you're interested in representations and in category-theoretic stuff, you'd call them quivers.

Quiver representations

Ok, but what is a representation of a quiver? It's a fairly straightforward thing, actually:

For each vertex of the quiver, pick some vector space (e.g. \(\mathbb{R}^n\)) For each directed edge of the quiver, pick a linear map between the vector spaces corresponding to the starting/ending vertex of this edge

Or, if you're more comfortable with more concrete descriptions,

For each vertex of the quiver, pick a nonnegative integer (the dimension of the vector space) For each directed edge of the quiver, pick some \(N\times M\) matrix, where \(M\) is the number at the start of the edge, and \(N\) is the number at the end

For an example, let's take the \(\bullet\rightarrow\bullet\) quiver. A representation of this quiver is a pair of vector spaces and a linear map between them, or equivalently (after we choose a basis of the first vector space, and another basis of the second vector space), a representation is just some \(N\times M\) matrix (so, any matrix).

For another example, take the \(\bullet\style{display: inline-block; transform: rotate(-90deg)}{\circlearrowleft}\) quiver (one vertex, and one looping edge). For this quiver, we select just one vector space, and select an operator from this space to itself. Equivalently (after choosing a basis in this vector space), a representation of this quiver is just an \(N\times N\) matrix (i.e., any square matrix).

Classifying representations

When talking about representations, the first thing one is interested in is classifying all possible representations. We've already did it in some sense in the previous section — we've determined that for two simple quivers, the representations are all possible matrices, or all possible square matrices. However, that doesn't really tell us much about how these are structured as representations.

There's one particularly simple operation we can do with representations of the same quiver: just add them. This doesn't have anything to do with usual matrix addition, though, so this operation is usually referred to as the direct sum. If we have two representations, — let's call them \(A\) and \(B\), — their direct sum \(A\oplus B\) is constructed like this:

For each vertex, the corresponding vector space is the direct sum of the vector spaces assigned to this vertex by representations \(A\) and \(B\) For each edge, the corresponding linear map is the direct sum of the linear maps assigned to this edge by representations \(A\) and \(B\)

In terms of coordinates,

Direct sum of vector spaces corresponds to simply concatenating the coordinate arrays, and Direct sum of linear maps corresponds to forming a block-diagonal matrix like \(\begin{pmatrix}A & 0 \\ 0 & B\end{pmatrix}\)

The reason this is useful is that the \(A\) and \(B\) parts of the representation behave independently, so if we can decompose some representation into a sum of two smaller representations, then we can analyze them separately, which is typically much easier than analyzing the original representation as a whole.

Let's look at an example, with the same \(\bullet\rightarrow\bullet\) quiver. Recall that a representation of this quiver is just a linear map (a matrix) between two vector spaces.

Take representation \(A\) to be \(\mathbb{R}^2\rightarrow\mathbb{R}^3\) with the matrix defined as \(\begin{pmatrix}1 & 2 \\ 3 & 4 \\ 5 & 6\end{pmatrix}\), and the representation \(B\) to be \(\mathbb{R}\rightarrow\mathbb{R}^2\) with the matrix \(\begin{pmatrix}-32 \\ -64\end{pmatrix}\). Then, the direct sum representation \(A\oplus B\) maps between vector spaces

\[ \mathbb{R}^2\oplus\mathbb{R}=\mathbb{R}^3 \quad\longrightarrow\quad \mathbb{R}^3\oplus\mathbb{R}^2=\mathbb{R}^5 \]

with the matrix

\[ \begin{pmatrix}1 & 2 & 0 \\ 3 & 4 & 0 \\ 5 & 6 & 0 \\ 0 & 0 & -32 \\ 0 & 0 & -64\end{pmatrix} \]

A representation that can be decomposed into a direct sum is called, well, decomposable. It's important to note that it doesn't mean that each matrix in the representation is block-diagonal; rather, that there exists a basis of each vector space involved such that the matrix (wrt this basis) will be block-diagonal. Remember the matrix vs operator distinction I stressed earlier? That's where it becomes important.

A representation that cannot be decomposed in such a way is called indecomposable. That's quite a mouthful, but it wasn't me who invented this term. It's a more or less trivial result that any representation can be decomposed into indecomposable ones: just keep decomposing while you can, and stop when you can't decompose more — at this point you have a direct sum of indecomposable representations (of course, in infinite dimensions you'd need to invoke Zorn's lemma).

So, to classify representations, it's enough to classify indecomposable ones, and that's exactly what we'll do for a bunch of simple-looking quivers.

The \(\bullet\) quiver

The simplest possible quiver has...nothing. Zero vertices, zero edges. It has exactly one representation — the one that doesn't really specify any vector spaces or matrices. You might even object that this thing is a quiver at all!

The next simplest possible quiver has one vertex and no edges.