The Andrews–Curtis Conjecture & SAIR Challenge: Balanced Presentations, 4-Manifold Handles & Akbulut–Kirby Pairs
Formulated by Andrews and Curtis in 1965 and benchmarked by XTX-backed SAIR competitions: why a two-relator presentation of the trivial group can pass through deeper intermediate word lengths before collapsing via three elementary algebraic moves.
Why it matters
Picture solving a Rubik’s cube when you only have two faces turning inside a narrow sleeve: you cannot swap two corner pieces without first breaking solved strips on purpose so opposite layers line up for a clean cancellation cascade.
Conceptual Vision Plate M.14-V (Imagining What It Would Look Like) · Artistic visualization of twin genus-2 handlebodies and free-group conjugations bridging Andrews–Curtis (1965) and Akbulut–Kirby pairs (1985).
About this illustrationThis AI-generated illustration is imagining what the concept would look like: an artistic impression, not a measured structure or specification. Exact geometry, specifications and governing equations are kept strictly intact with zero artistic interpretation in deterministic Plate M.14-A and Plate M.14-B below.Sinopsis Ejecutiva en Español · Folio M.14
Actos I y II — Historia, ley gobernante e intuición cotidiana:La Conjetura de Andrews–Curtis y el Reto de SAIR: Presentaciones Balanceadas y Pares de Akbulut–Kirby — Formulada por Andrews y Curtis en 1965 y adoptada en los retos de SAIR respaldados por XTX: por qué una presentación balanceada del grupo trivial obliga a alargar sus palabras antes de colapsar mediante tres movimientos elementales. Este monográfico interactivo verifica la ley gobernante AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves. Por qué importa en la vida real: La conjetura de Andrews–Curtis pregunta si toda presentación balanceada del grupo trivial se reduce a ⟨x₁, …, xₙ | x₁, …, xₙ⟩ usando solo inversiones, productos y conjugaciones sin añadir variables temporales.
En Palabras Sencillas (Explicación Accesible): Imagina dos ligas marcadas x e y enredadas alrededor de dos postes. Aunque en secreto las ligas no sujeten ningún poste y el sistema sea trivial, las reglas de Andrews–Curtis prohíben clavar un tercer poste temporal para deshacer el nudo. Solo puedes invertir una liga, empalmar una con otra o deslizarla por un poste mediante conjugación. Por eso hasta un ejemplo de 11 letras como AK(2) tiene que estirarse primero a 14 letras antes de cancelarse en cascada hasta 2 letras en 23 pasos.
Mecanismo Técnico, Fuerzas en Competencia y Umbral Crítico: Basado en Andrews y Curtis (1965, DOI 10.2307/2033843), Akbulut y Kirby (1985, DOI 10.1016/0040-9383(85)90010-2) y la búsqueda neuronal en grafos de nudos de Gukov et al. (2021, DOI 10.1088/2632-2153/abe91f). El verificador skills/math/m14/verify_m14_andrews_curtis_moves.py reproduce los 23 movimientos exactos sobre AK(2) de longitud 11 a 2 y falla bajo --planted-defect al omitir el inverso en la conjugación.
Acto III — Laboratorio interactivo: los deslizadores en tiempo real y las cuatro lentes del observatorio (superficie 3D, retrato de fase, listón de conservación y radar polar) permiten explorar los umbrales críticos directamente en el navegador.
Actos IV y V — Descubrimiento y fuentes: la narrativa completa y las fuentes primarias siguen abajo (en inglés). Investigación científica y educativa abierta, no consejo médico.
Act I — Handlebodies, Free Groups, and a 60-Year Combinatorial Puzzle
In 1965, James J. Andrews and Morton L. Curtis published a short topological paper on free groups and handlebodies (Proceedings of the AMS, DOI 10.2307/2033843) containing a disarmingly compact algebraic question. Suppose you are given n algebraic generators x_1, …, x_n and exactly n defining equations r_1 = 1, …, r_n = 1 that already collapse the entire group down to the single-element trivial group. Can you always untangle those equations back to the bare coordinate axes ⟨x_1, …, x_n | x_1, …, x_n⟩ using only three local moves—without ever introducing an auxiliary helper variable?
In Plain Words · Extra-Easy Explanation
Imagine holding two rubber bands labeled x and y twisted around two pegs in a complicated knot, and someone tells you the knot actually does not lock either peg down—the system is secretly trivial. If you were allowed to hammer in a temporary third peg to slide loops over, untangling the bands is always possible. The Andrews–Curtis rule forbids hammering in any third peg: you may only reverse a band’s orientation, splice one loop onto the other, or slide a band partway around a peg. Even for two generators and eleven characters, untangling the knot often forces the bands to look longer and more tangled in the middle before dozens of opposite twists suddenly cancel out at once.
Beneath its elementary symbols, the Andrews–Curtis Conjecture sits directly across the border between combinatorial group theory and 4-dimensional differential topology. Because 2-dimensional handle slides on a 4-manifold boundary map straight to relator multiplications and free-group conjugations, Selman Akbulut and Robion Kirby (1985, Topology, DOI DOI 10.1016/0040-9383(85)90010-2[Scite ↗]) studied explicit balanced families such as AK(n) = ⟨x, y | x y x = y x y, xⁿ = yⁿ⁺¹⟩ whose trivializations test whether smooth 4-sphere structures conceal non-standard handlebodies. While AK(1) and AK(2) yield to short algebraic manipulation, higher members of infinite balanced families require exploring exponentially wide word graphs.
In 2021, Sergei Gukov, James Halverson, Fabian Ruehle, and Piotr Sułkowski (DOI DOI 10.1088/2632-2153/abe91f[Scite ↗]) demonstrated how reinforcement learning and neural policy networks could navigate combinatorial topology and knot-unknotting move trees without exhausting naive breadth-first memory. Following XTX Markets’ 2026 philanthropy shift, the SAIR Foundation (competition.sair.foundation) elevated the Andrews–Curtis Conjecture Challenge into a clean testbed for heuristic theorem-search, curriculum learning, and symbolic rewrite agents: every candidate trace is instantly checkable in linear time once found, yet finding short traces across steep length barriers remains wide open.
Why is Andrews–Curtis such an instructive benchmark for mathematical AI? Many automated reasoning benchmarks reward local step-by-step greed: every good step visibly shrinks an error metric toward zero. Andrews–Curtis punishes greedy heuristics brutally. To trivialize even the small presentation AK(2) (total length 11), our explicit 23-step move trace must expand total relator length upward to 14 symbols before collapsing abruptly to 2. Discovering strategies that tolerate deliberate intermediate complexity without losing global orientation is precisely what separates shallow pattern matching from deep mathematical planning.
Every enduring equation begins as a human question—an act of patient curiosity by investigators who refused to accept an opaque boundary as the final word. Tracing the intellectual arc of Folio M.14 from its earliest formulation in 1965 (J. J. Andrews and M. L. Curtis pose the balanced trivial-presentation reduction conjecture in Proceedings of the AMS (DOI DOI 10.2307/2033843[Scite ↗]).) to its modern resolution in 2026 (The SAIR Foundation hosts the Andrews–Curtis Conjecture Challenge (https://competition.sair.foundation/) as a clean benchmark for open mathematical search.) reveals why un-coupled classical approximations repeatedly stalled at a hard analytical barrier. Whenever investigators attempted to treat the governing relation AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves as a purely local or linearized perturbation, higher-order coupling terms across the kernel triad (Free-group word reduction Engine ⟨x, y⟩ · Elementary Andrews–Curtis moves (INV, MUL, CONJ) · Akbulut–Kirby AK(n) presentation family) amplified truncation error rather than damping it. What appeared for decades to be an intractable computational or experimental pathology was, in reality, a structural phase boundary embedded in the operator domain itself.
Resolving that impasse required shifting from ad-hoc empirical curve fitting to a rigorous, multi-stage operator formulation anchored in AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization. Specifically, the system’s trajectory is governed by control parameter P_1 (Akbulut–Kirby Parameter (k)) spanning the admissible interval [1, 5] with step resolution Δ = 1 and canonical reference operating point k = 2; control parameter P_2 (Elementary AC Move Trace Budget (moves)) spanning the admissible interval [5, 30] with step resolution Δ = 1 and canonical reference operating point moves = 23. Within this state space, any valid proof or physical design must simultaneously satisfy local conservation laws, global boundary conditions, and strict asymptotic scaling—setting the stage for the four-chapter formal derivation in Act II.
"Forbidding auxiliary variables turns an easy topological unwinding into a canyon where relators must first grow longer before they can collapse to zero."
§ I.2 · Historical Turning Points
Year
Milestone
1965
J. J. Andrews and M. L. Curtis pose the balanced trivial-presentation reduction conjecture in Proceedings of the AMS (DOI DOI 10.2307/2033843[Scite ↗]).
1985
Selman Akbulut and Robion Kirby introduce the 4-manifold handlebody family AK(n) linking exotic smooth topology to combinatorial presentations (DOI DOI 10.1016/0040-9383(85)90010-2[Scite ↗]).
2021
Sergei Gukov, James Halverson, Fabian Ruehle, and Piotr Sułkowski apply deep reinforcement learning to combinatorial unknotting and move-graph search (DOI DOI 10.1088/2632-2153/abe91f[Scite ↗]).
2026
The SAIR Foundation hosts the Andrews–Curtis Conjecture Challenge (https://competition.sair.foundation/) as a clean benchmark for open mathematical search.
Act II — Intuition & Governing Law: Non-Monotonic Free-Group Rewriting
Everyday Analogy & Interactive Controls Primer
Everyday Analogy: Picture solving a Rubik’s cube when you only have two faces turning inside a narrow sleeve: you cannot swap two corner pieces without first breaking solved strips on purpose so opposite layers line up for a clean cancellation cascade.
How the Two Sliders Work in Plain Words: Slider 1 selects the Akbulut–Kirby parameter k from AK(1) through AK(5), showing how initial word length climbs steadily (9, 11, 13, 15, 17) while the abelianization determinant stays identically 1. Slider 2 steps across our explicit AC move trace budget up to 30 elementary moves to observe the peak intermediate word-length swell before total collapse.
1 · EVERYDAY ANALOGY (M.14)
No-Extra-Peg Knot Untangling
Inversion, multiplication & conjugation must cancel relators with zero auxiliary generators
Slider 1: Akbulut–Kirby Parameter
Slider 2: Elementary AC Move Trace Budget
➜
2 · TWO COMPETING FORCES
▲ Non-Monotonic Valley Barrier
AK(2) swells 11 → 14 symbols mid-trace before collapsing to length 2
▼ Exact Free-Group Conjugation
w r_i w^-1 preserves normal closure and unlocks 23-step reduction
➜
3 · CRITICAL TIPPING POINT
Final Presentation Check ⟨x, y | r1, r2⟩
✓ STABLE / NOMINAL REGIME
AK(2) reaches ⟨x, y | x, y⟩ (length 2) in 23 valid AC moves
⚠ CRITICAL BREAKDOWN REGIME
Missing conjugation inverse w r_i w breaks cancellation & stalls reduction
PLATE M.14-D · VISUAL INTUITION BRIDGE → GOVERNING OPERATOR: AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves
Plate M.14-D · Visual Intuition Bridge: Before diving into the formal equations, follow how the everyday physical analogy (left) sets two competing mechanisms in tension (center) around a sharp tipping point (right) that you can test directly with the two sliders in Act III.
Consider AK(2) = ⟨x, y | r_1, r_2⟩ with r_1 = x y x y⁻¹ x⁻¹ y⁻¹ (length 6) and r_2 = x² y⁻³ (length 5). First inspect the abelianization matrix of net exponent sums: r_1 sums to (1, −1) and r_2 sums to (2, −3), giving |det([[1, −1], [2, −3]])| = |−3 − (−2)| = 1. That fast check shows the abelianized group vanishes, but abelianization is far too weak to decide non-abelian triviality or produce an AC trace. Replaying our 23 elementary AC moves in verify_m14_andrews_curtis_moves.py explicitly transforms [r_1, r_2] (length 11, peak intermediate length 14) step by step into [y, x] = ⟨x, y | x, y⟩ (length 2). Live parameter coupling: k = 2 under governing law
.
Look closely at what makes every single conjugation move w r_i w⁻¹ delicate. Free-group invariance holds strictly because right-multiplying by w⁻¹ cancels cyclic prefixes while preserving the normal closure ⟨⟨r_1, r_2⟩⟩. When our verifier enables --planted-defect, omitting the inverse on conjugation—computing w r_i w instead of w r_i w⁻¹—injects spurious generator parity into the presentation. Within several moves, cancellations miss, word lengths drift away from cancellation valleys, and the trace fails to recover the trivial generator basis ⟨x, y | x, y⟩.
AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves
Kernels: Free-group word reduction Engine ⟨x, y⟩ · Elementary Andrews–Curtis moves (INV, MUL, CONJ) · Akbulut–Kirby AK(n) presentation family · Benchmarks: AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization · Primary Anchor:DOI 10.2307/2033843
To elevate Folio M.14 (The Andrews–Curtis Conjecture & SAIR Challenge: Balanced Presentations, 4-Manifold Handles & Akbulut–Kirby Pairs) from a qualitative summary to an executable mathematical and physical treatise, we first define the exact state-space manifold on which the operator AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves acts. Let the system state be parameterized by control parameter P_1 (Akbulut–Kirby Parameter (k)) spanning the admissible interval [1, 5] with step resolution Δ = 1 and canonical reference operating point k = 2; control parameter P_2 (Elementary AC Move Trace Budget (moves)) spanning the admissible interval [5, 30] with step resolution Δ = 1 and canonical reference operating point moves = 23. Over this bounded domain, the coupled kernels (Free-group word reduction Engine ⟨x, y⟩ · Elementary Andrews–Curtis moves (INV, MUL, CONJ) · Akbulut–Kirby AK(n) presentation family) map every admissible input configuration to a unique, deterministic equilibrium or deductive fixed point recomputed by skills/math/m14/verify_m14_andrews_curtis_moves.py.
Crucially, well-posedness across the AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization regime requires that the governing operator preserve dimensional homogeneity, non-negativity of physical energy/entropy functionals, and strict monotony along the primary reaction or proof coordinate. Whenever a simplified model omits one of the coupled terms in AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves, the resulting approximation violates boundary compatibility and diverges from the primary peer-reviewed evidence (Scite Smart Citation Index (fetched 2026-11-15): 0 retractions; 36 citing publications (0 supporting, 1 mentioning, 0 contrasting) for Andrews & Curtis (1965), Free groups and handlebodies.).
Rather than treating AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves as an opaque black-box formula, we decompose the proof and physical mechanism of Folio M.14 into four clear, verifiable stages. True scientific tools do not ask for blind trust; they invite inspection. Each stage represents a rigorous transformation of the state vector—corresponding one-to-one with the 4-stage interactive stepper in Act III and the standalone verifier in skills/math/m14/verify_m14_andrews_curtis_moves.py:
Stage 1 Derivation & State Transition
Formal Stage Mechanism: Stage 1 (Andrews & Curtis 1965): J. J. Andrews and M. L. Curtis (Proc. AMS, DOI DOI 10.2307/2033843[Scite ↗]) asked whether every balanced finite presentation of the trivial group can be reduced to the empty identity ⟨x_1, …, x_n | x_1, …, x_n⟩ using only relator inversion, relator multiplication (i ≠ j), and free-group conjugation—excluding stabilization by extra generator/relator pairs.
Operator Coupling & Invariant Closure: At Stage 1 of the Folio M.14 derivation chain, the intermediate state maps directly onto the governing law AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves under benchmark regime AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization. To ensure that deductive or physical flux is conserved without unverified hand-waving as the system advances from Stage 1 toward terminal convergence, the transition operator enforces the companion verification constraint: Allow strictly the three Andrews–Curtis operations: relator inversion r_i -> r_i^-1, relator multiplication r_i -> r_i r_j (i != j), and free-group conjugation r_i -> w r_i w^-1; never insert extra generators. Every numerical trajectory and geometric projection in Plate M.14-A and Plate M.14-B below evaluates this exact stage transfer function in real time.
Stage 2 Derivation & State Transition
Formal Stage Mechanism: Stage 2 (4-Manifold Topology & Akbulut–Kirby Pairs): Selman Akbulut and Robion Kirby (Topology 1985, DOI DOI 10.1016/0040-9383(85)90010-2[Scite ↗]) constructed infinite families such as AK(n) = ⟨x, y | x y x = y x y, xⁿ = yⁿ⁺¹⟩ arising from 4-manifold handleslides, generating classic stress tests for combinatorial search.
Operator Coupling & Invariant Closure: At Stage 2 of the Folio M.14 derivation chain, the intermediate state maps directly onto the governing law AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves under benchmark regime AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization. To ensure that deductive or physical flux is conserved without unverified hand-waving as the system advances from Stage 2 toward terminal convergence, the transition operator enforces the companion verification constraint: Maintain free-group cancellation g g^-1 -> eps at every multiplication and conjugation seam, and evaluate candidate reductions without assuming greedy length monotonicity. Every numerical trajectory and geometric projection in Plate M.14-A and Plate M.14-B below evaluates this exact stage transfer function in real time.
Stage 3 Derivation & State Transition
Formal Stage Mechanism: Stage 3 (Non-Monotonic Search Landscapes & AK(2) Trace): Even simple trivializations are non-monotonic. Running skills/math/m14/verify_m14_andrews_curtis_moves.py replays 23 elementary AC moves on AK(2), temporarily swelling total relator length from 11 up to 14 before collapsing cleanly to ⟨x, y | x, y⟩ (length 2).
Operator Coupling & Invariant Closure: At Stage 3 of the Folio M.14 derivation chain, the intermediate state maps directly onto the governing law AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves under benchmark regime AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization. To ensure that deductive or physical flux is conserved without unverified hand-waving as the system advances from Stage 3 toward terminal convergence, the transition operator enforces the companion verification constraint: Verify the explicit 23-move AK(2) trivialization trace offline with python -X utf8 skills/math/m14/verify_m14_andrews_curtis_moves.py and check --planted-defect detection. Every numerical trajectory and geometric projection in Plate M.14-A and Plate M.14-B below evaluates this exact stage transfer function in real time.
Stage 4 Derivation & State Transition
Formal Stage Mechanism: Stage 4 (AI Search & SAIR Challenge): Deep reinforcement learning and discrete search methods (Gukov et al. 2021, DOI DOI 10.1088/2632-2153/abe91f[Scite ↗]) explore super-exponential AC move graphs; the SAIR Andrews–Curtis Conjecture Challenge (https://competition.sair.foundation/) benchmarks open search algorithms on harder balanced presentations.
Operator Coupling & Invariant Closure: At Stage 4 of the Folio M.14 derivation chain, the intermediate state maps directly onto the governing law AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves under benchmark regime AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization. To ensure that deductive or physical flux is conserved without unverified hand-waving as the system advances from Stage 4 toward terminal convergence, the transition operator enforces the companion verification constraint: Allow strictly the three Andrews–Curtis operations: relator inversion r_i -> r_i^-1, relator multiplication r_i -> r_i r_j (i != j), and free-group conjugation r_i -> w r_i w^-1; never insert extra generators. Every numerical trajectory and geometric projection in Plate M.14-A and Plate M.14-B below evaluates this exact stage transfer function in real time.
Every quantitative claim in Folio M.14 is tied to three falsification rules listed in sair-andrews-curtis-moves-SKILL.md and executed by skills/math/m14/verify_m14_andrews_curtis_moves.py:
Invariant M.14-R1: Allow strictly the three Andrews–Curtis operations: relator inversion r_i -> r_i^-1, relator multiplication r_i -> r_i r_j (i != j), and free-group conjugation r_i -> w r_i w^-1; never insert extra generators.
Recomputed offline by skills/math/m14/verify_m14_andrews_curtis_moves.py; primary anchor DOI 10.2307/2033843.
Invariant M.14-R2: Maintain free-group cancellation g g^-1 -> eps at every multiplication and conjugation seam, and evaluate candidate reductions without assuming greedy length monotonicity.
Recomputed offline by skills/math/m14/verify_m14_andrews_curtis_moves.py; primary anchor DOI 10.2307/2033843.
Invariant M.14-R3: Verify the explicit 23-move AK(2) trivialization trace offline with python -X utf8 skills/math/m14/verify_m14_andrews_curtis_moves.py and check --planted-defect detection.
Recomputed offline by skills/math/m14/verify_m14_andrews_curtis_moves.py; primary anchor DOI 10.2307/2033843.
Together, Invariants M.14-R1 through M.14-R3 close the epistemic loop between symbolic derivation and numerical execution. If a code edit violates these bounds, the verifier fails.
Primary Counterfactual Knockout (SIDENOTE M.14-A · STABLE VS. UNSTABLE MOVES): If you allow adding and later removing a temporary extra generator z with relator z = 1 (stabilization), any two presentations of the same finitely presented group become Tietze-equivalent. The Andrews–Curtis Conjecture asks whether balanced trivial presentations ever force such temporary extra generators.
Secondary Coupling & Regime Boundary (SIDENOTE M.14-B · NON-MONOTONIC VALLEY CROSSING): Greedy solvers minimizing relator word length fail immediately on Akbulut–Kirby pairs because early AC moves must lengthen relators (11 → 14 symbols in AK(2)) to align opposite generator inverses before cancellation triggers.
Mathematical & Physical Necessity of the Full Operator: Testing a theorem or physical law by knocking out its core hypothesis is one of the sharpest ways a human mind builds intuition. This counterfactual analysis shows why every coupling term in AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves is indispensable: When the primary control parameter is dragged to its degenerate boundary in the Act III observatory below, the stabilizing restorative term vanishes, reproducing the classical collapse predicted by theory and illustrating that our solver is an interactive computational model rather than a static animation.
Act III — Interactive Laboratory & Worked Numerical Verification
§ III.1 · Three Guided Experiments to Try
Experiment 1 (Akbulut–Kirby Index k): Increase k from 1 to 5 and compare initial symbol lengths 2k + 7 across the family while noting |det(Ab)| stays identically equal to 1.
Experiment 2 (Trace Budget): Sweep the elementary AC move counter across 0..23 moves on AK(2) to watch word length climb from 11 to 14 mid-search and then drop to 2.
Experiment 3 (Counterfactual ⚡): Run python -X utf8 skills/math/m14/verify_m14_andrews_curtis_moves.py --planted-defect to strip the inverse from free-group conjugation and watch the trace diverge from ⟨x, y | x, y⟩.
Stage 1 (Andrews & Curtis 1965): J. J. Andrews and M. L. Curtis (Proc. AMS, DOI 10.2307/2033843) asked whether every balanced finite presentation of the trivial group can be reduced to the empty identity ⟨x_1, …, x_n | x_1, …, x_n⟩ using only relator inversion, relator multiplication (i ≠ j), and free-group conjugation—excluding stabilization by extra generator/relator pairs.
Governing Law (M.14):AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves
Plate M.14-B · 3D Akbulut–Kirby Presentation Word-Length & Conjugation Barrier Surface (Drag to Orbit 360°)
3D Surface Axes: X: Akbulut–Kirby Index k · Z: Elementary AC Step t · Y: Relator Length Horizon
AK(2) Initial → Peak → Final Length11 → 14 → 2 (⟨x, y | x, y⟩)
Elementary AC Moves Replayed (AK(2))23 valid free-group moves
Conjecture Open StatusOpen since 1965 (stable AC uses Tietze add)
§ III.2 · Worked Numerical Verification & Reference Telemetry Benchmark
To verify the interactive observatory above by hand or inside an independent computational notebook, we evaluate the governing law AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves at the canonical benchmark configuration (AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization). Substituting control parameter P_1 (Akbulut–Kirby Parameter (k)) spanning the admissible interval [1, 5] with step resolution Δ = 1 and canonical reference operating point k = 2; control parameter P_2 (Elementary AC Move Trace Budget (moves)) spanning the admissible interval [5, 30] with step resolution Δ = 1 and canonical reference operating point moves = 23 into the coupled Stage 1–4 equations yields the reference values recomputed by the verifier: AK(2) Initial → Peak → Final Length converges to 11 → 14 → 2 (⟨x, y | x, y⟩); Elementary AC Moves Replayed (AK(2)) converges to 23 valid free-group moves; AK(3) Initial Length & |det(Ab)| converges to 13 symbols · |det| = 1 (trivial Z⁰); Conjecture Open Status converges to Open since 1965 (stable AC uses Tietze add).
Running python skills/math/m14/verify_m14_andrews_curtis_moves.py from the repository root recomputes these values, and its planted-defect mode must fail.
Act IV — Search Policies Beyond Greedy Heuristics
Modern reinforcement learning and neuro-symbolic rewrite systems bring fresh stamina to move graphs that dwarf manual pen-and-paper bookkeeping. Rather than asking a neural network to declare a presentation trivial by intuition alone, architectures guided by Gukov et al. (2021) and benchmarked in SAIR’s challenge emit explicit sequence-of-move witnesses whose algebraic validity is checked in microseconds by deterministic free-group engines.
Whether researchers eventually establish the full conjecture across all 2-relator presentations or isolate a genuine counterexample linked to exotic smooth 4-spheres, progress hinges on transparent move traces, canonical state hashing, and shared benchmark families spanning AK(n), Miller–Schupp, and random balanced presentations.
§ IV.3 · Cross-Disciplinary Continuum & Systems Transfer
Structural & Mathematical Isomorphism (Extends M.04/M.10 · Untangling a pair of knotted handlebody loops when intermediate loops must briefly lengthen): One of the defining principles of Informatico.ai is that deep governing operators transcend disciplinary silos. The exact mathematical structure of Folio M.14 (AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves) reappears across coupled multiscale systems: Mathematics Pillar Monograph M.14 (VOL. 07): Non-monotonic combinatorial group rewriting and witnessed state-space search bridging 4-manifold handlebodies and AI planning.
Living Edition & Multi-Family Council Provenance (REV 1.0): REV 1.0 (Published 2026-11-15): Volume VII SAIR Research Folio introducing the Andrews–Curtis Conjecture (Andrews & Curtis 1965), Akbulut–Kirby families (1985), ML search benchmarks (Gukov et al. 2021), and exact AK(2) AC replay verifier verify_m14_andrews_curtis_moves.py. All primary DOIs verified via Crossref and Scite (Andrews 1965: 36 citing publications, 0 retractions); explicit 23-step AK(2) reduction trace executed and checked cleanly. By pairing multi-chapter mathematical and physical derivations with interactive WebGL2/SVG observatories and downloadable SKILL.md companions, Folio M.14 equips engineers, mathematicians, physicists, and AI agents with a permanent, falsifiable building block for frontier discovery.
Act V — Sources
Andrews, J. J., & Curtis, M. L. (1965). Free groups and handlebodies. Proceedings of the American Mathematical Society, 16(2), 192–195. DOI DOI 10.2307/2033843[Scite ↗].
Akbulut, S., & Kirby, R. (1985). A potential smooth counterexample in dimension 4 to the Poincaré conjecture, the Schoenflies conjecture, and the Andrews–Curtis conjecture. Topology, 24(4), 375–390. DOI DOI 10.1016/0040-9383(85)90010-2[Scite ↗].
Gukov, S., Halverson, J., Ruehle, F., & Sułkowski, P. (2021). Learning to unknot. Machine Learning: Science and Technology, 2(2), 025035. DOI DOI 10.1088/2632-2153/abe91f[Scite ↗].
Nicholson, J. M., et al. (2021). scite: A smart citation index that displays the context of citations and classifies their intent using deep learning. Quantitative Science Studies, 2(3), 882–898. DOI DOI 10.1162/qss_a_00146[Scite ↗].
SAIR Foundation Competitions (2026). Andrews–Curtis Conjecture Challenge. https://competition.sair.foundation/ ; XTX Markets Philanthropy Update (2026-09-16): https://aimoprize.com/updates/2026-09-16-update-on-xtx-markets-ai-philanthropy.
Inspired by classic broadsheet crosswords: test your command of M.14’s governing laws and historical turning points. Switch to ES-MX in the masthead to unlock a completely independent Spanish crossword with its own grid and scientific vocabulary.
EN · INDEPENDENT ENGLISH EDITION (10×10)
0 / 50 Folios Sealed (EN: 0 · ES-MX: 0)
1 ACROSSSelect any cell or clue below to begin solving.
Across
Down
Select any cell or clue and type A–Z. Space toggles Across/Down; progress auto-saves to localStorage.
Give any AI agent or engineering pipeline the governing equations of Folio M.14: a portable SKILL.md, a zero-dependency Python verifier (verify_m14_andrews_curtis_moves.py), or the live telemetry as JSON.
Show the SKILL.md source
---
name: sair-andrews-curtis-moves
description: AI-agnostic combinatorial group theory skill for Folio M.14: Andrews–Curtis equivalence moves in free groups ⟨x, y⟩, Akbulut–Kirby AK(n) benchmark presentations, and explicit replay via skills/math/m14/verify_m14_andrews_curtis_moves.py.
license: MIT
compatibility: Claude Code, GitHub Copilot, Cursor, Google Antigravity, OpenAI Codex, Ollama (Qwen 3.8 / Gemma 4)
---
# The Andrews–Curtis Conjecture & SAIR Challenge: Balanced Presentations, 4-Manifold Handles & Akbulut–Kirby Pairs (Folio M.14)
A plain-text companion to the essay at https://informatico.ai/math/m14/ (`M.14 · Andrews–Curtis Conjecture & SAIR Search Challenge (competition.sair.foundation)`, `REV 1.0`, redated `2026-11-15`).
## The governing relation
`AC moves {r_i ↦ r_i⁻¹, r_i ↦ r_i r_j (i≠j), r_i ↦ w r_i w⁻¹} · AK(2) = ⟨x, y | x y x = y x y, x² = y³⟩ (length 11) collapses to ⟨x, y | x, y⟩ (length 2) in 23 moves`
## Rules the essay derives
1. Allow strictly the three Andrews–Curtis operations: relator inversion r_i -> r_i^-1, relator multiplication r_i -> r_i r_j (i != j), and free-group conjugation r_i -> w r_i w^-1; never insert extra generators.
2. Maintain free-group cancellation g g^-1 -> eps at every multiplication and conjugation seam, and evaluate candidate reductions without assuming greedy length monotonicity.
3. Verify the explicit 23-move AK(2) trivialization trace offline with python -X utf8 skills/math/m14/verify_m14_andrews_curtis_moves.py and check --planted-defect detection.
## How it works, in four stages
- Stage 1 (Andrews & Curtis 1965): J. J. Andrews and M. L. Curtis (Proc. AMS, DOI 10.2307/2033843) asked whether every balanced finite presentation of the trivial group can be reduced to the empty identity ⟨x_1, …, x_n | x_1, …, x_n⟩ using only relator inversion, relator multiplication (i ≠ j), and free-group conjugation—excluding stabilization by extra generator/relator pairs.
- Stage 2 (4-Manifold Topology & Akbulut–Kirby Pairs): Selman Akbulut and Robion Kirby (Topology 1985, DOI 10.1016/0040-9383(85)90010-2) constructed infinite families such as AK(n) = ⟨x, y | x y x = y x y, xⁿ = yⁿ⁺¹⟩ arising from 4-manifold handleslides, generating classic stress tests for combinatorial search.
- Stage 3 (Non-Monotonic Search Landscapes & AK(2) Trace): Even simple trivializations are non-monotonic. Running skills/math/m14/verify_m14_andrews_curtis_moves.py replays 23 elementary AC moves on AK(2), temporarily swelling total relator length from 11 up to 14 before collapsing cleanly to ⟨x, y | x, y⟩ (length 2).
- Stage 4 (AI Search & SAIR Challenge): Deep reinforcement learning and discrete search methods (Gukov et al. 2021, DOI 10.1088/2632-2153/abe91f) explore super-exponential AC move graphs; the SAIR Andrews–Curtis Conjecture Challenge (https://competition.sair.foundation/) benchmarks open search algorithms on harder balanced presentations.
## Reference values stated in the essay
- **AK(2) Initial → Peak → Final Length**: `11 → 14 → 2 (⟨x, y | x, y⟩)`
- **Elementary AC Moves Replayed (AK(2))**: `23 valid free-group moves`
- **AK(3) Initial Length & |det(Ab)|**: `13 symbols · |det| = 1 (trivial Z⁰)`
- **Conjecture Open Status**: `Open since 1965 (stable AC uses Tietze add)`
## Check it yourself
This skill ships a verifier that recomputes its values. Its planted-defect mode must fail:
```
python skills/math/m14/verify_m14_andrews_curtis_moves.py
python skills/math/m14/verify_m14_andrews_curtis_moves.py --planted-defect
```
## Primary source
- https://doi.org/10.2307/2033843 (Scite report: https://scite.ai/reports/10.2307/2033843)
- What the essay compares against: AK(2) total length 11 → trivial length 2 in 23 AC moves (peak intermediate length 14); AK(3) starts at length 13 with |det| = 1 trivial abelianization
## Recent research context
- **Andrews–Curtis Search Challenge Tests Non-Monotonic Free-Group Planners**: Originating in Andrews & Curtis (1965, DOI 10.2307/2033843) and Akbulut & Kirby (1985, DOI 10.1016/0040-9383(85)90010-2), balanced group trivializations become a clean open benchmark at SAIR (https://competition.sair.foundation/).
#!/usr/bin/env python3
"""Deterministic Andrews-Curtis move verifier for Folio M.14.
Executes a free-group presentation engine over <x, y> supporting the three
Andrews-Curtis moves: relator inversion (INV), relator multiplication (MUL_L/MUL_R),
and free-group conjugation (CONJ). Replays an explicit 23-step elementary AC sequence
reducing Akbulut-Kirby AK(2) = <x, y | x y x = y x y, x^2 = y^3> (total relator length 11)
to <x, y | x, y> (total length 2). Passing --planted-defect drops the inverse on
conjugation (w r w instead of w r w^-1), causing reduction to fail.
"""
from __future__ import annotations
import argparse
import json
import sys
Word = tuple[tuple[str, int], ...]
X: Word = (("x", 1),)
XI: Word = (("x", -1),)
Y: Word = (("y", 1),)
YI: Word = (("y", -1),)
AK2_TRIVIALIZING_TRACE: list[tuple[str, int, Word]] = [
("CONJ", 1, YI),
("INV", 1, ()),
("CONJ", 0, YI),
("MUL_R", 1, ()),
("CONJ", 1, YI),
("MUL_L", 0, ()),
("CONJ", 0, YI),
("INV", 1, ()),
("MUL_R", 0, ()),
("CONJ", 0, X),
("CONJ", 0, YI),
("MUL_L", 1, ()),
("CONJ", 0, XI),
("INV", 0, ()),
("CONJ", 1, YI),
("MUL_R", 0, ()),
("CONJ", 0, X),
("INV", 1, ()),
("MUL_R", 1, ()),
("MUL_L", 0, ()),
("MUL_R", 1, ()),
("INV", 0, ()),
("INV", 1, ()),
]
def free_reduce(word: Word) -> Word:
stack: list[tuple[str, int]] = []
for gen, sign in word:
if stack and stack[-1][0] == gen and stack[-1][1] == -sign:
stack.pop()
else:
stack.append((gen, sign))
return tuple(stack)
def invert_word(word: Word) -> Word:
return tuple((gen, -sign) for gen, sign in reversed(word))
def apply_ac_move(
relators: list[Word],
op: str,
target_idx: int,
conjugator: Word = (),
defect: bool = False,
) -> list[Word]:
out = list(relators)
other_idx = 1 - target_idx
if op == "INV":
out[target_idx] = invert_word(out[target_idx])
elif op == "MUL_R":
out[target_idx] = free_reduce(out[target_idx] + out[other_idx])
elif op == "MUL_L":
out[target_idx] = free_reduce(out[other_idx] + out[target_idx])
elif op == "CONJ":
right_side = conjugator if defect else invert_word(conjugator)
out[target_idx] = free_reduce(conjugator + out[target_idx] + right_side)
else:
raise ValueError(f"Unknown AC move: {op}")
return out
def ak_presentation(n: int) -> list[Word]:
r1 = free_reduce(X + Y + X + YI + XI + YI)
r2 = free_reduce((X * n) + (YI * (n + 1)))
return [r1, r2]
def abelianization_det(relators: list[Word]) -> int:
"""Compute |det| of 2x2 exponent-sum matrix for <x, y | r1, r2>."""
rows = []
for w in relators:
cx = sum(p for g, p in w if g == "x")
cy = sum(p for g, p in w if g == "y")
rows.append((cx, cy))
return abs(rows[0][0] * rows[1][1] - rows[0][1] * rows[1][0])
def verify(planted_defect: bool = False) -> tuple[bool, dict[str, object]]:
ak2 = ak_presentation(2)
ak3 = ak_presentation(3)
cur = list(ak2)
max_word_len = len(cur[0]) + len(cur[1])
for op, idx, conj in AK2_TRIVIALIZING_TRACE:
cur = apply_ac_move(cur, op, idx, conj, defect=planted_defect)
max_word_len = max(max_word_len, len(cur[0]) + len(cur[1]))
trivialized = set(cur) == {X, Y}
ak2_abel_trivial = abelianization_det(ak2) == 1
ak3_abel_trivial = abelianization_det(ak3) == 1
ak2_len = sum(len(r) for r in ak2)
ak3_len = sum(len(r) for r in ak3)
ok = trivialized and ak2_abel_trivial and ak3_abel_trivial and (ak2_len == 11) and (ak3_len == 13)
payload: dict[str, object] = {
"folio_id": "M.14",
"status": "PASS" if ok else "FAIL",
"ak2_initial_length": ak2_len,
"ak3_initial_length": ak3_len,
"ak2_abelianization_det": abelianization_det(ak2),
"ak3_abelianization_det": abelianization_det(ak3),
"ac_moves_replayed": len(AK2_TRIVIALIZING_TRACE),
"max_intermediate_length": max_word_len,
"final_total_length": sum(len(r) for r in cur),
"reached_trivial_basis": trivialized,
"planted_defect": planted_defect,
}
return ok, payload
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description="Verify explicit AK(2) Andrews-Curtis reduction sequence for Folio M.14.")
parser.add_argument("--planted-defect", action="store_true", help="Drop inverse on free-group conjugation.")
args = parser.parse_args(argv)
ok, payload = verify(planted_defect=args.planted_defect)
print(json.dumps(payload, indent=2))
return 0 if ok else 1
if __name__ == "__main__":
raise SystemExit(main(sys.argv[1:]))
Edition history & reviewPublished 2026-11-15 · Updated 2026-11-15 (REV 1.0)
REV 1.0 (Published 2026-11-15): Volume VII SAIR Research Folio introducing the Andrews–Curtis Conjecture (Andrews & Curtis 1965), Akbulut–Kirby families (1985), ML search benchmarks (Gukov et al. 2021), and exact AK(2) AC replay verifier verify_m14_andrews_curtis_moves.py.
All primary DOIs verified via Crossref and Scite (Andrews 1965: 36 citing publications, 0 retractions); explicit 23-step AK(2) reduction trace executed and checked cleanly.