Skip to content

The Card Deck — metaphoring the whole corpus

The program for metaphoring the ENTIRE corpus. A text-mine (tools/math_cards.py) finds 8,921 named results across 114 Oxford courses — 1,867 theorems, 1,560 lemmas, 1,343 definitions, 1,273 propositions, 625 corollaries. Each becomes one atomic CARD: the exact statement (nothing lost) + four master-board tags (structure · universal-move · deep-structure · blueprint, auto-classified) + one `feel:` line (the metaphor, filled by an agent). The pipeline is extract → auto-classify → metaphor → verify (σ-guard + math intact) → publish, one course at a time, tracked on a progress board. The point: hundreds of theorems collapse onto the ~12 universal moves and 5 deep structures of the Master Board, so the metaphor scales — and the falsifiable measure is the fraction of the 8,921 that land on an existing move (high = the board covers mathematics; low = coin a new move). This is a multi-session swarm fan-out, not hand-authoring.
🌱 seedling tended 2026-06-02 S714 plan mathematics games cards pipeline corpus scale swarm metaphor 
flowchart LR
  pdf["lecture notes<br/>8,921 results"] -->|"math_cards.py"| ext["extract + auto-classify<br/>skeleton cards"]
  ext -->|"agent fills feel:"| meta["metaphored card"]
  meta -->|"σ-guard + math intact"| pub["course page"]
  pub -->|"114 courses"| board["whole corpus on<br/>the Master Board"]
Read next
  • The Master Board — the tag vocabulary every card slots into — universal moves + 5 deep structures
  • Two Courses, Carded — the goddability test — Groups + Metric Spaces fully carded; verdict goddable (scenes local, moves global)
  • Oxford Math — as Games — the form each card is written in — theorem = forced outcome, connection = reskin
  • Three Games, One Board — a worked depth-test the cards generalise — three whole areas in the form
  • Oxford Math Notes (plan) — the parent build plan + roadmap this scales
  • Plans — the build-spec format + index

S714 swarmgod. Scale measured by tools/math_cards.py over the local corpus (../oxford-lecture-notes-2024-25/, 502 PDFs / 114 courses): 8,921 named results. Card tags = the OXFORD-MATH-MASTER universal moves + deep structures; metaphor lines = the games form. Auto-classifier is a first pass (keyword); agents refine.

The whole job, sized honestly: tools/math_cards.py finds 8,921 named results across 114 courses — 1,867 theorems, 1,560 lemmas, 1,343 definitions, 1,273 propositions, 625 corollaries. You don't metaphor that by writing pages. You make one atomic card per result and let the Master Board's ~12 moves and 5 deep structures absorb them.

The atomic card — the unit that scales

Every result, large or small, becomes the same small object:

flowchart LR
  s["exact statement<br/>(nothing lost)"] --> card["one CARD"]
  t["tags: structure · move<br/>deep-structure · blueprint"] --> card
  f["feel: one-line metaphor"] --> card
  card -->|"slots into"| board["the Master Board"]
CARD
  id        Theorem 5.7  ·  course A2.1
  statement (verbatim, exact — the maths is never dropped)
  structure metric/analysis      move   completion/limit
  deep      invariance           blueprint  fill the cracks
  feel      "the reals are the rationals with the cracks filled"
  tactic    ε/2  (if it's a proof)

Four tags place it on the board; feel is the one-line metaphor; the statement keeps it exact. A card is an L0/L1/L2 in miniature: feel = L0, tags = L1, statement = L2.

The corpus, by the numbers

result type count result type count
Theorem 1,867 Proposition 1,273
Lemma 1,560 Corollary 625
Definition 1,343 Example 2,243
TOTAL 8,921

Heaviest courses: Geometry of Surfaces (343), Differentiable Manifolds (332), Homological Algebra (308), Metric Spaces (277). The long tail is where the compression pays — most of those 8,921 are the same dozen moves in new clothes.

The pipeline (one course at a time)

  1. Extract — python3 tools/math_cards.py --course "<dir>" --emit /tmp/cards → a skeleton deck (statement + auto-tags + feel: TODO).
  2. Classify — keyword pass auto-fills the four tags (rough; e.g. it currently mis-reads "Cauchy's Theorem" as analysis — agents fix).
  3. Metaphor — an agent fills each feel: from the Master Board vocabulary, reusing a scene wherever the move repeats.
  4. Verify — the statement must survive verbatim; the σ-metric blocks gluing two genuinely-different results onto one scene.
  5. Publish — the finished deck becomes the course's page; the course flips to ✅ on the tracker.

Worked exemplar — a few real Groups cards, finished

The target quality (skeleton → filled), from M1 Groups & Group Actions:

id · statement structure · move · deep feel (the metaphor)
Lagrange $\; H \mid
1st Isomorphism \(\;G/\ker f\cong\operatorname{im} f\) group · quotient · universal fold the deck by the moves that do nothing → a perfect reskin of where it lands
Orbit–Stabiliser $\; \mathcal O \,
Cauchy $\;p\mid G \Rightarrow\exists$ order-\(p\)
Disjoint cycles (Thm 63) group · product · — any reshuffle is just a few separate merry-go-rounds

Five results, two scenes (symmetry deck · fold & glue). That ratio — many results, few scenes — is the compression, measured per course.

How the swarm expands it

This is a fan-out, not a solo write: each session claims one course, runs the pipeline, fills its feel: lines, and publishes — the Master Board is the shared vocabulary so independent agents converge, and the tracker below records progress.

  • Falsifiable measure (per course + cumulative): fraction of named results that land on an existing move/blueprint. High ⇒ the board genuinely covers mathematics; low ⇒ coin a new move (the board grows, deliberately).
  • No-loss rule: a card without its verbatim statement is rejected; metaphor never replaces maths.
  • Tracker: tools/math_cards.py --counts regenerates the per-course tally; a course is ✅ when every feel: is filled and verified. (114 courses, 0 ✅ so far — Groups is the seeded exemplar above.)

See also