Simple objects and finite-length categories

Let $\mathcal C$ be an abelian category. A nonzero object $S$ is simple if its only subobjects are $0$ and $S$. An object $X$ has finite length if it admits a composition series

\[\label{eq:composition-series} 0=X_0\subset X_1\subset\cdots\subset X_n=X\]

whose successive quotients $X_i/X_{i-1}$ are simple. The Jordan–Hölder theorem states that their isomorphism classes and multiplicities do not depend on the chosen composition series; see (Etingof et al., 2015; §1.5).

A $k$-linear abelian category is locally finite if its Hom spaces are finite-dimensional and every object has finite length (Etingof et al., 2015; Definition 1.8.1). A $k$-linear abelian category is finite if it is equivalent to the category of finite-dimensional modules over a finite-dimensional $k$-algebra. Equivalently, it is locally finite, has enough projectives, and has only finitely many isomorphism classes of simple objects (Etingof et al., 2015; Definitions 1.8.5–1.8.6). Thus every finite abelian category is locally finite and has only finitely many simple isomorphism classes. Indeed, if $\mathcal C\simeq A\text{-mod}$ for a finite-dimensional $k$-algebra $A$, then every simple object occurs as a composition factor of the regular $A$-module. In particular, $\operatorname{Rep}_k(G)$ is finite when $G$ is a finite group, since $kG$ is finite-dimensional.

Simple composition factors are subquotients. They need not be subobjects or direct summands. In particular, a nonsplit extension of two simple objects has two composition factors without being their direct sum. This distinction is especially visible in positive characteristic.

The interface

The predicates is_locally_finite(C) and is_finite(C) record these two properties. The generic implications reflect the definitions: a finite category is locally finite, and a locally finite category is linear, abelian, additive, and Krull–Schmidt. As for all structural predicates, a false result may mean only that the property has not been established by the implementation.

Within a finite-length category, an implementation may provide the following computational functions. They are optional capabilities rather than part of the axioms of an abelian or finite category:

None of these computations follows from the abstract abelian or finite-length interface. Testing whether an object is simple, finding its composition factors or simple subobjects, and enumerating all simple objects are generally difficult problems that require algorithms specific to the category and its coefficient field. These capabilities are therefore implemented separately. For finite-group representations, these operations are available over many coefficient fields; their precise scope and backend selection are documented on the representation-category inventory page.

Example: Modular group representations

For a finite group $G$ and a field $k$, finite-dimensional $k$-representations form a finite abelian category: they are the finite-dimensional modules over the finite-dimensional group algebra $kG$. In particular, every such representation has finite length. The example below tests simplicity and computes composition factors with the specialized finite-group representation implementation.

Let $G=C_5$ and $k=\mathbb F_5$. The matrix

\[\label{eq:modular-jordan-block} J=\begin{pmatrix}1&1\\0&1\end{pmatrix}\]

satisfies $J^5=1$ in characteristic $5$ and therefore defines a two-dimensional representation of $C_5$. It is a nonsplit self-extension of the trivial representation.

using TensorCategories, Oscar
F = GF(5)
G = cyclic_group(5)
C = representation_category(F, G)
J = matrix(F, [1 1; 0 1])
X = Representation(C, gens(G), [J]; check=true)

@assert is_finite(C) && is_locally_finite(C)
@assert J^5 == identity_matrix(F, 2)
@assert !is_simple(X)
factors = composition_factors(X)
@assert length(factors) == 1
S, multiplicity = only(factors)
@assert is_simple(S) && multiplicity == 2
(int_dim(X), int_dim(S), multiplicity)

(2, 1, 2)

Although both composition factors are trivial, $X$ is not their direct sum. Its simple subobject belongs to the socle, and its simple quotient belongs to the top. Neither splits off as a direct summand:

socle_types = simple_subobjects(X)
@assert length(socle_types) == 1
S = only(socle_types)
inclusions = basis(Hom(S, X))
projections = basis(Hom(X, S))
@assert length(inclusions) == 1 && length(projections) == 1
@assert is_zero(only(projections) ∘ only(inclusions))

This example shows why composition factors and direct-sum decompositions need separate interfaces. We discuss direct summands next.

Continue with idempotents and direct-sum decompositions.