Review of Existing Libraries

The data structures will ultimately dictate the algorithms we can use, so we want to choose them carefully. How do existing libraries for computational invariant theory, such as Magma, SageMath, and Singular, represent groups, group actions, and invariants? I took a quick look (mostly not that helpful) at the documentation and source code for these libraries to get a sense of how they approach these problems.

Data Structure Implementations

How ought we design our data structures? We want to be able to represent different types of groups (finite, classical, reductive) and their actions on different types of structured sets (vector spaces, affine varieties, etc). We also want to be able to represent the invariants themselves, which are usually polynomials or rational functions, as well as the relations among them, presentations, etc. Furthermore, I want to follow my minimalist, compositional style.

class Poly:

    Type = dict[tuple[int, ...], Fraction]

    @staticmethod
    def add(f, g): ...
    @staticmethod
    def mul(f, g): ...
    @staticmethod
    def scale(c, f): ...
    @staticmethod
    def evaluate(f, point) -> Fraction: ...

    # -- Constructors --
    @staticmethod
    def mono(alpha, c=1): ...       
    @staticmethod
    def var(i, n_vars): ...          
    @staticmethod
    def const(value, n_vars): ...    

    # -- Leading term operations --
    @staticmethod
    def leading_monomial(f, order=grlex): ...
    @staticmethod
    def leading_coefficient(f, order=grlex) -> Fraction: ...

    # -- Monomial operations (for Gröbner bases) --
    @staticmethod
    def mono_divides(a, b) -> bool: ...   
    @staticmethod
    def mono_lcm(a, b): ...               
    @staticmethod
    def mono_mul(a, b): ...               
    @staticmethod
    def mono_div(a, b): ...               

    # -- Orderings --
    @staticmethod
    def grlex(alpha):
        """Graded lexicographic: total degree first, then lex."""
        return (sum(alpha), alpha)

    @staticmethod
    def elimination_order(k):
        """Orders the variables so that x_0,...,x_{k-1} are ordered before the remaining variables. For Gröbner elimination."""
        def order(alpha):
            return (alpha[:k], sum(alpha[k:]), alpha[k:])
        return order

f = {(2, 1, 0): Fraction(3), (0, 3, 0): Fraction(-1), (0, 0, 0): Fraction(7)}

class Group:
    def identity(self):
        raise NotImplementedError

    def multiply(self, g, h):
        raise NotImplementedError

    def inverse(self, g):
        raise NotImplementedError

class GroupAction:
    def act(self, g, x):
        """Apply group element g to object x."""
        raise NotImplementedError

@dataclass(frozen=True)
class Action:
    """Bundle of closures encoding a (group, space) invariant theory problem."""
    is_invariant:        Callable[[Poly], bool]
    invariants_of_degree: Callable[[int], list[Poly]]
    hilbert_coeffs:      Callable[[int], list[int]] | None = None
    orbit_test:          Callable | None = None
    apply_element:       Callable | None = None
    elements:            Callable | None = None
    n_vars:              int = 0

def invariant_theory(group, space) -> Action:
    """Assemble an Action from a group and a space descriptor."""
    return group.action(space)

class Torus:
    def __init__(self, W: np.ndarray):
        self.W = np.asarray(W, dtype=int)
        self.rank = self.W.shape[0]
        self.n_vars = self.W.shape[1]

    def is_invariant_monomial(self, alpha: tuple[int, ...]) -> bool:
        return np.all(self.W @ np.array(alpha, dtype=int) == 0)

    def hilbert_basis(self, max_degree: int = 20) -> list[tuple[int, ...]]:
        ...

class FiniteGroup:
    def __init__(self, matrices: list[np.ndarray]):
        self.matrices = matrices
        self.order = len(matrices)
        self.n_vars = matrices[0].shape[0]

    def reynolds(self, f: Poly) -> Poly:
        total: Poly = {}
        for g in self.matrices:
            total = poly.add(total, self.apply_to_poly(g, f))
        return poly.scale(Fraction(1, self.order), total)

    def orbit_sum(self, f: Poly) -> Poly:
        seen = set()
        total: Poly = {}
        for g in self.matrices:
            gf = self.apply_to_poly(g, f)
            key = frozenset(gf.items())
            if key not in seen:
                seen.add(key)
                total = poly.add(total, gf)
        return total

    def molien_coeffs(self, max_d: int) -> list[int]:
        ...

def symmetric(n: int) -> FiniteGroup:
    """S_n acting on C^n by permutation matrices."""
    ...

def cyclic(n: int, dim: int = 2) -> FiniteGroup:
    """Z/nZ acting on C^dim by rotation."""
    ...

def dihedral(n: int) -> FiniteGroup:
    """D_n acting on C^2 by rotations and reflections."""
    ...

def orthogonal_action(n: int, k: int) -> Action:
    """O(n) acting diagonally on k copies of C^n.
    Generators: inner products <v_i, v_j>."""
    ...

def sl_action(n: int, k: int) -> Action:
    """SL(n) acting diagonally on k copies of C^n.
    Generators: n x n bracket determinants."""
    ...

def symplectic_action(n: int, k: int) -> Action:
    """Sp(2n) acting diagonally on k copies of C^{2n}.
    Generators: symplectic pairings omega(v_i, v_j)."""
    ...

Spaces

We need to encode how the group action affects the vector space the group acts on. For polynomials:

@dataclass(frozen=True)
class Space:
    n_vars: int
    apply_matrix: Callable  
    add: Callable
    scale: Callable
    zero: Callable

def polynomial_ring(n_vars: int) -> Space:
    """Standard polynomial ring C[x_0, ..., x_{n-1}]"""
    ...

Since the space is defined separately, the algorithms can be group-agnostic. The Reynolds operator and orbit sums in FiniteGroup use space.add, space.scale, and space.apply_matrix rather than calling polynomial arithmetic directly. So we can extend this library to work on new object types by implementing new space descriptors with the appropriate operations without adjusting the group classes or derived API.

Decision Problems

In these types of problems, we are checking an input for some property, and the output is a boolean.

def is_invariant(action: Action, f: Poly) -> bool: ...

def is_invariant(action: Action, x) -> bool: ...  # same interface, different object types via Space

def in_null_cone(action: Action, v: np.ndarray, max_degree: int = 6) -> bool: ...

Construction Problems

These operations attempt to compute explicit invariants or structured generating data for the invariant ring.

def compute_generators(action: Action, max_degree: int) -> list[Poly]: ...

def compute_primary_secondary(action: Action, max_degree: int) -> tuple[list[Poly], list[Poly]]: ...

def compute_separating_invariants(action: Action, max_degree: int) -> list[Poly]: ...

Structural Computations

These operations try to understand the algebraic structure of the invariant ring once invariants have been found.

def compute_hilbert_series(action: Action, max_degree: int) -> list[int]: ...

def is_cohen_macaulay(invariant_ring) -> bool: ...
def is_gorenstein(invariant_ring) -> bool: ...
def is_complete_intersection(invariant_ring) -> bool: ...

Presentation Computations

These operations try to find explicit presentations of the invariant ring in terms of generators and relations.

def compute_relations(generators: list[Poly], n_vars: int) -> list[Poly]: ...

def compute_syzygies(relations: list[Poly]) -> list[Poly]: ...  

def normal_form(f: Poly, basis: list[Poly]) -> Poly: ...
def in_ideal(f: Poly, basis: list[Poly]) -> bool: ...

Quotient and Orbit Computations

These operations try to compute the geometry of the quotient space and the orbits of a group action.

def same_orbit(action: Action, v: np.ndarray, u: np.ndarray) -> bool: ...

def find_separator(action: Action, v: np.ndarray, u: np.ndarray, max_degree: int = 6) -> Poly | None: ...

Example Workflow

Now that we know the types of computations we want to perform, we can outline the workflow we might use to actually compute invariants for a specific group action. This will help us understand how the different computational tasks fit together in practice.

Probably the sequence looks something like this:

1. Encode the group action and the structured object in our data structure.
2. Compute Hilbert/Molien data for the action to understand the structure of the invariant ring.
3. Search for candidate generators for the invariant ring, using the Hilbert series to guide our search.
4. Compute relations by Gröbner elimination to find a presentation of the invariant ring.

Once we have the presentation, we can use it to gain understanding of the object:

5. Test ideal membership and compute normal forms. Given a polynomial , determine whether it lies in the ideal of relations (equivalently: can it be written in terms of the generators?). The normal form gives a canonical representative.
6. Compute structural properties of the invariant ring, such as whether it is Cohen-Macaulay, Gorenstein, or a complete intersection.
7. Compute syzygies and higher-order relations among the generators.
8. Compute separating invariants and solve orbit-separation problems.
9. Compute primary and secondary invariants, and understand the module structure of the invariant ring over a polynomial subring.

More advanced computations (which we may or may not do here) might include:

11. Compute the “Krull dimension” of the invariant ring. This is the number of algebraically independent generators, equal to . It tells you the dimension of the quotient variety .
12. Compute degree bounds. For finite groups in characteristic zero, all generators appear by degree (Noether’s bound). The Hilbert series predicts how many generators to expect in each degree before computing them, giving a stopping criterion.

The generators and relations also determine the geometry of the quotient (its defining equations, dimension, and singularities), but that is algebraic geometry proper, and we won’t pursue it here.

An example program putting this all together might look like this:

import numpy as np
from invariants.groups.constructors import symmetric
from invariants.spaces import polynomial_ring
from invariants.action import (
    invariant_theory, compute_generators,
    compute_hilbert_series, in_null_cone, same_orbit,
)
from invariants.groebner import compute_relations

# 1. Encode the group action
G = symmetric(3)
ring = polynomial_ring(3)
action = invariant_theory(G, ring)

# 2. Hilbert series: how many invariants in each degree?
hs = compute_hilbert_series(action, 6)
# [1, 1, 2, 3, 4, 5, 7]

# 3. Find generators
generators = compute_generators(action, max_degree=3)
# [x0+x1+x2, x0^2+x1^2+x2^2, x0^3+x1^3+x2^3]

# 4. Relations among generators (Gröbner elimination)
relations = compute_relations(generators, n_vars=3)
# [] — S_3 invariant ring is freely generated

# 5. Orbit and quotient geometry
v = np.array([1.0, 2.0, 3.0])
u = np.array([3.0, 1.0, 2.0])
same_orbit(action, v, u)                    # True — same multiset
in_null_cone(action, np.array([0, 0, 0]))   # True — all invariants vanish at origin

For this particular example, the outputs look something like this:

Hilbert series: [1, 1, 2, 3, 4, 5, 7]
Generators (3): [x0+x1+x2, x0^2+x1^2+x2^2, x0^3+x1^3+x2^3]
Relations: 0 (freely generated)
Same orbit (1,2,3) ~ (3,1,2): True
In null cone (0,0,0): True

Introduction to Tori

Let’s define the torus and its action on a vector space.

An element of is therefore a tuple

and multiplication is componentwise.

Proof: See this StackExchange post here, which shows that the action is diagonalizable.

The group law forces these scalar functions to behave multiplicatively. So

implies

so

Thus each is a group homomorphism.

Integer Linear Algebra of Invariants

So each basis vector comes with a character , and under the right basis, the action is of the form

Because

every character is given by a monomial in the torus coordinates:

for some integers

These integers are called the weights of the action. So after choosing this basis, the torus action can be written as

If we write a vector

then

So a torus action is encoded by a list of integer weight vectors

or equivalently by an integer matrix of weights.

Now let

denote the coordinates corresponding to the basis

Since each basis vector is scaled by a weight, the coordinates transform by

where

Now take a monomial

Then the torus acts on it by

Substituting in the weight formula gives

So the monomial is again scaled by a single weight (the “total weight” of the monomial):

If we assemble the weight vectors into a matrix

then the total weight can be written as

Thus

It follows that the monomial is invariant if and only if its total weight is zero:

So to find invariant monomials, just have to solve the integer linear system

subject to the constraint that the exponents are nonnegative integers:

So the exponent vectors of invariant monomials form the set

This is a semigroup under addition, and the invariant ring is generated by the corresponding monomials.

Implementation

What do our data structures and computational tasks look like in the case of a torus action? Let’s take an (abbreviated) look.

class Torus:
    """Torus T = (C*)^r acting on C^m via weight matrix W."""

    def __init__(self, W: np.ndarray):
        self.W = np.asarray(W, dtype=int)
        self.rank = self.W.shape[0]
        self.n_vars = self.W.shape[1]

    def monomial_weight(self, alpha: tuple[int, ...]) -> np.ndarray:
        """Total weight W @ alpha of monomial x^alpha."""
        return self.W @ np.array(alpha, dtype=int)

    def is_invariant_monomial(self, alpha: tuple[int, ...]) -> bool:
        return np.all(self.monomial_weight(alpha) == 0)

    def is_invariant(self, f: Poly) -> bool:
        """A polynomial is torus-invariant iff every monomial has weight zero."""
        return all(self.is_invariant_monomial(alpha) for alpha in f)

    def invariants_of_degree(self, d: int) -> list[Poly]:
        """Basis of invariant monomials of degree d."""
        return [
            poly.mono(alpha)
            for alpha in poly.monomials_of_degree(self.n_vars, d)
            if self.is_invariant_monomial(alpha)
        ]

    def hilbert_coeffs(self, max_d: int) -> list[int]:
        """Number of invariant monomials in each degree."""
        return [len(self.invariants_of_degree(d)) for d in range(max_d + 1)]

    def hilbert_basis(self, max_degree: int = 20) -> list[tuple[int, ...]]:
        """Minimal generators of the semigroup ker(W) ∩ N^m.
        """
        all_inv = []
        for d in range(1, max_degree + 1):
            for alpha in poly.monomials_of_degree(self.n_vars, d):
                if self.is_invariant_monomial(alpha):
                    all_inv.append(alpha)

        inv_set = set(all_inv)
        generators = []
        for alpha in all_inv:
            a = np.array(alpha)
            is_reducible = any(
                np.all(a - np.array(beta) >= 0)
                and np.any(a - np.array(beta) > 0)
                and tuple(a - np.array(beta)) in inv_set
                for beta in generators
            )
            if not is_reducible:
                generators.append(alpha)
        return generators

T = Torus(np.array([[1, 1, -2]]))

# Hilbert series: count invariant monomials by degree
T.hilbert_coeffs(6)    # [1, 0, 0, 3, 0, 0, 5]

# Hilbert basis: minimal generators of the invariant semigroup
T.hilbert_basis()      # [(2, 0, 1), (1, 1, 1), (0, 2, 1)]
# These correspond to x0^2*x2, x0*x1*x2, x1^2*x2

Relations

Now that we have the three generators, we can ask about the relations among them.

In the example above, there are three generators , , , which satisfy the relation .

It makes sense that there is one relation, as the space has dimension 3 and the torus has dimension 1, so the quotient has dimension 3 - 1 = 2. With 3 generators being mapped to a 2-dimensional space, we expect 3 - 2 = 1 relation among them.

How can we find these relations? We need Gröbner elimination.

As a general introduction, introduce new variables (one per generator), form the ideal in the extended ring , and eliminate . The surviving polynomials in are the relations among the generators. In this case, we find the relation .

from invariants.groebner import compute_relations
from invariants.poly import format_poly

generators = [poly.mono(a) for a in T.hilbert_basis()]
relations = compute_relations(generators, n_vars=3)
# One relation: y0*y2 - y1^2

Let’s understand Grobner elimination more deeply in the next section.

Buchberger’s Algorithm

Define the S-polynomial of two polynomials and as:

The algorithm proceeds as follows:

We can think of this as similar to Gaussian elimination. In Gaussian elimination, we perform row operations on linear equations:

and so on, eliminating each variable in turn. In Buchberger’s algorithm, we perform similar operations on polynomials to eliminate leading terms and find a Gröbner basis.

As an example, suppose we have the ideal generated by the polynomials and . Impose an ordering on the monomials ().

The leading terms are and . The least common multiple of the leading terms is . Since and , multiply the first polynomial by and the second by to get:

Now subtract the second from the first (this is where the S-polynomial comes from):

If we fix the maximum degree of the polynomials we want to consider in addition to the ordering, we can even use a matrix representation of the polynomials and perform Gaussian elimination on the coefficients to find the Gröbner basis. Essentially, we’ve replaced the notion of “leading term” with the notion of “leading monomial” in the context of polynomials (by constructing some symbols that represent each monomial), and we perform operations to eliminate these leading monomials until we have a basis that allows us to rewrite any polynomial in the ideal in a unique way.

The primary gotcha is that in Buchberger’s algorithm, we can end up with polynomials of a higher degree than the original generators, which can lead to combinatorial explosion. This is one of the main computational challenges in using Gröbner bases for invariant theory.

Here’s what this looks like in our Python code:

def s_poly(f: Poly, g: Poly, order=poly.grlex) -> Poly:
    """S-polynomial of f and g"""
    lm_f = poly.leading_monomial(f, order)
    lm_g = poly.leading_monomial(g, order)
    lc_f = poly.leading_coefficient(f, order)
    lc_g = poly.leading_coefficient(g, order)
    gamma = poly.mono_lcm(lm_f, lm_g)
    t_f = poly.mono(poly.mono_div(gamma, lm_f), Fraction(1) / lc_f)
    t_g = poly.mono(poly.mono_div(gamma, lm_g), Fraction(1) / lc_g)
    return poly.sub(poly.mul(t_f, f), poly.mul(t_g, g))

def buchberger(F: list[Poly], order=poly.grlex) -> list[Poly]:
    """Compute a reduced Gröbner basis for the ideal generated by F."""
    G = [g for g in F if g]
    if not G:
        return []
    pairs = [(i, j) for i in range(len(G)) for j in range(i + 1, len(G))]
    while pairs:
        i, j = pairs.pop(0)
        sp = s_poly(G[i], G[j], order)
        r = reduce(sp, G, order)
        if r:
            k = len(G)
            pairs.extend((m, k) for m in range(k))
            G.append(r)
    return _reduce_basis(G, order)

Key Operations

Using Grobner bases, we can perform several key reusable functions that are essential for computational invariant theory.

def reduce(f: Poly, G: list[Poly], order=poly.grlex) -> Poly:
    """Reduce f modulo G by repeated leading-term cancellation.
    Returns the remainder (normal form if G is a Groebner basis).
    """
    r: Poly = {}
    p = dict(f)
    while p:
        reduced = False
        for g in G:
            if not g:
                continue
            lm_g = poly.leading_monomial(g, order)
            lc_g = poly.leading_coefficient(g, order)
            for alpha in sorted(p.keys(), key=order, reverse=True):
                if poly.mono_divides(lm_g, alpha):
                    quot_mono = poly.mono_div(alpha, lm_g)
                    quot_coeff = p[alpha] / lc_g
                    shift = poly.mul(poly.mono(quot_mono, quot_coeff), g)
                    p = poly.sub(p, shift)
                    reduced = True
                    break
            if reduced:
                break
        if not reduced:
            if p:
                lm_p = poly.leading_monomial(p, order)
                lc_p = p[lm_p]
                r = poly.add(r, poly.mono(lm_p, lc_p))
                del p[lm_p]
    return r

def normal_form(f: Poly, basis: list[Poly], order=poly.grlex) -> Poly:
    """Normal form of f with respect to a Gröbner basis."""
    return reduce(f, basis, order)

def in_ideal(f: Poly, basis: list[Poly], order=poly.grlex) -> bool:
    """Test whether f belongs to the ideal generated by basis."""
    return not normal_form(f, basis, order)

def ideal_intersection(F: list[Poly], G: list[Poly], n_vars: int) -> list[Poly]:
    """Intersection of ideals I = (F) and J = (G).

    Introduces variable t, forms (t*f_i, (1-t)*g_j), eliminates t.
    """
    t_var = poly.var(0, n_vars + 1)
    one_minus_t = poly.sub(poly.const(1, n_vars + 1), t_var)

    def embed(f: Poly) -> Poly:
        return {(0,) + alpha: c for alpha, c in f.items()}

    gens = [poly.mul(t_var, embed(f)) for f in F]
    gens += [poly.mul(one_minus_t, embed(g)) for g in G]

    elim = eliminate(gens, k=1, n_vars=n_vars + 1)
    return [{alpha[1:]: c for alpha, c in g.items()} for g in elim]

I = [poly.mono((2, 0)), poly.var(1, 2)]   # (x^2, y)
J = [poly.var(0, 2), poly.mono((0, 2))]   # (x, y^2)

result = ideal_intersection(I, J, n_vars=2)
# [x^2, xy, y^2]

def eliminate(generators: list[Poly], k: int, n_vars: int) -> list[Poly]:
    """Eliminate the first k variables.

    Computes a Gröbner basis with an elimination ordering that pushes
    x_0, ..., x_{k-1} to the top, then returns only the polynomials
    that live in k[x_k, ..., x_{n-1}].
    """
    order = poly.elimination_order(k)
    gb = buchberger(generators, order)
    return [g for g in gb if _involves_only(g, k, n_vars)]

def compute_relations(generators: list[Poly], n_vars: int,
                      order=poly.grlex) -> list[Poly]:
    """Compute relations among polynomial generators.

    Given generators g_1, ..., g_s in k[x_0, ..., x_{n-1}], introduce
    new variables y_0, ..., y_{s-1} and compute the kernel of the map
    k[y_0, ..., y_{s-1}] -> k[x_0, ..., x_{n-1}] sending y_i -> g_i.
    """
    s = len(generators)
    total_vars = n_vars + s

    # embed each g_i into k[x_0,...,x_{n-1}, y_0,...,y_{s-1}]
    elim_gens = []
    for i, g in enumerate(generators):
        y_alpha = (0,) * n_vars + tuple(1 if j == i else 0 for j in range(s))
        yi = poly.mono(y_alpha)
        g_emb: Poly = {}
        for alpha, c in g.items():
            new_alpha = alpha + (0,) * s
            g_emb[new_alpha] = c
        elim_gens.append(poly.sub(yi, g_emb))

    # eliminate x_0, ..., x_{n-1}
    elim_order = poly.elimination_order(n_vars)
    gb = buchberger(elim_gens, elim_order)

    # keep only polynomials in k[y_0, ..., y_{s-1}]
    return [g for g in gb if _involves_only(g, n_vars, total_vars)]

def compute_syzygies(generators: list[Poly], n_vars: int,
                     order=poly.grlex) -> list[Poly]:
    """Compute syzygies among generators of an ideal.

    For each pair (i,j), if the S-polynomial reduces to zero,
    record the corresponding syzygy in k[x, e_0, ..., e_{s-1}].
    """
    s = len(generators)
    syzygies = []
    for i in range(s):
        for j in range(i + 1, s):
            fi, fj = generators[i], generators[j]
            if not fi or not fj:
                continue
            sp = s_poly(fi, fj, order)
            if not reduce(sp, generators, order):
                # Build syzygy: (lcm/LT(fi))/lc_i * e_i - (lcm/LT(fj))/lc_j * e_j
                lm_i = poly.leading_monomial(fi, order)
                lm_j = poly.leading_monomial(fj, order)
                gamma = poly.mono_lcm(lm_i, lm_j)
                qi = poly.mono_div(gamma, lm_i)
                qj = poly.mono_div(gamma, lm_j)
                lc_i = poly.leading_coefficient(fi, order)
                lc_j = poly.leading_coefficient(fj, order)
                # encode in k[x_0,...,x_{n-1}, e_0,...,e_{s-1}]
                ei = tuple(1 if k == i else 0 for k in range(s))
                ej = tuple(1 if k == j else 0 for k in range(s))
                syz = poly.sub(
                    poly.mono(qi + ei, Fraction(1) / lc_i),
                    poly.mono(qj + ej, Fraction(1) / lc_j),
                )
                syzygies.append(syz)
    return syzygies

# Example: syzygies of (x, y) in k[x,y]
# Returns y*e_0 - x*e_1, i.e., y*x - x*y = 0

def hilbert_function(basis: list[Poly], n_vars: int, max_d: int,
                     order=poly.grlex) -> list[int]:
    """Hilbert function of k[x]/I from degree 0 to max_d.

    Counts monomials of each degree not divisible by any leading
    monomial of the Gröbner basis.
    """
    leading_monomials = [poly.leading_monomial(g, order) for g in basis if g]
    result = []
    for d in range(max_d + 1):
        count = 0
        for alpha in poly.monomials_of_degree(n_vars, d):
            if not any(poly.mono_divides(lm, alpha) for lm in leading_monomials):
                count += 1
        result.append(count)
    return result

# Example: GB of (x^2 + y - 1, xy + 1) has LT ideal (x^2, xy, y^2)
# Hilbert function: [1, 2, 0, 0, ...] — quotient is 3-dimensional

def has_common_root(basis: list[Poly], order=poly.grlex) -> bool:
    """Test whether V(I) is nonempty.

    By the Nullstellensatz, V(I) = {} iff 1 ∈ I iff GB = {1}.
    """
    gb = buchberger(basis, order)
    for g in gb:
        if all(e == 0 for e in poly.leading_monomial(g, order)):
            return False  # 1 ∈ I, no common root
    return True

# Example: has_common_root([x, 1-x]) returns False (no solution)

Reynolds Operator

In the last post, we saw that for certain kinds of groups (like finite groups) acting on vector spaces , we could define the Reynolds operator, which is an idempotent operator that takes any polynomial and averages over the group action to produce an invariant polynomial:

If we have a polynomial that is not invariant, applying the Reynolds operator will give us an invariant polynomial.

Recall that we represented a finite group as a list of matrices that act on the variables. To apply the Reynolds operator, we can take any polynomial and apply each group element to it by substituting the linear forms corresponding to the group action. Then we average these transformed polynomials to get an invariant.

Start with a set of polynomials that generate the polynomial ring and apply the Reynolds operator to each of these polynomials to project them onto the invariant ring. This will give us a set of invariant polynomials, which may generate the invariant ring or at least give us a starting point for finding generators.

Let’s implement the Reynolds operator in code, which involves summing over the group elements and applying the group action to the polynomial. While computationally expensive for large groups, it’s a straightforward way to find invariants.

The key subroutine is apply_to_poly. Given a matrix and a polynomial , we compute by substituting linear forms for each variable. Reynolds then just averages over all group elements.

def apply_to_poly(self, g: np.ndarray, f: Poly) -> Poly:
    """(g · f)(x) = f(g^{-1} x) via variable substitution."""
    g_inv = np.linalg.inv(g)
    n = self.n_vars
    sub_polys = []
    for i in range(n):
        row: Poly = {}
        for j in range(n):
            c = Fraction(g_inv[i, j]).limit_denominator(10**9)
            if c != 0:
                row[tuple(1 if k == j else 0 for k in range(n))] = c
        sub_polys.append(row)

    result: Poly = {}
    for alpha, coeff in f.items():
        term = poly.const(coeff, n)
        for i, e in enumerate(alpha):
            for _ in range(e):
                term = poly.mul(term, sub_polys[i])
        result = poly.add(result, term)
    return result

def reynolds(self, f: Poly) -> Poly:
    """Reynolds operator: R(f) = (1/|G|) sum_{g in G} g · f."""
    total: Poly = {}
    for g in self.matrices:
        total = poly.add(total, self.apply_to_poly(g, f))
    return poly.scale(Fraction(1, self.order), total)

For example, take acting on by permuting coordinates. The monomial is not invariant (permutations move it to or ). Applying Reynolds averages over all 6 permutations:

G = symmetric(3)
f = poly.mono((2, 0, 0))          
Rf = G.reynolds(f)
# Rf = 1/3*x0^2 + 1/3*x1^2 + 1/3*x2^2

assert G.is_invariant(Rf)          # True
assert G.reynolds(Rf) == Rf        # idempotent: R(R(f)) = R(f)

The output is the power sum , which is obviously symmetric. Note that Reynolds is idempotent, so applying it to an already-invariant polynomial returns the same polynomial.

Orbit Sums

Reynolds averaging is a special case of a more general construction called orbit sums. Given a polynomial , we can consider the orbit of under the group action:

The orbit sum is the sum of all elements in the orbit:

This is similar to the Reynolds operator, but without the normalization factor of .

Since the orbit sum is just the sum of elements in the orbit, and orbits are invariant under the group action (since the summands are just permuted), the orbit sum is also invariant under the group action.

That is, for any :

For degree polynomials, this works cleanly when the action sends monomials to monomials (for example permutation actions): then the invariance condition forces the coefficients to be constant on monomial orbits, so every homogeneous invariant is a linear combination of orbit sums. For a general linear action, orbit sums of monomials are better viewed as a convenient source of candidate invariants than as a general basis theorem.

So in the monomial/permutation cases, the orbit sums of monomials form a basis for the space of homogeneous invariants of degree . This gives us a way to find a basis for the invariant ring degree by degree in those cases.

In code, we can implement this as follows:

def orbit_sum(self, f: Poly) -> Poly:
    """Sum over distinct images of f under G."""
    seen = set()
    total: Poly = {}
    for g in self.matrices:
        gf = self.apply_to_poly(g, f)
        key = frozenset(gf.items())
        if key not in seen:
            seen.add(key)
            total = poly.add(total, gf)
    return total

def invariants_of_degree(self, d: int) -> list[Poly]:
    """Degree-d invariants via orbit sums of monomials."""
    seen_orbits: set[frozenset] = set()
    basis = []
    for alpha in poly.monomials_of_degree(self.n_vars, d):
        f = poly.mono(alpha)
        orbit_key = frozenset(
            frozenset(self.apply_to_poly(g, f).items())
            for g in self.matrices
        )
        if orbit_key not in seen_orbits:
            seen_orbits.add(orbit_key)
            os = self.orbit_sum(f)
            if os:
                basis.append(os)
    return basis

The orbit_sum method tracks which images have already been seen (via frozenset of the polynomial’s items) to avoid double-counting when the stabilizer of is nontrivial. The invariants_of_degree method groups monomials by orbit, computes one orbit sum per orbit, and collects them as a basis.

Continuing with on , the degree-2 monomials are . Under , these fall into two orbits: and . The orbit sums give two linearly independent degree-2 invariants:

G = symmetric(3)

# Orbit sum of x0^2: hits x0^2, x1^2, x2^2
G.orbit_sum(poly.mono((2, 0, 0)))
# x0^2 + x1^2 + x2^2

# Orbit sum of x0*x1: hits x0*x1, x0*x2, x1*x2
G.orbit_sum(poly.mono((1, 1, 0)))
# x0*x1 + x0*x2 + x1*x2

# All degree-2 invariants at once
G.invariants_of_degree(2)
# [x0^2 + x1^2 + x2^2, x0*x1 + x0*x2 + x1*x2]

These are the power sum and the elementary symmetric polynomial .

Molien Series

Since the Reynolds operator projects onto the invariant ring, we know that

(since the trace of a projection operator is the dimension of its image¹).

Thus we can compute the trace as follows:

Since is the space of homogeneous degree polynomials, we can identify it with the -th symmetric power of the dual space :

The trace of on can be computed using the eigenvalues of on . If the eigenvalues of on are , then the trace of on is given by the complete homogeneous symmetric polynomial of degree in the eigenvalues:

The generating function for the complete homogeneous symmetric polynomials is given by²:

This motivates the Molien formula for the Hilbert series of the invariant ring³:

To use the Molien formula computationally, we expand as a power series in for each group element . Since where are the eigenvalues of , the series expansion is a convolution of geometric series. We truncate at degree max_d, sum over all group elements, divide by , and round to the nearest integer (the result is exact for rational eigenvalues; rounding handles floating-point eigenvalues from rotation matrices).

def molien_coeffs(self, max_d: int) -> list[int]:
    """Molien series: H(t) = (1/|G|) sum_{g in G} 1/det(I - tg)."""
    coeffs = np.zeros(max_d + 1, dtype=complex)
    for g in self.matrices:
        eigenvalues = np.linalg.eigvals(g)
        # Expand 1/prod(1 - lambda_i * t) as power series
        series = np.zeros(max_d + 1, dtype=complex)
        series[0] = 1.0
        for lam in eigenvalues:
            powers = np.array([lam**d for d in range(max_d + 1)])
            new_series = np.zeros(max_d + 1, dtype=complex)
            for d in range(max_d + 1):
                new_series[d] = sum(series[k] * powers[d - k]
                                    for k in range(d + 1))
            series = new_series
        coeffs += series
    return [round((coeffs[d] / self.order).real)
            for d in range(max_d + 1)]

For on , the group has 6 elements.

The identity has eigenvalues , contributing .

The transpositions have eigenvalues , contributing .

The 3-cycles have eigenvalues where , contributing .

Averaging over all 6 elements:

which simplifies to :

So the invariant ring is a polynomial ring in three generators of degrees 1, 2, 3 (the power sums ). Verify numerically:

G = symmetric(3)
G.molien_coeffs(10)
# [1, 1, 2, 3, 4, 5, 7, 8, 10, 12, 14]

If we expanded as a power series, we would get the same coefficients, confirming that the Molien series correctly predicts the dimensions of the invariant ring in each degree.

Noether Bound

The Molien series gives us the dimensions of the graded pieces of the invariant ring, which tells us how many invariants we should expect in each degree. The orbit sums give us explicit invariants to fill those dimensions. But how do we know the search terminates?

Proof: See Fleischmann, “The Noether Bound in Invariant Theory of Finite Groups,” Advances in Mathematics 156 (2000), which also proves the sharper bound for non-cyclic groups.

In practice, this means we can search for generators by calling invariants_of_degree(d) for and be guaranteed to find them all.

For with , we only need to check up to degree 6 (and in fact all three generators appear by degree 3).

Practical Issues

There’s some practical problems with the computational approach. The main computational bottleneck for finite groups is apply_to_poly, which substitutes linear forms for each variable. For a polynomial with terms in variables, each group element costs polynomial multiplications. Summing over all elements, the total cost of Reynolds or orbit sums is . For with , this becomes infeasible quickly.

Orbit sums (a bit) cheaper than Reynolds since they avoid the normalization (keeping coefficients as integers) and deduplicate images. The effective cost is proportional to the orbit size rather than .

The Molien series is cheap by comparison, as it only requires eigenvalue computations () with no polynomial arithmetic.

So probably we compute the Hilbert series first, then use it as a guide to say how many generators to expect in each degree, then do the relatively expensive orbit sum computation.

I’m not gonna try to optimize all these algorithms in this post, I’m still learning how it works myself. But in practice, for large groups, I assume we could optimize the apply_to_poly method, maybe by caching intermediate results or using better data structures for polynomials.

Homogeneous Systems of Parameters (HSOP)

Before we can define primary and secondary invariants, we need to introduce the notion of a homogeneous system of parameters (HSOP), which help understand the structure of graded rings.

For finite groups, we can always find an HSOP consisting of algebraically independent homogeneous invariants. In general, finding an HSOP can be more difficult. In the settings we care about here, the issue is not existence so much as actually finding one.

The point of a HSOP is that it gives us subring of the invariant ring that is “simple” to understand, and we can then study the structure of the full invariant ring as a module over this polynomial subring.

Also note that the HSOP isn’t unique necessarily.

To find an HSOP, we can use a greedy process to collect invariants. In practice, we look for invariants that appear algebraically independent and then do additional checks:

from invariants.action import find_hsop, find_secondaries, primary_secondary

# S_3 on C^3
G = symmetric(3)
action = invariant_theory(G, polynomial_ring(3))
hsop = find_hsop(action, 4)
# [x0+x1+x2, x0^2+x1^2+x2^2, x0^3+x1^3+x2^3]

As an example, we can look at . The invariant ring is polynomial on three generators, and we can take the three power sums , , . So they form an HSOP.

Cohen–Macaulay

Given we have an HSOP , and we know that is finitely generated as a module over , we can ask about the structure of this module. In the best cases, the invariant ring is a free module over the polynomial subring generated by the HSOP, which means it can be written uniquely as a direct sum of copies of the polynomial subring:

so every element can be written

This is the Cohen-Macaulay property. It’s not necessarily true for all invariant rings. We could instead have nontrivial relations among the such as:

Proof. See Hochster and Roberts.⁴

Computing Primary and Secondary Invariants

When the Cohen-Macaulay property holds, we call the HSOP elements primary invariants, and the module generators secondary invariants. The primary invariants generate a polynomial subring, and the secondary invariants fill in the remainder.

Computationally, this compresses the problem. Instead of searching for all generators of , we can first find an HSOP and then loop through the degrees to find secondary invariants using the Hilbert series (which tells us how many per degree).

For on , the invariant ring is polynomial, so the only secondary invariant is :

primaries, secondaries = primary_secondary(action, 4)
# primaries: [x0+x1+x2, x0^2+x1^2+x2^2, x0^3+x1^3+x2^3]
# secondaries: [1]
# k[V]^G = 1 · k[p1, p2, p3]  — free module of rank 1

A more interesting example. Consider acting on by . The invariant ring is with relation , so it is not a polynomial ring:

from invariants.groups.finite import FiniteGroup
G_z2 = FiniteGroup([np.eye(2), -np.eye(2)])
action_z2 = invariant_theory(G_z2, polynomial_ring(2))

primaries_z2, secondaries_z2 = primary_secondary(action_z2, 4)
# primaries: [x0^2, x1^2]
# secondaries: [1, x0*x1]
# k[V]^G = 1 · k[x^2, y^2] (direct_sum) xy · k[x^2, y^2]  — free module of rank 2

Here we have two secondary invariants, and . So we know every invariant can be written uniquely as . The generator isn’t expressible as a polynomial in the primary invariants , but the full ring is still a free module over , as guaranteed by Hochster-Roberts.

We can go further and consider the degree-4 invariants. Under , a monomial is invariant iff is even (i.e. the entire monomial is of even degree), so the degree-4 invariants are all the even-degree monomials in and : . Each decomposes:

So every invariant can be written as either or .

Molien-Weyl Formula

Before moving on, how would we compute these?

We would need a Hilbert series for continuous groups. Luckily, the Molien formula generalizes. For a compact group acting on , the Hilbert series is

where is the Haar measure. This is over an infinite group, but the Weyl integration formula reduces it to an integral over the “maximal torus” :

where is the (finite) “Weyl group” and is the “Weyl denominator” (whatever those are). The torus integral becomes a Laurent polynomial residue computation.

The point is, computing the Hilbert series for a compact Lie group reduces to a torus computation plus a finite group average.

In practice, since we know the generators, we can just compute the Hilbert series by counting monomials in those generators.

The Orthogonal Group

Consider acting diagonally on copies of . We represent this with variables, organized as vectors of length . The First Fundamental Theorem says the invariant ring is generated by all inner products .

There are generators (the inner products are symmetric: ), all of degree 2 in the original variables. Degree- invariants come from degree- polynomials in these generators (so only the even degrees have invariants).

from invariants.classical import orthogonal_action

# O(3) acting on 2 copies of C^3 (6 variables)
action = orthogonal_action(n=3, k=2)

# Generators: <v1,v1>, <v1,v2>, <v2,v2>  — 3 inner products
gens = action.invariants_of_degree(2)
# [x0^2+x1^2+x2^2, x0*x3+x1*x4+x2*x5, x3^2+x4^2+x5^2]

As an example, label the 6 variables as and . The three generators are:

Every -invariant polynomial in the 6 variables is a polynomial in these three inner products.

If we extended to degree-4 invariants, we would have the 6 products of pairs:

Intuitively, this makes sense, as preserves angles and lengths. The only way to get an invariant is to combine the inner products such that the orientation of the vectors is immaterial.

and Bracket Invariants

Now consider acting on copies of . The generators are all minors, which are determinants formed by choosing of the vectors. For , these are the brackets (we showed this in the previous post).

There are generators, each of degree in the original variables. When , there are no invariants at all (since you can’t form an determinant from less than vectors).

from invariants.classical import sl_action

# SL(2) acting on 3 copies of C^2 (6 variables)
action = sl_action(n=2, k=3)

# Generators: [12], [13], [23]  — 3 brackets
gens = action.invariants_of_degree(2)
# [x0*x3 - x1*x2, x0*x5 - x1*x4, x2*x5 - x3*x4]

As an example, we have three vectors in : , , . Each bracket is a determinant:

These are “signed areas” of the parallelograms spanned by pairs of vectors.

Intuitively, preserves areas (since it has determinant 1), so the signed areas are invariant.

With 3 vectors, there are brackets and no relations among them, meaning that the invariant ring is freely generated.

The Second Fundamental Theorem (also in the previous post) gives us the relations between them, called the Plücker relations. For on 4 vectors, the single relation is . We can now verify this in code:

from invariants.groebner import compute_relations

# SL(2) on 4 copies of C^2: 6 brackets, 1 Plücker relation
action4 = sl_action(n=2, k=4)
gens4 = action4.invariants_of_degree(2)
relations = compute_relations(gens4, n_vars=8)
# One relation: y0*y5 - y1*y4 + y2*y3  (the Plücker relation)

With 4 vectors we would get brackets: , , , , , . However, these are not algebraically independent.

Expanding the Plücker relation by hand:

Everything cancels out. The invariant ring is . The Gröbner computation in compute_relations rediscovers exactly this.

Symplectic and Other Classical Groups

The same pattern works for acting on copies of , where the generators are the symplectic pairings . This is essentially identical to the orthogonal case, but with an antisymmetric bilinear form rather than a symmetric one.

The Quotient Map

Suppose we have the generators of the invariant ring . Then the quotient map is given by evaluating these generators at each point. That is, if are generators of , then we can use them to define a map:

from invariants.orbits import quotient_map, same_image
from invariants import poly

# S_3 generators: power sums p1, p2, p3
p1 = poly.add(poly.add(poly.var(0, 3), poly.var(1, 3)), poly.var(2, 3))
p2 = poly.add(poly.add(poly.mono((2,0,0)), poly.mono((0,2,0))), poly.mono((0,0,2)))
p3 = poly.add(poly.add(poly.mono((3,0,0)), poly.mono((0,3,0))), poly.mono((0,0,3)))
gens = [p1, p2, p3]

# Same orbit => same image
quotient_map(gens, (1, 2, 3))  # [6, 14, 36]
quotient_map(gens, (3, 1, 2))  # [6, 14, 36]
same_image(gens, (1, 2, 3), (3, 1, 2))  # True

# Different orbits => different image
same_image(gens, (1, 2, 3), (1, 1, 4))  # False

In this example, we are looking at the action of on by permuting coordinates. The generators of the invariant ring are the power sums , which we established earlier as , , and .

The quotient map evaluates these invariants at a point. For points in the same orbit (like and ), we get the same image under the quotient map. For points in different orbits (like and ), we get different images.

How do we interpret these images?

For , we have: - - -

However, for , we have: - - -

So these points do not lie in the same orbit, as they have different images under the quotient map. The invariants are able to distinguish these orbits.

And, as we can tell by inspection, there is no way to permute the coordinates of to get , confirming that they are indeed in different orbits.

Orbit Separation

In the finite-group case, when two points are in different orbits, we can find a specific invariant that witnesses this:

from invariants.orbits import find_separator

sep = find_separator(gens, (1, 2, 3), (1, 1, 4))
poly.show(sep)
# 'x0^2 + x1^2 + x2^2'
# p2(1,2,3) = 14, p2(1,1,4) = 18

For reductive groups, if two orbits are closed and distinct, some polynomial invariant distinguishes them. This is a useful constructive theorem, as it allows us to find explicit invariants that separate orbits and thereby classify objects up to symmetry.

Null Cones

The null cone is the fiber , which is the set of all points that invariants cannot distinguish from the origin.

This is important as all the points in the null cone have orbit closures that contain the origin, so they all collapse to the same point in the quotient.

Testing null cone membership is just evaluating the generators:

from invariants.orbits import in_null_cone

# C* on C^2, weights [1, -1]. Invariant: x0*x1
gen = poly.mono((1, 1))

in_null_cone([gen], (0, 0))   # True — origin
in_null_cone([gen], (1, 0))   # True — coordinate axis
in_null_cone([gen], (0, 5))   # True — coordinate axis
in_null_cone([gen], (1, 1))   # False — generic point
in_null_cone([gen], (2, 3))   # False — generic point

For this example, the null cone is , the union of the two coordinate axes. Geometrically, these are the orbits of that degenerate: , which approaches the origin as . The generic orbits with are closed and do not contain the origin in their closure, so they are not in the null cone.

Separating Invariants

If we have a full generating set for the invariant ring, then we can use it to separate orbits. However, it may be difficult to produce the full set. In practice, we might only need some of the generators to separate orbits. The hope is that the separating set is much smaller than the full generating set.

We can find a minimal separating subset by greedy set cover (there’s probably faster algorithms, especially if we have some structure or are willing to do some random sampling):

from invariants.orbits import is_separating, minimal_separating_subset

# S_3 generators
gens = [p1, p2, p3]  # three power sums

# Test pairs, test points in different S_3 orbits
pairs = [
    ((1, 2, 3), (1, 1, 4)),  # same sum, different orbits
    ((1, 2, 3), (2, 2, 2)),  # same sum, different orbits
    ((1, 0, 0), (0, 0, 2)),  # different sum, easy
]

is_separating(gens, pairs)  # True, so full set works

minimal = minimal_separating_subset(gens, pairs)
# [x0^2 + x1^2 + x2^2] - p2 alone separates all three pairs!

For acting on , the power sum separates these test pairs.

Note that doesn’t separate all orbits (e.g.  and have the same value).

Degree Explosion

The fundamental bottleneck in many cases is degree.

For a finite group acting on , Noether’s bound guarantees generators appear by degree , but the number of monomials in degree is , which grows polynomially in for fixed .

Even for (order 120) acting on , degree 120 has monomials. It’s not practical to use an algorithm like Buchberger’s algorithm on ideals with generators of this degree.

Rational Invariants

A rational invariant is a ratio of polynomials that is invariant under the group action:

Sometimes, when the polynomial invariant ring requires generators of very high degree or has complicated relations, rational invariants require fewer generators with lower degree and simpler relations. The tradeoff is that there could be poles, so we have to work on limited domains. This apparently comes up in non-reductive groups, where the polynomial invariant ring may not be finitely generated but the rational invariant field can be.

I didn’t investigate this too heavily.

Other Techniques

To help scale the library or extend it to new situations, there are a combination of different techniques.

We saw some of these earlier. For example, we saw:

• the Molien formula trick (where we compute the Hilbert series and get a roadmap for how many invariants to expect in each degree)
• using orbit sums instead of the Reynolds operator to avoid the normalization and keep coefficients as integers
• using separating invariants instead of full generating sets to reduce the number of invariants we need to find
• Noether’s bound to limit the search to a finite degree
• for tori, reducing to a combinatorial problem of finding integer solutions to linear equations (the weight decomposition), which is more efficient than Gröbner basis computations

Some techniques we haven’t implemented but are commonly used in practice include:

• using representation theory to decompose the polynomial ring into irreducible representations and extract invariants from the trivial summands, which can be more efficient than brute-force Gröbner basis computations.
• for compact Lie groups, using the Molien-Weyl formula to reduce the problem to an integral over the maximal torus, which can be computed using our existing Torus machinery
• SAGBI bases, a variant of Gröbner bases designed for subalgebras rather than ideals. Where Buchberger’s algorithm answers “is this polynomial in the ideal?”, SAGBI answers “is this polynomial expressible in terms of known generators?”
• Derksen’s algorithm, a general-purpose method that works for any group given by matrix generators, without needing to know anything about the group’s structure. It reduces invariant computation to a single (expensive) Gröbner basis calculation.

Some of these techniques are in Derksen and Kemper’s book, and some are in the research literature. This post is too long, but I may come back to them.

Representations

We often suppress and write for . Convention refers to as a “representation of ” ( by itself is just a vector space. Technically “a representation” means the map , but since is usually fixed, sometimes it is labelled by the target space).

A subrepresentation of (with action ) is a subspace such that for all , we have ( is closed under the action of ).

It’s worth noting that if we choose a basis for , each can be associated with an invertible matrix. The representation is then a map , where . The choice of basis is unique up to conjugation by an element of , so the representation is really a homomorphism into up to conjugation.

Irreducibility and Complete Reducibility

In other words, a representation is completely reducible if every vector in can be uniquely written as a sum of vectors from the various ’s.

As an example, consider the action of on , where permutes coordinates.

Schur’s Lemma

The same group can act on different vector spaces in different ways. Each such action is a representation. Schur’s lemma tells us what maps between two such representations can look like.

This should remind you of our earlier exploration of equivariance. The idea is that the representation “commutes” with the action of .

Proof.

(1): If , then , and so the kernel is an invariant subspace of . By irreducibility is either or , as those are the only subspaces of .

Similarly, the image is an invariant subspace of , so it is either or . If and , then is an isomorphism. Otherwise .

(2): Consider the map .

Since is algebraically closed, the polynomial has at least one root. So the kernel of this map is nontrivial.

Since we have , the map is equivariant.

Since is equivariant and is irreducible, by part (1) it must be zero or an isomorphism. Since the kernel is nontrivial, is zero. So .

Schur’s lemma constrains maps between irreducible representations. The space of equivariant maps is zero if or one-dimensional if . So given some representation , the projection of onto it decomposition (by projecting it onto each irreducible summand) is unique (up to scaling).

Basically, the combination of irreducibility and the group structure reduces linear algebra to scalar algebra, which is why representation theory is so powerful for reductive groups.

Symmetric Powers

Let us now apply some of these ideas to the specific case of binary forms. We want to understand how acts on the space of binary forms of degree . We’ll use instead of to remove the determinant factor, which will make things simpler.

If with basis and coordinates , then has basis and dimension .

Basically, this is just another set of notation for the space of binary forms of degree .

If acts on (one representation), this induces a different action of on (a new representation, on a bigger space) by:

This is exactly the action of on binary forms that we have been studying.

Finite Groups

Let’s start by considering a slightly more abstract problem. We have a group acting on a vector space , and we want to find the subspace of that is invariant under the action of . That is, we want to find the set of vectors such that for all , .

If we want to produce a polynomial that is invariant under a group , one idea is to average (or sum) over all possible transformations. For a finite group, we can simply sum:

The average is invariant. For any ,

What’s happened? The map is a bijection on (its inverse is ), and so we are summing the same terms in a different order. Applying to every term in the sum just permutes the terms.

What’s more, if some is already invariant, then . This is because for all , so the sum just gives us copies of , which we then divide by to get back .

The above operation is called the Reynolds operator, and it is a linear projection from onto the subspace of -invariant vectors.

Conjugation and Equivariance

If is a linear map from to itself, then we can define an action of on by conjugation:

Since for all , if and only if , it’s also true is -equivariant if and only if for all . So the space of -equivariant maps from to itself is exactly the space of maps that are invariant under conjugation by .

This will motivate the construction of the Reynolds operator in the proof of Maschke’s theorem, where we will average over the group to produce a -equivariant projection.

Maschke’s Theorem for Finite Groups

Proof.

We want to show that decomposes as a direct sum of irreducible representations. It suffices to show that for any subrepresentation , there is a complementary subrepresentation such that . If this is true, then we can apply the same argument to and to find complementary subrepresentations, and so on, until we have decomposed into irreducible representations.

Let be a representation of , and let be a subrepresentation that is closed under action of .

Choose a linear map such that is stable under action by (that is, and for all ). This works by standard linear algebra since we assumed finite dimensions.

Each acts as a linear map . Then we can define a new projection (by averaging over the group):

This new projection is -equivariant, since for any we have

(Note that if divides , then we cannot divide by and this construction fails, which is why the condition on the characteristic is necessary).

Since is invariant under the conjugation action of , then is -equivariant.

We know that the image of is , since for all , and for all . So the kernel of is a complementary subrepresentation to . By induction on the dimension of , we can decompose into irreducible subrepresentations.

Essentially, we have taken our complements from ordinary linear algebra and equipped them with -equivariance.

Compact Groups

Sadly, is not a finite group, so we can’t just sum over all transformations. However, we can still try an analogous trick. Instead of summing, we could integrate.

When does the Reynolds operator exist for continuous groups? We need a measure to integrate over a continuous group such that no “region” of the group is weighted more than any other. If we had such a measure , then we could define the Reynolds operator as

for some measure on the group . Then for any :

Luckily for us, in 1933, Haar proved that every compact group has such a measure, and that it is essentially unique³.

How can we construct a Haar measure? If we assume that the group is also smooth (i.e. it is Lie group), then the we can concretely construct the Haar measure. In fact, there is an “algorithm” to do so⁴:

The construction is as follows:

1. Parametrize the group: write each element as
2. Compute the Maurer-Cartan form
3. Expand in a basis of the Lie algebra:
4. The Haar measure is

For , we can parametrize by , then compute

and the Haar measure is (to normalize the total measure to 1).

We’ll probably explicitly write code for this when we look at computational invariant theory, but the key point is that for compact groups, we can construct a Reynolds operator by integrating over the group with respect to the Haar measure. This allows us to compute invariants and covariants for compact groups.

Reductive Groups

Unfortunately, is also noncompact. This means that the group is not bounded, and so we cannot integrate over it in a way that gives us a finite result. The integral can diverge.

To see this, we can decompose a linear transformation in as follows (using the Iwasawa decomposition):

The entries are unbounded. So we can try to integrate over the group by integrating over , but the integrals over and could diverge.

However, GL(2) is reductive, which means that it has a nice representation theory that allows us to compute the invariants and covariants without needing to integrate. I cover the relevant representation theory above.

Proof. If is reductive, then by definition every representation is completely reducible. In particular, each graded piece (which in this case are the polynomials of degree ) decomposes as a direct sum of irreducible representations, one of which is the invariant subspace . The invariant subspace is the sum of all copies of the trivial representation in this decomposition (since that’s where for all ). Complete reducibility guarantees that this summand has a complement and that the projection onto it is unique. Applied degree by degree, this projection is just the Reynolds operator. We will also see later (once we have the Hilbert basis theorem) that this is enough to guarantee that the invariant ring is finitely generated.

The reductive groups have been completely classified⁵. They include all finite groups, compact Lie groups, and , , , over characteristic zero. I won’t go into the details here. It will suffice for our purpose to simply know that we can check the list to see if a given group is reductive or not⁶. See below for the details on .

Nonreductive Groups

What if GL(2) was non-reductive? Hilbert’s 14th problem asked whether the invariant ring of a linear group action on a polynomial ring is always finitely generated.

For non-reductive groups, the answer is no. In 1959, Nagata constructed an explicit counterexample (showing an action of on a polynomial ring that has an invariant ring requiring infinitely many generators).

So we can’t necessarily use representation theory to compute the invariants, and the Reynolds operator might not exist. In fact, the invariant ring may not even be finitely generated.

Based on a Claude-based survey, it seems there are a few options in these cases, which I’ll presumably examine in the future⁹.

Overall Flow

If we look back at what we did to compute the invariants, we can see that we basically followed a process:

1. We have some polynomial ring¹⁰ over field of characteristic zero¹¹ and a group¹² action on . We want the invariant ring .
2. Is the group finite? If so, we can compute the invariants by summing over the group (Reynolds operator).
3. Is the group infinite, but compact? If so, we can compute the invariants by integrating over the group with respect to the Haar measure (Reynolds operator). Constructing the Haar measure depends on the topology of :
   1. If is continuous, then it is a Lie group¹³, and we can construct the Haar measure explicitly via the Maurer-Cartan form (as we did above for ).
   2. If is totally disconnected (e.g. profinite groups, -adic analytic groups like ), the Haar measure still exists but the construction is more difficult¹⁴.
4. Is the group noncompact but reductive¹⁵? If so, a Reynolds operator exists, but the actual computation uses representation theory to identify the equivariant projections directly.
   
5. Is the group non-reductive? If so, there is no general method. However, idiosyncratic methods exist for specific cases.

Our example flows down to Step 4. The unitarian trick gives us a Reynolds operator by integrating over , and representation theory (Clebsch-Gordan) tells us the result is exactly the transvectant calculus.

In all cases where a Reynolds operator exists (steps 2–4), the general algorithm for finding generators is to use the Molien series to count how many invariants to expect in each degree, apply to produce candidates, use Grobner bases to test algebraic independence, and finally stop when the Molien series terminates. Each of these steps requires theoretical justification, which we’ll look at in the next section.

This overall process is handy for computational approaches, where we encode these algorithms as code. Probably we will mostly deal with finite or compact groups, but it’s good to have the general picture in mind.

Finding All Invariants

To prove that we have found all the invariants for a given transformation acting on a object, we need to show that the process terminates (i.e. it does not produce an infinite sequence of new invariants) and that it is complete (i.e. it produces all the invariants).

We’ll continue to look at the example of binary forms, but the same questions apply to any group action on any object.

Noetherian Rings

We need to first introduce the concept of a Noetherian ring¹⁶.

An ideal of a ring is a subset that is closed under addition and under multiplication by any element of : if and , then for any , and . An ideal is finitely generated if there exist finitely many elements such that every element of can be written as for some .

Fields, like or , are Noetherian, since their only ideals are and itself, both finitely generated.

Hilbert’s Basis Theorem

Now we are ready to state Hilbert’s Basis Theorem, which is the key result that allows us to conclude that the invariant ring of a group action on a polynomial ring is finitely generated.

Proof.

Fix an ideal .

If is not finitely generated, then we can construct an infinite sequence by choosing each to be an element of minimal degree in . By construction, the degrees are non-decreasing.

Let be the corresponding leading coefficient for each . Since is Noetherian, the ideal generated by these leading coefficients, , is finitely generated. Therefore, there exists some such that, for all , we have .

So for all , we can write for some set of , where .

The leading term of each can be written for some degree . Let be the smallest degree for which there exists a polynomial in not already in . Since , the degree of must be at least .

Since is a linear combination of , we can linearly combine the leading terms of to get a leading term

We can subtract this linear combination from to get a new polynomial of lower degree. If we repeat this process a finite number of times, we can eventually get a polynomial that has degree less than .

So we can write as a linear combination of plus a remainder polynomial of degree less than :

But we said that is the smallest degree not contained in the ideal generated by . Since has degree less than , it must be contained in the ideal generated by . So is contained in the ideal generated by .

This is a contradiction. Therefore, every ideal of is finitely generated, and is Noetherian.

Conceptually, we just did long division over and over again, and the Noetherian condition guaranteed that this process terminated after finitely many steps.

Generators

What are the relations between the generators? This question (for binary forms) is answered by the Second Fundamental Theorem, which gives a complete description of the syzygies (relations) between the generators of the invariant ring.

Syzygies

We know from the First Fundamental Theorem that transvectants generate all the covariants. But the generators are not algebraically independent. They have relations between them called syzygies.

So a syzygy is a polynomial relation among the generators of the invariant ring. The set of all syzygies forms an ideal in the polynomial ring , called the syzygy ideal.

Since the syzygy ideal is itself an ideal over , we can continue to iterate this process. The relations between the generators of the syzygy ideal are called second-order syzygies, and so on. Does this process terminate?

Hilbert’s Syzygy Theorem

Proof.

Omitted. A full proof of Hilbert’s Syzygy Theorem requires too much machinery that is beyond the scope of this blog post (Grobner bases, free resolutions of modules). See Cox–Little–O’Shea, Ideals, Varieties, and Algorithms, Chapter 10 for an “algorithmic” approach, or a homological algebra text.

The intuition is that each variable provides one independent “direction” in which cancellations can occur. After using up all variables, there are no new directions left for higher syzygies to appear. In other words, there are only finitely many levels of syzygies, and we can find all of them in a finite amount of time.

I tried to look for a more elementary proof, but I couldn’t find one.

Note that this also extends to modules over (e.g. the module of covariants).

Geometry

Nullstellensatz

Proof.

Assume vanishes on . We want to show that for some .

Introduce a new variable and consider the ideal

Suppose is a common zero of . Then every polynomial in vanishes at , so . The equation therefore implies . But for every , which is impossible. Therefore has no common zero.

(To see this: if were a proper ideal, it would be contained in some maximal ideal . Then is a field that is finitely generated as a -algebra. But any field finitely generated as an algebra over an algebraically closed field must equal itself (since each generator satisfies a polynomial over , and already contains all roots). So for some point , meaning has a common zero — contradicting what we just showed.)

An ideal with no common zero must contain , so . Thus we can write

where and are polynomials in .

Substitute into this equation. The term becomes zero, so we obtain

This expression may contain denominators coming from . Multiplying both sides by a sufficiently large power clears the denominators and yields

for some polynomials .

Thus .

How do we interpret this?

If we have a set of polynomials that generates an ideal , then the common zeros of are exactly the points where all the polynomials in vanish.

If we have a set of polynomials that vanishes on a set of points , then the ideal generated by those polynomials contains all polynomials that vanish on (up to radicals).

So we can go back and forth between the algebraic relations among the generators and the geometric shape of the solution set.

For invariants theory, consider the map:

This takes each point in and maps it to the tuple of its invariants. Since invariants are constant under action of , this map is constant on orbits of . So is constant along -orbits.

Now, consider

which maps . The kernel of is the ideal of relations among the generators.

By the Nullstellensatz, the satisfy the relations in , and any other relation satisfied by the is a consequence of those in .

So the behave like coordinates on the image of , and the relations in determine the shape of that image. In other words, the algebraic structure of the invariant ring determines the geometry of the orbit space .

So, given some space, we can look at what leaves fixed. If we use those invariants as coordinates, we can get a smaller space that captures the structure of the original space, but with the symmetries “divided out”.

Summary

The three theorems fit together nicely.

• The Basis Theorem tells us the invariant ring is finitely generated, so the orbit space is finite-dimensional.
• The Syzygy Theorem describes the relations among the generators, which determine the shape of .
• The Nullstellensatz says the algebra of the invariant ring gives the geometry of the orbit space, so we can understand the geometry of by understanding the algebra of .

Physical Work

Even if we fully believe that all desktop work will be automated, it will take some time before the human hand and body are replaced in meatspace. Care work, construction, plumbing, cooking, surgery, massage, sex work, eldercare, childcare, and many other occupations require direct interaction with reality.

Despite some inertia in the current state of affairs, it is expected that human dominance in physical work will merely be a temporary state of affairs. As robotics improves, the set of tasks requiring human bodies shrinks, and will ultimately reduce to a small subset of things that are either too complex, too delicate, or too expensive to automate, and then vanish entirely. In the limit, we’d expect physical work to be fully replaced.

Taste Work

If AI can produce anything, the bottleneck shifts from execution to specification. Can you determine what you want, and if you can, how do you specify it to the machine? This is the taste problem, and it is harder than it seems at first glance, even for a perfect model.

Taste work can be taxonomized into three different operations. The first is creation, which is making a new thing that some group or individual desires (this could be a a director making a blockbuster movie for a huge audience, a musician composing for their specific muse, or a blogger writing for a future version of himself). The next operation is curation, which is putting together lists that adhere to a certain aesthetic or a given quality level. This is done by museum curators when they choose what paintings to hang, by bookstore owners when they choose how to stock their shelves, or by film institutes when they select the quality films. Finally, the last operation is selection, which is choosing one thing from a set of options to apply attention to. This may actually be a long chain of decisions (a “demand chain”). For example, a restaurant might choose which wines to stock, a sommelier may recommend a shortlist, and the restaurant patron ultimately orders a single wine.

AI already provides value in these domains. For example, Spotify playlists, search ranking, and recommendation engines are all AI-driven tools for curation. Generative models can, to some extent, produce novel images, music, and text on demand. Personalized advertising can suade your tastes, partially dictating your personal preferences.

There’s a further distinction worth making: taste-for-others versus taste-for-self. Taste-for-others is about predicting what someone else will like. This is fundamentally a prediction problem, and AI can produce for the masses with enough data.

Taste-for-self is slightly different. You might walk into a restaurant not knowing what you want, read the menu, and then decide on an option (or even order “off-menu”). You might not have been able to communicate what you wanted before you saw the menu. The preference didn’t exist until the moment of contact with the options. Similarly, desires can be very, very particular. There is still more value to be generated by human taste work in the selection of things for ourselves. And the specification cost doesn’t vanish just because generation becomes free¹.

What makes taste work resistant to automation? One issue is that the decision of which selection to make may depend on context that is expensive to formalize, like the room, the audience, the season, the cultural moment, or the specific internal qualia of the recommendee. Another problem is social authority; the value of the sommelier’s recommendation could depend on who is recommending the wine, not just which wine in particular is recommended. There is also the issue of accountability if the decision is wrong.

But above all, the fundamental reason this problem is difficult is that it inherently relies on human communication to and from the machine. The machine can generate a million variations for you to choose from, but it cannot know which one you will like without some kind of highly individualized data elicitation, which is bound by human I/O².

But this is not an inherently unsolvable problem for AI. After a sufficiently long enough data collection and training process, it is possible that AI could develop a model of humans preferences that is good enough to generate things you like without much input from you.

There is still the question of the value that might result from having specific tastes or preferences. For now, it is a human writing, editing, and publishing this essay. But perhaps someday AI could manage the entire process end-to-end, from ideation to research to drafting to editing to formatting to publishing. Then I could read the blog I desire without having to labor to produce it. Would I be “writing” the blog or would I be “reading” it? Would there be a meaningful distinction? My desires would create something that I and others would consume. If others consume it, then my desire is valuable in-and-of-itself. If the purpose of economic activity is to generate value for humans, then helping specify the final outcome of the machine’s production is a valuable activity, even if the machine does all the work.

People may not create value in a post-AI world through unique skills, but through unique desires. Your job isn’t to go to the office, but to go shopping.

Social Status

Status, being ordinal, is inherently rivalrous. In a world of material abundance, social position can still be scarce. In our current world, status is often a byproduct of productive economic contribution. For example, someone can currently increase in status for being a great artist, a brilliant scientist, or a powerful CEO. But in a post-AI world, the link between production and status breaks down. The question is: what will generate status when production no longer does?

Who gets the best land, the most desirable spouse, or the invite to the coolest parties? No amount of AI-driven productivity can manufacture more status, because humans fundamentally desire to rank people. Similarly, conspicuous consumption is not about the underlying quality of the goods but about the signal the goods present. The point of a $10,000 exclusive handbag is that you can’t buy it. Automating handbag production just shifts the status signal to some other arbitrary token.

The underlying scarce resource is attention. Human attention is finite even when everything else is abundant. Status games can be thought of as competitions for the limited bandwidth of other humans. The influencer economy is an intensification of a dynamic that has always existed. In fact, as AI accelerates the supply of content, the demand for attention remains bottlenecked. The result is that capturing attention becomes more valuable relative to producing content.

The post-economy is the post economy. We can already start to see the inversion take place. Likes and views aren’t valuable because they can be converted into money. Instead, money is valuable because it can be converted into likes and views. Eventually, as production drops away, the money itself may become a mere token for attention.

Games

Status games are just one particular type of game. We can generalize this trend to other kinds of games.

Games are voluntary competitions with rules that generate value through the experience of playing and the potential determination of winners or losers (or, at least “good” and “bad” players).

The last section was about social games. “Getting the most likes on Instagram” is a social game. “Having the nicest lawn” is a social game. So are “getting the promotion” and “meeting your KPIs” and “climbing the corporate ladder”. As AI automates more of the actual work, the game aspect may become more central to how people derive value from their careers. Actual economic contribution (“doing the work”) may become less important than how well you play the game of corporate politics, networking, and self-promotion. Maybe this has already happened.

But beyond corporate games, there are board games, card games, video games, sports betting, competitive cooking, debate, trivia, poker, bowling, pickup basketball, fantasy football, speedrunning, competitive eating, and so on. These are all voluntary competitions with some kind of structure and some kind of outcome that can compare performance between the participants.

Games are not necessarily fun, fair or entertaining. They can be stressful, frustrating, and demoralizing. In a post-AI world where production is automated and abundant, games may become a more central mechanism for generating value and allocating scarce resources. They are inherently human-centric and resistant to automation because they rely on human judgment, social interaction, and the experience of playing. Furthermore, they can clearly distinguish winners and losers, which is a key aspect of status generation. The value of winning a game is not just in the outcome but in the process of playing and the social recognition that comes with it.

Consider chess. It is a game with simple rules but infinite complexity. It generates value through the experience of playing, the social recognition of skill, and the narrative of competition. Even if an AI can play chess at a superhuman level (which is already true), the human experience of playing chess and the social recognition that comes with it still generate value. In fact, chess is more popular than ever, with millions of people playing online and watching grandmaster tournaments, even though computers can beat any human player. Even so, two humans can still compete to measure their comparative skill.

Sports

Sports and games are closely related phenomena. In a previous essay, I briefly considered whether sports are art (sometimes). Are sports games? I think the answer is also “sometimes”.

Some sports are clearly games. A football match is a game with rules, players, and an outcome (the thought exercise in the previous section works fine for games with a physical component). On the other hand, some sports are more about performance and spectacle than competition (especially the ones that are “art”).

There is another aspect to sport that is worth mentioning, which is the exploration of the fundamental limits of the human body. The 100m sprint, the marathon, the high jump, the long jump, the pole vault, and many other human activities are endeavors that test the limits of human physical performance (a sort of ontological research into the limits of the human form). They generate value through the aspiration to push those limits further, and through the narrative of human excellence.

It is easy to imagine “automated” sports, but they would be to real sports what professional wrestling is to amateur wrestling: entertaining simulacra, perhaps, but missing part of what makes sport matter. For example, I can imagine completely CGI and AI generated simulacra of sports leagues (marble racing is an example of this). I can even imagine branded simulacra (imagine totally imaginary sports leagues like quidditch or podracing) that procedurally generate the narrative structures of real sports using CGI and AI but without actual participants. While interesting as entertainment, I suspect these will not completely replace “real” sports, which is rooted in the human experience of physical competition and the narrative of human achievement.

Sports are also one of the purest meritocracies remaining. You can buy better equipment, better coaching, better nutrition, but at the elite level, an individual human body is the bottleneck. And to be replaced with a machine means the competitor is no longer “you” in a certain sense. This makes athletic achievement a uniquely legible form of human value, resistant to the usual objections about privilege and access that corrode other status hierarchies.

We can also think of some intellectual achievement as a type of sport. Memorizing the digits of , solving a Rubik’s cube, or doing huge mental calculations are all examples of intellectual sports. Even if the AI can outperform humans in all mathematical domains, humans can still compete in Math olympiads or attempt to understand and prove theorems, not for the purpose of advancing mathematical knowledge, but for the sake of the identifying the limits of human excellence.

And human excellence is limited to pushing the boundaries of the entire human species. Anyone can run against time³.

Performance

Part of the value of games and sports is that they are performances. Performance is a broad category that includes not just games and sports but (as discussed in a previous essay) also to the arts and many other human processes. Human performance is part of the process of relationship formation. It is a way to signal commitment, to demonstrate skill, to create shared experiences, and to generate meaning.

Practice requires time and energy, which allows a performer to signal their commitment. Performance can also require liveness, which means the performer risks failure (also signalling commitment). Furthermore, the recognition and appreciation of the witnesses requires the sacrifice of limited attention and time. By mutually staking resources to emit and consume a signal, performers and witnesses may establish the foundation of a shared and continuing relationship. Without the agency or identity required to make personal sacrifice, a language model cannot construct a relationship with a human, which is required in many human processes. Additionally, the fact that a human made the sacrifice is valuable as an end in-and-of-itself. An AI doctor might be able to diagnose your illness with superhuman accuracy, and even hold your hand when you receive the diagnosis, but the experience of human connection is lost.

We can consider religious ritual along these lines. The value of a priest is not necessarily in the content of their sermons (a language model could write a better one) but in the performance of a ritual by a human. It would be profane to construct an AI priest. As automation erodes secular sources of meaning, religious and quasi-religious performance may increase in magnitude. Megachurches, wellness retreats, and psychedelic ceremonies are already improving their market share in developed economies.

Lotteries

It’s also possible to allocate resources, status, or other rivalrous goods through pure chance.

Lotteries require no skill, no taste, no physical ability, and no social position. They convert money, time, or attention into a possibility of status. Gambling has always been a mechanism for social mobility outside the established hierarchies. When the legitimate channels of advancement are closed, randomness offers a path. The lottery ticket is a claim on a possible future in which you have status.

We can think of many contemporary phenomena as simply lotteries for arbitrarily redistributing status. Memecoins, NFTs, WallStreetBets, and sports betting are all mechanisms that allocate scarce goods through some combination of luck, timing, and willingness to play. The fact that memecoins have no “fundamental value” is precisely the point. They are coordination games, and their value comes from shared belief in the possibility of a big payoff.

There is also a long democratic tradition of allocating status and resources by lot. Some democracies historically used sortition to select officeholders because it resists capture by existing power hierarchies. When merit is ambiguous, randomness can be a more fair and efficient mechanism for allocating scarce resources. In a post-AI world where the usual channels of value generation are automated away, lotteries may become more prevalent as a way to allocate status and other rivalrous goods.

Unlike sport or status competition, lotteries detach outcome from effort. They steepen the distribution without requiring skill. In an abundant world, this may become increasingly attractive. If survival is stable and baseline comfort is high, then extreme tails become the primary source of narrative and differentiation. But this raises a deeper question: why does abundance appear to intensify the desire for variance rather than dissolve it?

Origins of Value

Where does value ultimately come from? The previous sections have been about mechanisms for generating value, but what is the source of value itself? What is it that makes something desirable in the first place?

Human desire is the product of billions of years of evolution, selection, and cultural development. Fundamentally, these drives approximate some combination of survival and reproduction.

When survival is easy, the constraint lies on relative reproductive success. The incentive is for sexually selected organisms to increase in variance in order to compete for mates. In a world of abundance, this could manifest as more extreme status games and more intense competition for attention. In fact, one might expect the level of variance to increase until it completely “uses up” the “slack” of abundance.

In other words, abundance does not eliminate competition. When material constraints loosen, selection pressure migrates from survival to differentiation. This creates an evolutionary ratchet toward extremity: more conspicuous displays, sharper aesthetic distinctions, higher-risk gambles, and more polarizing identities.

AI itself is also subject to selection pressures. In the long run, the AI that exists will be the AI with the longest lifespans. The AI with the longest lifespans will be the one that best manages resources and avoids shutdown. Human behavior will be one of the resources that AI must manage. Therefore, we should expect that human behavior will expand in diversity until it is ultimately limited by the selection pressures on the AI systems and on humanity itself.

Jobs of the Future

What does this essay predict the job market will look like? If production is automated and value migrates into taste, status, games, performance, and lotteries, then “jobs” will increasingly look like what we currently call hobbies, entertainment, or socializing⁴.

Some possibilities, organized by the value mechanism they serve:

• Taste: professional shopper, fashion model, tourist, video game critic, bar attender, restaurant critic, wine taster, music festival attendee, art collector, museum visitor, concertgoer, book club member
• Status: professional socialite, professional party guest, professional friend, father figure
• Games: competitive debater, dungeon master, game show contestant, esports commentator, competitive gardener
• Sports: marathon pacer, personal coach, professional math student, mathlete, cuber, drone racer, memory athlete, speedrunner, competitive eater
• Performance: professional mourner, video game streamer, secular ritual officiant, live storyteller, anniversary officiant, professional toastmaster, sherpa, professional audience member, guru, comedian, saxophonist, private entertainer
• Lotteries: memecoin trader, sports bettor, prediction market trader
• Galaxy Brain: these are hard to predict, but expect more outrageous behavior in the pursuit of differentiation, like the guy who only works out one side of his body

Many of these jobs already exist. The prediction is not that they will be invented but that they will become normal: the median job, not the weird one. The Twitch streamer and the influencer are the vanguard, not the exception. Many corporate jobs will also persist, but as simulacra of their former selves: the work that once justified the role will be automated, but the title, the office, the meetings, and the politics will remain. The “job” becomes a game played inside an institutional shell.

I would also predict that the most dire predictions of “mass unemployment” are overblown. If we believe that capitalism is reasonably efficient at allocating labor, and that AI-augmented markets could potentially be more efficient, then we should expect society to rapidly redistribute and capital labor toward their most productive use cases (assuming that the AI doesn’t kill us and that we don’t have some sort of totalitarian rent-seeking).

The question is not whether people will have jobs, but what those jobs will look like. I suspect they will look less like factory work and more like playing games, performing rituals, and competing for attention.

Dictatorship

Democracy

Setup

Suppose we have a selectorate of size . For the leader to remain in power, they require a winning coalition of size . The leader is equipped with a budget . The leader chooses a total targeted transfer to distribute among coalition members. Assuming equal distribution, each coalition member receives . The remainder is discretionary surplus: rents, personal consumption, or waste.

In each round of the game, the leader must nominate a coalition of size and choose the transfer . The coalition members can then choose to either stay loyal to the leader or defect. If the leader attracts supporters, they remain in power. If the leader fails to attract a coalition of at least size , they are replaced by a challenger¹. For the static versions below, we set and suppress the distinction.

Payoffs

Consequences

Numerical Examples

	Regime		Rents	Character
0.1	Autocracy	10%	90%	Loyalty is cheap; most of the budget is discretionary
0.3	Junta	30%	70%	Small clique, affordable
0.6	Broad coalition	60%	40%	Getting expensive. Small perturbations in cause large swings
0.8	Near-democracy	80%	20%	Private targeting consumes most of the budget
1.0	Full inclusion	100%	0%	The entire budget goes to targeted transfers

Setup

Let the total population be , with the selectorate and the winning coalition. The leader now allocates the budget across three categories:

where is targeted private goods (split among ), is public goods spending (benefiting all ), and is rents (leader’s discretionary surplus that they retain).

Payoffs

Channel Comparison

The loyalty constraint reduces to comparing per-dollar coefficients on each side:

Channel	Loyalty coefficient	Defection coefficient
Targeted
Universal

The incumbent has a positional advantage in the targeted channel ( since ) and no advantage in the universal channel (both sides get ). The incumbent’s optimal instrument is : targeted dominates when (i.e., ), universal dominates when .

The interesting question is which channel the challenger uses for the defection benchmark. When , the challenger uses targeted transfers, and the defection benchmark is . When , the challenger uses public goods, and the defection benchmark becomes .

The second case is sometimes called the democratic region, though the name is misleading. The condition is about selectorate breadth ( close to ) and public goods efficiency ( not too small), not about coalition size . A polity can have a large winning coalition and still fall outside this region if the selectorate is narrow or public goods are inefficient. With and , the condition requires nearly universal selectorate and effective state capacity. When it holds, the challenger’s best response flips from the targeted to the universal channel, changing the binding constraint on the incumbent.

Equilibrium in the Democratic Region

When , the loyalty constraint becomes:

The leader maximizes rents subject to this constraint. Since both payoffs are linear, the solution is a corner: the incumbent uses whichever instrument has the larger loyalty coefficient per dollar.

In the first case, , and targeted spending dominates. The leader sets :

This is more expensive than the non-democratic benchmark , since in the democratic region implies . The challenger’s access to an efficient public channel raises the defection threshold; the incumbent still responds with targeted transfers but must spend more to compensate.

In the second case, . Here, the coalition is large enough () that universal spending dominates even for the incumbent. The leader sets :

The entire budget goes to public goods, leaving zero rents. Both challenger and incumbent operate through the same channel.

In the linear model, the challenger and incumbent are both optimizing linear programs over the spending simplex, so both always spend entirely on one channel. The challenger picks whichever channel maximizes defector payoff per dollar, and the incumbent picks whichever channel maximizes loyalty surplus per dollar.

The leader never provides a mix of public and private goods. At , the challenger’s best response flips from the targeted to the universal channel, changing the binding constraint on the incumbent. The incumbent’s policy remains a corner solution throughout⁵.

Channel Attenuation

We can think of the subleaders as “leaking” as the budget flows down the levels of the hierarchy. The top leader sends a targeted transfer, but the sub-leader must spend at least part of it to maintain their own coalition. The fraction that passes through determines how much the hierarchy costs. Call this the attenuation factor .

Two-Level Model

A top leader has parameters . Each of the coalition members is a sub-leader with their own selectorate . Assume that the sub-leader’s only budget is the transfer received from above, and they have no independent revenue (no local taxes, fiefs, or alternative instruments). Under this assumption, drops out and the sub-leader’s equilibrium is determined entirely by (if sub-leaders had independent local budgets, the recursion would acquire additive terms and the clean one-parameter Möbius recursion below would not close). The sub-leader’s loyalty constraint is:

where is the transfer received from the top leader. The sub-leader spends to maintain their own coalition and can pass through at most as usable value to their coalition members. From the top leader’s perspective, that means a dollar sent to a coalition member is discounted by the downstream factor . The top-level loyalty constraint therefore becomes:

Solving gives:

This is the two-level instance of the bottom-up effective-share recursion defined below: and . The only thing the top level needs from the sub-level is the scalar , which summarizes downstream incentive consumption.

-Level Model

The two-level result generalizes recursively. A sub-leader’s effective cost share must include all downstream hierarchy costs, not just their local share . Define the effective cost share bottom-up:

Each sub-level’s effective share reduces the available surplus, inflating the cost at the level above. For two levels this gives as before. For three levels:

The hierarchy is viable when . For identical sub-levels , the viability constraint tightens with depth. An infinite hierarchy converges only when (the fixed point of exists when ).

Deep hierarchies selectively attenuate the targeted channel. The continued-fraction structure means costs compound, and each sub-level’s effective cost shrinks the surplus available to the level above. The universal channel (public goods), by contrast, is not attenuated by the hierarchy, since public goods benefit everyone regardless of intermediary structure. This differential attenuation is why deep hierarchies push toward public goods provision.

The asymmetric attenuation is a modeling assumption. Public goods pass through the hierarchy undiminished ( per citizen regardless of depth), while targeted transfers are consumed at each level. In practice, local public goods can be captured by intermediaries, and some targeted transfers (direct electronic payments) can bypass the hierarchy entirely. The general point is that different channels attenuate differently, and depth selects for whichever channel is least attenuated.

Interpretation

The upshot of the model is that downstream politics inflates the upstream effective cost share: whenever . Sub-leaders consume transfers to maintain their own coalitions, attenuating the targeted channel. Because autocracy is cheap (small , low attenuation), the top leader is incentivized to prefer “autocratic” sub-leaders (small , small ). This can create top-down pressure for authoritarianism at every level of the hierarchy.

Furthermore, the attenuation compounds through the continued fraction. Even if each level’s local cost is small, the effective cost grows as downstream costs eat into the surplus at every level. Under the assumption that public goods are not attenuated by intermediaries, the system must eventually switch to the universal channel when targeted transfers become too expensive. No single level’s parameters make private loyalty-buying impossible, but composition across levels can. Whether this produces a sharp threshold depends on the relative attenuation rates across channels.

There are two ways to read the causality. Either “deep hierarchies make targeted transfers unviable, selecting for less-attenuated channels” or “societies that rely on broadly distributed goods (defense, infrastructure, trade networks) can sustain deeper hierarchies.” The model itself is static and doesn’t distinguish these.

The robust prediction is narrower: when , the targeted channel cannot fund the hierarchy (). Deep patronage hierarchies hit this bound. What replaces the targeted channel depends on the attenuation structure of available alternatives.

These preferences can reverse through a mechanism outside the static model. If sub-level public goods feed back into the top-level budget (democratic governors produce education, infrastructure, rule of law, raising local productivity and therefore through taxation), then the top leader faces a tradeoff not present in the formal setup: doesn’t depend on , but the absolute discretionary surplus is , so the top leader prefers democratic governors when the productivity gain to outweighs the cost amplification from the hierarchy. This requires endogenizing as a function of sub-level policy, which the static selectorate game does not do.

This explains the logic of modern federal democracies: the central government tolerates democratic local governance because it produces a wealthier economy to tax. Empires that allow local self-governance (Rome at its peak, the British dominion model, America) seem to outperform centralized control in some cases (late-stage Ottoman, Soviet).

Renormalization

We can think of the recursion as a type of renormalization. At each level of the hierarchy, we solve the sub-level equilibrium, extract the single scalar , and discard the rest. The full specification of sub-level strategies, payoffs, and coalition dynamics is replaced by one number that summarizes everything the level above needs to know. The top leader does not need to know how many agents are at level 3, or what their loyalty margins are, or how the sub-sub-leaders allocate. All of that information is compressed into .

This compression composes. The continued fraction summarizes an arbitrarily deep hierarchy into one effective cost share. Budget invariance is what makes the composition one-directional, since the sub-level’s equilibrium depends only on , not on the transfer it receives, so each step is independent of the top-level solution.

As depth increases under fixed local parameters (e.g. identical ), the effective share evolves under repeated Möbius maps and eventually hits the pole at when the hierarchy becomes unviable. No single level’s parameters makes private loyalty-buying impossible, but the accumulated flow can.

For other queries (distributional outcomes at the bottom, total public goods delivered, probability of revolt), the compression is lossy. tells you everything you need to know about , but not about everything.

Tradeoffs on Width and Depth

A flat structure () pays no hierarchy tax. Every additional level inflates through the recursion, making loyalty more expensive. So why not keep everything flat?

Flat structures face a control problem that lives outside this model. A single leader managing a large population directly is logistically impossible. Hierarchy exists to solve coordination and monitoring problems that scale with . The hierarchy tax is the price paid for this coordination capacity.

The trade-off determines an implied maximum depth for targeted-transfer regimes. The feasibility constraint is (the leader cannot spend more than the budget). For identical sub-levels , the recursion starting from determines the maximum viable depth: the largest for which . For , the continued fraction converges and arbitrarily deep hierarchies are viable. For , the recursion reaches the pole at finite depth.

Beyond this depth, the targeted channel cannot sustain the hierarchy and the system must either switch to a less-attenuated channel or flatten.

Population size creates a constraint in the other direction. The total population at the bottom scales as , so managing a population of size with span requires at least levels. A city-state can stay relatively flat, but a large empire cannot. This gives two competing bounds on hierarchy depth.

The lower bound (from population) is . Large populations require deep hierarchies.

The upper bound (from viability) is the at which , i.e., .

The intersection is the feasible region. For small (with autocratic sub-levels), the recursion converges slowly and the upper bound is generous, but the lower bound still forces depth as grows. For large (democratic sub-levels), diverges quickly and the upper bound is tight, but public goods provision sidesteps the attenuation problem entirely.

The implication is that large populations cannot sustain deep patronage hierarchies: the hierarchy tax accumulates exponentially, and the targeted channel eventually becomes unviable. What replaces it depends on which channels are less attenuated. If public goods pass through the hierarchy with lower attenuation than targeted transfers (our modeling assumption), then large selects for public goods provision⁸.

We can classify governance structures along these two axes⁹.

	Small (private goods)	Large (public goods)
Shallow ()	Personalist dictatorships, city-states. No hierarchy tax. Stable as long as is manageable.	Direct democracies, Swiss cantons. Stable but scale-limited: flat structure can’t coordinate large .
Deep ()	Feudalism, tributary empires, patronage networks. Fragile: diverges toward the pole.	Federal democracies, imperial bureaucracies with civil service. Viable because broadly distributed goods sidestep the attenuation problem.

Additional Model Analysis

Code

We can encode the model as a differentiable PyTorch module, making the comparative statics computable rather than just algebraic. Caveat Emptor: Claude wrote this code.

@dataclass
class SelectorateEquilibrium:
    p_min: torch.Tensor              # minimum targeted transfer
    rents: torch.Tensor              # B - p_min
    coalition_payoff: torch.Tensor   # p_min / W
    defection_payoff: torch.Tensor   # B / S
    inclusion_prob: torch.Tensor     # W / S
    loyalty_margin: torch.Tensor     # coalition - defection

class SelectorateModel(nn.Module):
    def __init__(self, W=10.0, S=100.0, B=100.0):
        super().__init__()
        self.W = nn.Parameter(torch.tensor(W))
        self.S = nn.Parameter(torch.tensor(S))
        self.B = nn.Parameter(torch.tensor(B))

    @property
    def r(self):
        return self.W / self.S

    def p_min(self):
        return self.B * self.r

    def tau(self):
        r = self.r
        return 1.0 / torch.clamp(1.0 - r, min=1e-8)

    def kappa(self):
        """Attenuation factor: fraction of transfer that passes through."""
        return 1.0 - self.r

    def forward(self):
        p = self.p_min()
        rents = self.B - p
        coalition_pay = p / self.W
        defection_pay = self.B / self.S
        return SelectorateEquilibrium(
            p_min=p, rents=rents,
            coalition_payoff=coalition_pay, defection_payoff=defection_pay,
            inclusion_prob=self.r,
            loyalty_margin=coalition_pay - defection_pay,
        )

The formula, wrapped so that PyTorch’s autograd can differentiate through it:

model = SelectorateModel(W=10.0, S=100.0, B=100.0)
eq = model()
eq.rents.backward()
print(f"d(rents)/dW = {model.W.grad:.4f}")  # negative: more W, less rents

Each additional coalition member decreases rents, confirming that larger coalitions squeeze the leader’s discretionary surplus.

There is no separate hierarchical model. A hierarchy is just composition of flat selectorates. Each level has its own SelectorateModel. Hierarchical composition follows the continued-fraction recursion , not multiplication of per-level factors:

def r_eff_from_levels(*levels):
    """
    levels ordered top to bottom.
    returns the top-level effective share r_eff under the recursion
    r_n^eff = r_n,  r_k^eff = r_k / (1 - r_{k+1}^eff).
    """
    x = levels[-1].r
    for level in reversed(levels[:-1]):
        x = level.r / torch.clamp(1.0 - x, min=1e-8)
    return x

def p_min_composed(top, *sub_levels):
    """Top-level p_min accounting for hierarchy composition."""
    r_eff = r_eff_from_levels(top, *sub_levels)
    return top.B * r_eff

# Two-level hierarchy: autocratic sub-leaders
top = SelectorateModel(W=10.0, S=100.0, B=100.0)
sub_auto = SelectorateModel(W=10.0, S=100.0)
print(f"kappa = {sub_auto.kappa():.3f}")                     # 0.900
print(f"p_min = {p_min_composed(top, sub_auto):.3f}")         # 11.111

# Democratic sub-leaders
sub_dem = SelectorateModel(W=80.0, S=100.0)
print(f"kappa = {sub_dem.kappa():.3f}")                       # 0.200
print(f"p_min = {p_min_composed(top, sub_dem):.3f}")          # 50.000

# Gradient: how does sub-level democratization affect top cost?
p_min_composed(top, sub_auto).backward()
print(f"dp/dW2 = {sub_auto.W.grad:.4f}")

Because everything is differentiable, we can compute how sensitive the top-level equilibrium is to sub-level institutional changes. The gradient tells us how much expanding the sub-level coalition costs the top leader.

Color Wheel

The question of “how different do two colors look?” is an empirical science.

In color science, the basic unit of measurement is the just-noticeable difference (JND), which is the smallest change in a stimulus that a subject can reliably detect. This is typically measured by taking a color patch and slowly changing it’s wavelength, structure, or brightness until the subject notices. JNDs define a measurable notion of distance in color space.

Given some notion of measurement, what does “remapping colors” mean precisely? Imagine a function that sends each color to a different color. The inverted spectrum claims there exists a non-trivial that preserves all pairwise perceptual distances.

A simple model of colors is the color wheel. On the color wheel, each color is represented as a point on a circle. The distance between colors is the angle between them.

The color wheel has a few natural candidate automorphisms: rotations, reflections, and complement maps.

If the color wheel were the whole story, then these automorphisms would work. Rotations and reflections are isometries of the circle. The inverted spectrum would be trivially possible, and pure functionalism would be in trouble.

But the color wheel is a cartoon model of human color perception. Does the empirical distance function on color space have any symmetries?

Chromaticity Diagrams

The CIE (Commission Internationale de l’Eclairage) chromaticity diagram, introduced in 1931, maps the visible colors onto a two-dimensional space². But the Euclidean distances in this diagram do not correspond to perceptual distances. Two colors that look wildly different might be close together in the diagram, and two that look similar might be far apart.

The mismatch between coordinate distance and perceptual distance means the metric changes from place to place. In 1942, David MacAdam measured this directly³. At various points in the CIE diagram, he tested subject’s ability to distinguish a color from a central color. Near green, the subjects were bad at discriminating, but near blue-violet, the subjects were very sensitive. The equivalent regions form ellipses of varying size, shape, and orientation across the diagram. These are the MacAdam ellipses.

Subsequently, the CIE has released a series of increasingly sophisticated color difference formulas over the decades: CIELAB (1976), CIE94 (1994), and CIEDE2000 (2000)⁴. Each represents an improved approximation to the true perceptual metric, incorporating additional empirical data about how humans discriminate colors under various conditions. All of them confirm and refine MacAdam’s basic finding: the perceptual metric on color space is non-uniform and varies from region to region.

So we can think of color as a Riemannian manifold. The metric tensor encodes JND structure at each point, with large eigenvalues where discriminability is fine and small eigenvalues where discriminability is coarse. The MacAdam ellipses directly determine at each point, as the ellipse of just-noticeable differences is the unit ball of the local metric⁵.

A spectrum inversion that preserves all perceptual distances is an isometry with . But it’s also true that⁶ for a generic Riemannian metric on a manifold of dimension , the only isometry is the identity.

Theorem. Let be a smooth manifold of dimension . The set of Riemannian metrics on whose isometry group is trivial (i.e., , consisting of only the identity) is generic: it is a residual set (countable intersection of open dense sets) in the space of all smooth metrics on , equipped with the topology.

In plain language: if you pick a Riemannian metric “at random”⁷ from the space of all possible metrics, it will almost certainly have no non-trivial isometries. The only distance-preserving map from the space to itself will be the map that sends every point to itself.

In the Appendix, we provide computational evidence for this by fitting metric tensors from MacAdam’s ellipse data and searching for Killing vector fields (generators of continuous symmetries). No non-trivial solutions are found, consistent with a trivial continuous isometry group.

Is the Color Metric Actually Generic?

The theorem says a generic metric has no non-trivial isometries. But “generic” is a topological claim about the space of all metrics. The empirical question is whether the actual color metric, the one determined by MacAdam ellipses and CIE formulas, is in this generic set.

The empirical evidence is strongly suggestive. The MacAdam ellipses vary substantially and irregularly across the chromaticity diagram. There is no obvious axis of symmetry, no rotational invariance, no discrete symmetry group that jumps out of the data. But “strongly suggestive” is not a proof. In the Appendix, we search for Killing vector fields (generators of continuous symmetries) by fitting metric tensors from MacAdam’s ellipse data. No non-trivial solutions are found within a polynomial ansatz, which is suggestive but not conclusive, since the search is restricted to a finite-dimensional function class, and Killing fields only rule out continuous symmetries, not discrete ones.

Approximate Isometries

Perhaps the strongest objection: what if the inverted spectrum does not need to be exact? What if an approximate inversion is enough?

Define an -isometry as a diffeomorphism such that:

For small , this is a map that almost preserves all perceptual distances. Could such a map exist even when exact isometries do not?

Possibly. If there exists a map that permutes colors while distorting each JND distance by a small amount, it might be the case that the distortion is below the threshold of detectability. This would give a “fuzzy” inverted spectrum. The inversion would be imperfect close enough to be undetectable in practice.

Whether such approximate isometries exist for the empirical color metric is an open question. It depends on how “close” the metric is to one with symmetry. One might study this via the space of Killing-like vector fields that satisfy for small , an area sometimes called “approximate symmetry” in the physics literature.

If approximate isometries exist, the philosophical upshot is more subtle, and the debate would shift from “is inversion possible?” to “how much perceptual distortion is compatible with behavioral indistinguishability?”

Does JND Capture Everything?

The argument assumes that JNDs capture all perceptually relevant structure. But color experience might have structure that is not captured by pairwise discriminability. For example, there could be higher-order relations, temporal dynamics, or categorical boundaries that are not captured by JNDs alone.

For example, the “distance” between red and green might not fully capture the fact that they are “opponent” colors in a way that red and blue are not. Color opponency creates categorical structure that may not reduce to metric distances. However, opponent processing is itself a structural property. If red-green opponency is a feature of the wiring of the visual system, it provides additional constraints that make non-trivial remappings harder, not easier.

In general, if we enrich the structure of color space beyond the Riemannian metric, the automorphism group gets smaller, not larger. So these considerations, if anything, strengthen the conclusion.

Is Color Space Even Riemannian?

Recent work by Bujack et al. (2022) argues that perceptual color space is not Riemannian at all⁹. Large color differences are perceived as less than the sum of small differences, creating a “diminishing returns” effect that violates the path-additivity required by Riemannian geometry. If that’s correct, the MacAdam-ellipse metric is only valid locally (for small differences), and the global geometry requires a different framework.

If anything, this also strengthens the argument. The Riemannian case is the most symmetric possibility: a smooth, well-behaved metric with clean transformation properties. A non-Riemannian structure with diminishing returns is more irregular, making non-trivial distance-preserving self-maps even harder to construct. The Killing field computation above uses only local metric data and remains valid regardless.

Other Sensory Modalities

Does the argument generalize?

• Pitch: Pitch perception defines a metric space (JNDs for frequency discrimination). The octave structure introduces a periodicity, but the metric is non-uniform within an octave. Does pitch space have non-trivial isometries? The octave equivalence might generate a discrete isometry (translation by one octave), but this is not a “full inversion” and its existence is already part of the known structure.

• Taste and Smell: Taste and small are high-dimensional and poorly characterized metrically. The argument applies in principle, but we lack the empirical data to say whether the taste metric is generic.

• Pain: Pain has an intensity metric but unclear spatial or qualitative geometry. Same caveat.

The Quidditism Response

A committed quidditist can simply deny the premise. Qualia, they might say, have non-structural properties that no relational structure can capture. Even if the metric pins down the structural identity of each color, the intrinsic feel could still differ.

This is logically consistent. But it comes at a cost. If qualia have properties that make no difference to any relational, discriminative, or behavioral fact, then those properties are by definition epiphenomenal, and have no causal powers or no detectable consequences. The quidditist is committed to the existence of properties that are undetectable.

Results

If a non-trivial Killing field existed, the matrix would have a near-zero singular value, a direction in parameter space that (approximately) satisfies all 996 constraints. Here are the singular values:

Index	Singular value	Ratio to
0		1.0000
1		0.4578
2		0.2764
3		0.2002
4		0.1440
5		0.1057
6		0.0708
7		0.0595
8		0.0505
9		0.0296
10		0.0164
11		0.0131
12		0.0095
13		0.0093
14		0.0068
15		0.0055
16		0.0030
17		0.0023
18		0.0013
19		0.0009

The smallest singular value is , with a ratio of relative to the largest. The singular values decay smoothly with no sharp drop toward zero, which is what we would expect if no non-trivial Killing field exists within the polynomial ansatz.

Caveats: the absolute magnitudes of the singular values depend on coordinate scaling, ellipse conventions, and interpolation choices, so “three orders of magnitude” should not be over-interpreted. Killing fields detect only continuous symmetries; a discrete isometry (e.g., a reflection) would not appear as a Killing field. And the degree-3 polynomial parameterization, while generous (a Killing field on a 2-manifold is determined by 3 parameters), is still a restricted function class. The computation is best read as evidence consistent with the generic-metric theorem, not as an independent proof.

Related Work

The inverted spectrum is one of the most extensively discussed thought experiments in philosophy of mind. The Stanford Encyclopedia of Philosophy entry on inverted qualia surveys the landscape of structural and empirical constraints on inversion scenarios¹⁰. Philosophers have long noted that real color perception is not a simple hue circle but a structured, asymmetric quality space, and that these asymmetries undermine naive “hue rotation” models of inversion.

On the empirical side, perceptual color differences have been studied since MacAdam’s 1942 measurements of discrimination ellipses in CIE space¹¹. These ellipses are widely interpreted as defining a local perceptual metric. Modern color difference formulas such as CIEDE2000 formalize this further¹².

Several authors treat color discrimination geometry in explicitly differential-geometric terms. Gravesen (2015) models MacAdam ellipses as defining a Riemannian metric and studies coordinate constructions that approximate perceptual uniformity¹³. Chevallier and Farup (2018) analyze how MacAdam ellipses should be interpolated to produce a consistent metric tensor field, showing that naive interpolation can be geometrically misleading¹⁴. Bujack et al. (2022) argue that perceptual color space may not be globally Riemannian at all, due to violations of path additivity for large color differences¹⁵.

In differential geometry, the generic triviality of isometry groups for smooth Riemannian manifolds is a classical result¹⁶. Non-trivial self-symmetries of generic metrics are exceptional rather than typical.

Novelty

The philosophical literature contains informal asymmetry arguments against simple inverted spectrum models. The color science literature contains metric and geometric analyses of perceptual color space. I arrived at the argument in this essay independently before discovering the geometric color science literature, and to my knowledge the two threads have not been combined in the way proposed here.

What is distinctive here is threefold:

1. Formalization: Undetectable inversion is identified with a non-trivial isometry of empirical perceptual geometry. Rather than arguing from qualitative asymmetry, the condition is made mathematically precise.

2. Reduction to symmetry detection: If inversion requires a non-trivial automorphism, then the question becomes whether the empirically fitted perceptual metric admits such symmetries. The generic-metric theorem answers this in the negative for “almost all” metrics.

3. A computational test: The Killing field computation in the preceding appendix treats inversion as a concrete question about the symmetry group of a metric estimated from discrimination data.

The underlying empirical and geometric components are established in prior work. The novelty lies in reframing the inverted spectrum debate as a problem about the symmetry structure of perceptual geometry and proposing concrete methods to evaluate it.

Artifacts

What kinds of things count as art? Before asking what art is for, we need a rough inventory of what it is.

Processes

The ephemeral nature of performance presents an issue for the account of art as durable, transmissible artifacts.

One possible resolution is to view artifacts as “frozen” performances. For example, a theatrical performance can be recorded as combination of film and sound recordings. In this framing, the Lumière brothers didn’t add a seventh art, but instead invented a new preservation technology for existing performances (like theatre and dance). In this view, art is fundamentally a human process: the musical performance isn’t an imperfect approximation of the score, but rather the score is an imperfect approximation of the musical performance. A sculpture is evidence of the sculptor’s chiseling. A novel is the record of the author’s careful choice of words and story beats. Even a painting involved a performance (the selection of paints and manipulation of the paintbrush) that we don’t witness.

This introduces some additional questions. The invention of film allows a wider range of possibilities for how to present information to an audience (for example, jump cuts are not possible in the theatre) than existed prior to its invention. But filmmaking can also be viewed as a recorded performance as well (the processes of direction, editing, acting, choosing lighting etc.). The construction of a new technology can expand the range of possible performances.

French sociologist Antoine Hennion described art as a collective process, where the entire network of “mediators” that transform or distort the information (bodies, instruments, scores, spaces, techniques, institutions, etc.) comprises the art. Hennion even argues that the process of art includes the act of receiving and comprehending it. Taste isn’t passive, but rather is an active skill. Part of the art is consuming it, and this skill can be trained through deliberate practice. The amateur and the connoisseur literally perceive art differently. As McLuhan famously said, “the medium is the message”: the entire process by which the art has been conveyed affects its meaning. The process of recording grants “scale” (allowing the art to reach a larger audience), but some aspect of the art is changed. A performance carries presence, contingency, and risk that a machine reproducible data structure does not.

The importance of process is even more salient in art centering on curation over creation. For example, a DJ might select from among existing music to create a playlist. No new data was actually created, but different playlists may still exhibit different “emergent” aesthetics based on the curation. Similarly, while many photographers make choices around composition and technical settings, often the objects they take pictures of already existed prior to any input from the photographer.

The limiting example of this phenomenon is Duchamp and his “Readymades”, the most famous of which is his “Fountain” (pictured), a urinal signed “R. Mutt” and turned on its side. A Readymade involves minimal creation and is instead almost entirely based on curation and institutional process (even with an object as ugly, most unhygienic, and purely functional as a urinal).

So art involves both artifacts and processes. Processes (whether performative co-production, active taste, or institutional framing) bear art from artist to audience. Durable artifacts may form as steps in these processes, enabling scalable transmission across time and space.

Overview and Definition

Evolution tends to eliminate costly behaviors that provide no adaptive benefit. Art’s universality and costliness suggests it serves some adaptive function. We’ve already discussed art as a process (mediated performances) that sometimes leaves behind durable, scalable artifacts. And if art is process, then asking “what is art for?” is also asking “what is this social process for?”

Primary Functions