惯性聚合 高效追踪和阅读你感兴趣的博客、新闻、科技资讯
阅读原文 在惯性聚合中打开

推荐订阅源

freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More
Threat Intelligence Blog | Flashpoint
Threat Intelligence Blog | Flashpoint
E
Exploit-DB.com RSS Feed
Application and Cybersecurity Blog
Application and Cybersecurity Blog
Forbes - Security
Forbes - Security
W
WeLiveSecurity
N
News | PayPal Newsroom
cs.CV updates on arXiv.org
cs.CV updates on arXiv.org
T
Threat Research - Cisco Blogs
MyScale Blog
MyScale Blog
美团技术团队
Recent Announcements
Recent Announcements
Cloudbric
Cloudbric
T
Tenable Blog
钛媒体:引领未来商业与生活新知
钛媒体:引领未来商业与生活新知
CTFtime.org: upcoming CTF events
CTFtime.org: upcoming CTF events
C
Cisco Blogs
P
Palo Alto Networks Blog
Google Online Security Blog
Google Online Security Blog
Schneier on Security
Schneier on Security
N
Netflix TechBlog - Medium
Project Zero
Project Zero
The Hacker News
The Hacker News
aimingoo的专栏
aimingoo的专栏
P
Privacy International News Feed
S
Security Affairs
SecWiki News
SecWiki News
AI
AI
Engineering at Meta
Engineering at Meta
AWS News Blog
AWS News Blog
Latest news
Latest news
I
Intezer
云风的 BLOG
云风的 BLOG
The Register - Security
The Register - Security
Martin Fowler
Martin Fowler
PCI Perspectives
PCI Perspectives
V
Visual Studio Blog
cs.CL updates on arXiv.org
cs.CL updates on arXiv.org
Jina AI
Jina AI
Know Your Adversary
Know Your Adversary
Scott Helme
Scott Helme
NISL@THU
NISL@THU
C
Cyber Attacks, Cyber Crime and Cyber Security
爱范儿
爱范儿
F
Full Disclosure
博客园_首页
H
Hackread – Cybersecurity News, Data Breaches, AI and More
博客园 - Franky
J
Java Code Geeks
Y
Y Combinator Blog

Hacker News

Introducing Claude Opus 4.7 Qwen Studio The Future of Everything is Lies, I Guess: Where Do We Go From Here? GitHub - SeanFDZ/macmind: Single-layer transformer in HyperTalk for the classic Macintosh Show HN: Agent-cache – Multi-tier LLM/tool/session caching for Valkey and Redis Ancient DNA reveals pervasive directional selection across West Eurasia [pdf] Moving a large-scale metrics pipeline from StatsD to OpenTelemetry / Prometheus GitHub - Nightmare-Eclipse/RedSun: The Red Sun vulnerability repository GitHub - SethPyle376/hiraeth: Local AWS emulator focused on fast integration testing, with SQS support, SQLite-backed state, and a debug-friendly web UI. GitHub - macOS26/Agent: Any AI, replaces Claude Code, Cursor, OpenClaw. Over 18 LLM providers (Claude, OpenAI, Gemini, Ollama, Zai, HF, Qwen) wired into a native Mac app that writes code, builds Xcode projects, bumps versions, manages git, automates Safari, use AppleScript, JS or Accessibility, extend Agent! w/ MCP Servers, run tasks from your iPhone via Messages. YouTube now lets you turn off Shorts I Made a Terminal Pager Burgers | マクドナルド公式 Commands — HackerNews CLI documentation ChatGPT for Excel PiCore - Raspberry Pi Port of Tiny Core Linux Live Nation illegally monopolized ticketing market, jury finds Google Broke Its Promise to Me. Now ICE Has My Data. Founding Engineer at Adaptional | Y Combinator CRISPR takes important step toward silencing Down syndrome’s extra chromosome GitHub - saffron-health/libretto: The AI toolkit for building reliable browser automations US v. Heppner (S.D.N.Y. 2026) no attorney-client privilege for AI chats [pdf] Unexpected €54k billing spike in 13 hours: Firebase browser key without API restrictions used for Gemini requests Retrofitting JIT Compilers into C Interpreters IPv6 – Google The Accursèd Alphabetical Clock Cybersecurity Looks Like Proof of Work Now Fragments: April 14 Cal.com Goes Closed Source: Why AI Security Is Forcing Our Decision | Cal.com - Scheduling Software for Online Bookings Laravel raised money and now injects ads directly into your agent When moving fast, talking is the first thing to break Too much Discussion of the XOR swap trick – Heather Cafe Introduction to Spherical Harmonics for Graphics Programmers The Grand Line Building a Z-Machine in the worst possible language High-Level Rust: Getting 80% of the Benefits with 20% of the Pain GitHub - duguyue100/midnight-captain: Inspired by Midnight Commander, tailored to my taste. How to build a `git diff` driver · Jamie Tanna | Software Engineer Center for Responsible, Decentralized Intelligence at Berkeley The Local Universe’s Expansion Rate Is Clearer Than Ever, but Still Doesn’t Add Up - A new synthesis of astronomical measurements confirms a persistent mismatch that could point to physics beyond current models The air throughout our homes is infused with microplastics. But there are things you can do to breathe less of them The disturbing white paper Red Hat is trying to erase from the internet – OSnews The Future of Everything is Lies, I Guess: Annoyances ‘Abhorrent’: the inside story of the Polymarket gamblers betting millions on war Productive procrastination — Max van IJsselmuiden maps, territory and LMs 447 Terabytes per Square Centimetre at Zero Retention Energy: Non-Volatile Memory at the Atomic Scale on Fluorographane Show HN: Pardonned.com – A searchable database of US Pardons 20 Years on AWS and Never Not My Job The Seasons are Wrong Artemis II crew splashes down near San Diego after historic moon mission We gave an AI a 3 year retail lease in SF and asked it to make a profit | Andon Labs How a dancer with ALS used brainwaves to perform live On filing the corners off my MacBooks Installing every* Firefox extension OpenClaw’s memory is unreliable, and you don’t know when it will break Steve Blank Nowhere Is Safe Chimpanzees in Uganda locked in vicious 'civil war', say researchers watgo - a WebAssembly Toolkit for Go linux/Documentation/process/coding-assistants.rst at master · torvalds/linux GitHub - callumlocke/json-formatter: Makes JSON easy to read. Founding Product Engineer at Bild AI | Y Combinator A compelling title that is cryptic enough to get you to take action on it GitHub - Keychron/Keychron-Keyboards-Hardware-Design: Industrial design files for Keychron keyboards and mice. 100+ models with CAD assets in STEP, DXF, DWG, and PDF. Source-available, with commercial use allowed for original compatible accessories within the license terms. [ANNOUNCE] WireGuardNT v0.11 and WireGuard for Windows v0.6 Released 1D-Chess Helium Is Hard to Replace Cooperative Vectors Introduction | Evolve Keeping a Postgres queue healthy — PlanetScale Our response to the Axios developer tool compromise Do Americans read print books, e-books or audiobooks more? The Zettelkasten Method in Obsidian: A Practical Setup Guide Artemis II Is Competency Porn and We Are Starving For It WeakC4 Flight Viz — Cockpit View A Mexican surveillance giant you’ve never heard of is now watching the U.S. border Surelock: Deadlock-Free Mutexes for Rust RISC-V 101 – what is it and what does it mean for Canonical? | Ubuntu The Problem That Built an Industry How Much Linear Memory Access Is Enough? | Solidean Investigating Split Locks on x86-64 Simplest hash functions Sybilproof reputation mechanisms (2005) [pdf] What is a property? How Complex is my Code? Static code analysis in Kotlin — tools overview Toffoli gates are all you need PGLite evangelism dcmake: a new CMake debugger UI Clojure on Fennel part one: Persistent Data Structures Fragments: April 2 Python Release Python install manager 26.1 The Life and Death of the Book Review - Liberties Bitcoin miners are losing $19,000 on every BTC produced as difficulty drops 7.8% God sleeps in the minerals Building slogbox Apple Silicon and Virtual Machines: Beating the 2 VM Limit Who was “Not Even Wrong” first? Pokemon Evolution Vs Darwinian Evolution The APL Programming Language Source Code
Quivers: a year of linear algebra by drawing arrows
2026-06-10 · via Hacker News

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. Here it is in its full glory:

    A representation of this quiver assigns a vector space to the only vertex and that's it, there are no edges to assign linear maps (aka matrices) to. Asking how a representation of this quiver decomposes as a direct sum is essentially asking when a single vector space can be decomposed as a direct sum.

    Now, one of the first things one learns in a linear algebra course is that any vector space can be decomposed as a direct sum of one-dimensional spaces, which is just a fancy way of saying that any vector space has a basis! In terms of coordinates, direct sum of vector spaces corresponds to just concatenating the coordinate lists, so we could reformulate this as the fact that any list of numbers is a concatenation of single-element lists.

    So, this quiver has only a single indecomposable representation, which assigns a 1-dimensional vector space (i.e. \(\mathbb{R}^1\)) to the only vertex of the quiver. Any representation (which is just a vector space) decomposes as a sum of copies of this representation (aka any vector space has a basis). The number of terms in this decomposition is simply the dimension of the vector space

    Thus, the first few lectures of a linear algebra course are secretly about classifying representations of this quiver!

    The \(\bullet\rightarrow\bullet\) quiver

    The next quiver we'll look at has two vertices and just one arrow between them:

    As we've discussed before, a representation of this quiver is just any linear operator (i.e. any matrix), together with the source and destination vector spaces that this operator maps from/to. The question now is: up to a change of basis (both in the source and the destination vector spaces), what is the simplest way of representing a matrix in block-diagonal form?

    Or, in terms of matrices, given our (not necessarily square!) matrix \(A\), can we find invertible square matrices \(P\) and \(Q\) such that \(P^{-1}AQ\) looks as simple as possible?

    Indeed, we can! This is called \(LU\) decomposition (or better \(LDU\) decomposition), or Gauss elimination, or just the basic method of solving systems of linear equations!

    Specifically, after applying the Gauss method, you've applied invertible transformations for rows/columns of your matrix (which is equivalent to multiplying it from the right/left by invertible square matrices — that's our change of basis), and you're left with a matrix that looks something like

    \[ \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix} \]

    i.e. the first \(K\) elements of the diagonal are ones, the rest of the diagonal is filled with zeros, and everything else is filled with zeroes as well.

    In terms of basis vectors, this can be interpreted in the following way: we can choose a basis in the source vector space, and a basis in the destination vector space, such that

    • First \(K\) source basis vectors are mapped to the first \(K\) destination basis vectors, corresponding to the upper-left \(K\times K\) corner of this matrix (this number is called the rank of a matrix; these destination basis vectors form the image of the matrix, also known as the column space)
    • The remaining source basis vectors are mapped to the zero vector in the destination space, they correspond to the zero columns on the right of the matrix (these vectors form the kernel of this operator)
    • The remaining desination vectors cannot be obtained by applying this operator, they correspond to the zero rows on the bottom of the matrix (these vectors form the cokernel of this matrix)

    Paraphrasing this in terms of quiver representations, our quiver has exactly 3 indecomposable representations:

    • The \(\mathbb{R}\xrightarrow{1}\mathbb{R}\) representation that maps a 1-dimensional space to a 1-dimensional space via the identity matrix
    • The \(\mathbb{R}\rightarrow 0\) representation that maps all vectors of a 1-dimensional space into the zero vector of a 0-dimensional vector space
    • The \(0\rightarrow\mathbb{R}\) representation that simply embeds a 0-dimensional space into a 1-dimensional space

    NB: the 0-dimensional space is a vector space that contains the zero vector and nothing else. In terms of coordinates, it corresponds to an empty list of coordinates. It's weird, but immensely useful in general context, much like the number 0.

    Any representation of this quiver can be decomposed into a sum of copies of these 3 representations: one \(\mathbb{R}\rightarrow\mathbb{R}\) for each \(1\) on the diagonal (after Gauss elimination!), one \(\mathbb{R}\rightarrow 0\) for each zero column, and one \(0\rightarrow\mathbb{R}\) for each zero row.

    So, the representation theory of this quiver boils down to the fact that Gauss elimination can decompose any matrix into a direct sum of these three forms above, which is what a typical linear algebra course secretly covers somewhere in the middle :)

    The two quivers we've covered so far are the only ones in this post that have a finite number of indecomposable representations. This can be traced to Gabriel's theorem which states that the only such quivers are those whose underlying graph fits the ADE classification. Specifically, the \(\bullet\) and the \(\bullet\rightarrow\bullet\) quivers correspond to the \(A_1\) and \(A_2\) Dynkin diagrams.

    The \(\bullet\style{display: inline-block; transform: rotate(-90deg)}{\circlearrowleft}\) quiver

    You might think that a quiver with one vertex must be simpler than with two vertices, but there's a catch: since there's only one vertex, we have only one vector space, and we can only choose one basis! So we actually have less freedom in this case, and the emerging theory is more complicated.

    Here's our quiver:

    Recall that its representations are just square matrices, or operators acting on some vector space. Notice that in this case the source and destination spaces are forced to coincide, meaning we can only choose one basis to drive this matrix into some simpler form. In terms of matrices, we want to find an invertible \(P\) such that

    \[ P^{-1}AP \]

    has the simplest possible form. Notice that, unlike in the previous section, here that's the same matrix \(P\) on both sides!

    This problem is famously solved using eigenvalues and the Jordan normal form: any square matrix can be turned into block-diagonal form with blocks that look like

    \[ \begin{pmatrix} \lambda & 1 & 0 & 0 \\ 0 & \lambda & 1 & 0 \\ 0 & 0 & \lambda & 1 \\ 0 & 0 & 0 & \lambda \end{pmatrix} \]

    where \(\lambda\) is an eigenvalue of our matrix.

    Note that the eigenvalues can be complex, in which case the matrix and the basis vectors might be complex as well. The situation is a bit more complicated if we disallow this; e.g. we have to incorporate \(2\times 2\) rotation matrices corresponding to the complex eigenvalues.

    For this quiver, the indecomposable representations are classified by the real number \(\lambda\) and a positive integer \(N\): such a representation is an \(N\times N\) Jordan block with \(\lambda\) on the diagonal. In particular, there's an infinite number of indecomposable representations!

    So, once again, the representation theory of this quiver is something that's typically covered by a linear algebra course, probably somewhere in the second semester.

    The \(\bullet\rightrightarrows\bullet\) quiver

    Now, this is something that goes beyond a typical linear algebra course. The quiver is

    and its representations are just pairs of matrices between the same two vector spaces. We can choose the basis in the source vector space however we like, and the same goes for the destination space, but now we have two matrices that we want to decompose together, simultaneously. This makes the problem much harder!

    But not wildly harder: the classification is known as the Kronecker Canonical Form. It's a bit involved, you can read here in more detail if you're interested. It typically classifies something called a matrix stencil, which is just a name for a linear matrix-valued polynomial in one variable, i.e. an expression like \(A+Bx\) where \(A\) and \(B\) are matrices (though there's often a minus sign \(A-Bx\) for historical reasons). However, this is more or less equivalent to just classifying pairs of matrices \((A,B)\) under simultaneously changing the source and destination bases, i.e. we want the two matrices

    \[ P^{-1}AQ \quad P^{-1}BQ \]

    to have the simplest possible form.

    Although much less well-known, this stuff shows up routinely in control theory! And once again it can be seen as an instance of representation theory of quivers :)

    The \(\style{display: inline-block; transform: rotate(90deg)}{\circlearrowright}\bullet\style{display: inline-block; transform: rotate(-90deg)}{\circlearrowright}\) quiver

    This is the crown jewel of this post. Look at this absolute unit:

    Like in the previous example, we have two matrices \(A\) and \(B\), but they are square, and they map from some vector space to the same space. We can only choose one basis, so we're interested in finding an invertible matrix \(P\) such that

    \[ P^{-1}AP \quad P^{-1}BP \]

    look as simple as possible.

    This problem, and any problem that boils down to this problem, is called wild. It is believed that this problem is hopelessly difficult, to the point that a complete classification is so bizzarely complicated that it's mostly useless. In fact, it has been shown that such a classification would include the classification of all possible finite-dimensional algebras, which in my opinion is really, really wild.

    Conclusion

    So, quiver representations can represent things from the very basics of linear algebra to extremely advanced unsolvable problems. Kinda neat, isn't it? I hope you enjoyed it, too :)

    I hate writing conclusion sections. It feels like I'm in 7th grade, writing some boring essay. But it feels weirdly unfinished without it :/