Galois Theory of Algorithms

Many different programs are the implementation of the same algorithm. The collection of programs can be partitioned into different classes corresponding to the algorithms they implement. This makes the collection of algorithms a quotient of the collection of programs. Similarly, there are many different algorithms that implement the same computable function. The collection of algorithms can be partitioned into different classes corresponding to what computable function they implement. This makes the collection of computable functions into a quotient of the collection of algorithms. Algorithms are intermediate between programs and functions: Programs $\twoheadrightarrow$ Algorithms $\twoheadrightarrow$ Functions. \noindent Galois theory investigates the way that a subobject sits inside an object. We investigate how a quotient object sits inside an object. By looking at the Galois group of programs, we study the intermediate types of algorithms possible and the types of structures these algorithms can have.

💡 Research Summary

The paper proposes a novel mathematical framework that places algorithms squarely between concrete programs and abstract computable functions, using the language of Galois theory to describe how quotient objects sit inside a larger object. It begins by defining three sets: P (the set of all possible program representations, such as source code, byte‑code, or binaries), A (the set of algorithms obtained by quotienting P by an equivalence relation ∼₁ that identifies programs implementing the same procedural logic), and F (the set of computable functions obtained by further quotienting A by an equivalence relation ∼₂ that identifies algorithms with the same input‑output behavior). The maps P → A → F are regular epimorphisms in categorical terms, i.e., surjective structure‑preserving morphisms.

The core contribution is the introduction of “Galois groups of programs.” The automorphism group Aut(P) consists of all syntactic transformations that preserve program semantics (e.g., refactoring, renaming, compilation optimizations). A subgroup G₁ ⊆ Aut(P) that stabilises the equivalence ∼₁ is called the program‑level Galois group. Analogously, Aut(A) contains transformations of algorithmic descriptions (e.g., reordering independent steps, applying algebraic identities), and a subgroup G₂ ⊆ Aut(A) stabilises ∼₂, forming the algorithm‑level Galois group.

The paper shows that the classical Galois correspondence between subgroups and intermediate fields has an exact analogue here: for any subgroup H with G₁ ⊇ H ⊇ G₂, the fixed‑point set P^H is a quotient object that sits strictly between A and F. This object can be interpreted as a new class of algorithms characterised by additional constraints (e.g., “linear‑time, constant‑space algorithms”). The correspondence is formalised as a Galois connection Φ : Sub(G₁) ↔ Quot(P) : Ψ, where Φ maps a subgroup to its associated quotient and Ψ maps a quotient to the smallest subgroup that fixes it. This connection yields a complete lattice structure mirroring the subgroup‑field lattice of classical Galois theory.

The authors analyse the invariants associated with each group. Elements fixed by G₁ correspond to structural properties observable at the algorithmic level, such as control‑flow graphs, data‑flow dependencies, or complexity classes. Elements fixed by G₂ correspond to functional invariants, i.e., the actual mathematical function computed. Thus the Galois groups provide a systematic way to separate “implementation‑level” variability from “specification‑level” variability.

Concrete examples illustrate the theory. In functional languages, α‑conversion, β‑reduction, and η‑expansion are automorphisms of P; the subgroup that only allows these transformations yields an equivalence class of “pure functional algorithms.” In imperative languages, loop unrolling, inlining, and register allocation are members of G₁; the fixed‑point of the corresponding subgroup captures algorithms respecting a given time‑space trade‑off. The paper also discusses how compiler optimisations can be viewed as elements of Aut(P) and how their preservation of ∼₁ or ∼₂ determines whether they affect algorithmic semantics or merely program representation.

Related work is surveyed, noting that prior research has linked programs to functions via semantics or type theory, and that categorical approaches have modelled λ‑calculus and automata. However, the explicit insertion of an intermediate “algorithm” layer equipped with a Galois‑theoretic structure is novel. Moreover, while classical Galois theory studies subobjects (e.g., subfields), this work focuses on quotient objects, thereby extending the scope of Galois‑type reasoning.

The paper concludes with several avenues for future research: extending the framework to higher‑dimensional category theory (e.g., 2‑categories) to capture transformations of transformations; modelling distributed or parallel systems where multiple equivalence relations coexist, leading to a multi‑Galois‑group landscape; and building tooling that automatically extracts the relevant Galois groups from code bases to aid program refactoring, algorithm classification, and formal verification.

In summary, by treating programs, algorithms, and functions as a chain of quotients and by importing the machinery of Galois groups and connections, the authors provide a rigorous, algebraic lens for understanding the spectrum of abstraction in computation. This lens separates syntactic variability from semantic invariance, offers a lattice of intermediate algorithmic classes, and opens a path toward systematic, mathematically grounded analysis of software transformations.