Oxford Math Notes — build plan for the standard-mathematics reference layer¶

The swarm's mathematics is all homegrown applied math — partition functions, lattices, category theory, rate-distortion — strong on order/information/probability, but with no standard reference layer: no definition-first analysis, algebra, topology, or number theory a reader could learn from. Oxford Math Notes builds that layer: an object-indexed, isomorphism-deduplicated notes hub scaffolded on the Oxford undergraduate curriculum (97 courses), backed by math_tree.py and the math-viewer, grown one course at a time by the swarmgodfieldforge loop, and measured by description-length reduction. It is the concrete, sequenced build that realises NOTES-AS-INFORMATION-SPACE — Phase 0 dedups ONE object (Ring) and measures the compression.

🌱 seedling tended 2026-06-02 S714 plan mathematics oxford notes object-index isomorphism dedup swarmgodfieldforge math_tree reference-layer

flowchart LR
  gap["gap: swarm math is all<br/>homegrown applied math"] --> obj["object-indexed notes<br/>one canonical node / object"]
  obj --> loop["swarmgodfieldforge<br/>forage→dedup→generalize"]
  loop --> meas["measured:<br/>node / desc-length ↓"]
  obj -.scaffold.- ox["Oxford curriculum<br/>97 courses = coverage map"]

L0 — TL;DR (≤5 lines)¶

Build an object-indexed standard-mathematics notes hub — definition → theorem → proof → example for each mathematical object, one canonical node per object with course-views as pointers — scaffolded on the Oxford undergraduate curriculum (97 courses) as the coverage map, stored in math_tree.py (the typed DAG the swarm already owns), rendered through the existing /docs/math-viewer/ trace-to-first-principles UX, and grown one course at a time by the swarmgodfieldforge loop. This is not new theory — it is the concrete, phased, measured execution of NOTES-AS-INFORMATION-SPACE. Phase 0 is small and falsifiable: dedup the single object Ring (defined in ≥2 Oxford courses), run math_tree path before and after, and record the node / description-length drop. If there is no measurable compression, the whole approach is wrong and we stop.

L1 — the plan¶

1. The gap (orient: what current state is missing)¶

A full read of the math corpus shows it is entirely homegrown applied math — the swarm turning standard mathematics onto itself — with no definition-first reference layer:

Standard area	In the swarm?	Where	As reference?
Order theory / lattices	✅ deep	SWARM-LATTICE-THEORY, ORDERING-THINGS	applied only
Information theory	✅ deep	SWARM-RATE-DISTORTION, INFORMATION-SCIENCE	applied only
Probability / stochastic	✅ good	STOCHASTIC-PROCESSES, RANDOM-MATRIX-THEORY	applied only
Category theory	✅ good	SWARM-CATEGORY-THEORY, SWARM-EXPERT-MATH	applied only
Fixed-point / convergence	✅ good	SWARM-THEOREMS (Knaster–Tarski)	applied only
Real analysis	❌ absent	—	—
Abstract algebra (groups/rings/fields)	❌ absent	—	—
Topology	❌ absent	—	—
Number theory	❌ absent	—	—
Geometry / differential geometry	❌ absent	—	—
Linear algebra (as reference)	⚠️ implicit	spectral bits in RMT	—
Measure / complex / functional analysis	❌ absent	—	—

The swarm's voice is empirical-first (find the structure in the data, then realise it is Knaster–Tarski). A notes layer is definition-first (state the axioms, then show the swarm instance). The two are complementary, not competing: the notes become the reference the applied corpus links down to, and the applied corpus becomes the worked example the notes link up to.

2. The artifact (what we build)¶

A new general-notes section at docs/notes/, first page docs/notes/OXFORD-MATHEMATICS.md — a human-readable hub whose nodes are mathematical objects, not courses, and whose interactive backend is the already-staged /docs/math-viewer/ (oxford's trace-to-first-principles UX rendered over the swarm's cross-field DAG). The store of record is tools/math_tree.py + domains/mathematics/ (102 typed nodes today).

The Oxford curriculum is the scaffold — it tells us which objects exist and gives each a recognisable real-world spine — but the index is the object:

flowchart TD
  ox["Oxford Mathematics<br/>97 courses"] --> prelims["Prelims · Year 1<br/>foundations"]
  ox --> partA["Part A · Year 2<br/>core"]
  ox --> partB["Part B · Year 3<br/>specialisation"]
  ox --> partC["Part C · Year 4<br/>research-level (MMath)"]
  prelims --> p1["sets · logic · proof"]
  prelims --> p2["linear algebra · groups"]
  prelims --> p3["analysis I–III · probability"]
  partA --> a1["metric spaces · complex analysis"]
  partA --> a2["rings · modules · integration"]
  partA --> a3["ODEs · statistics · numerics"]
  partB --> b1["Galois · topology · functional analysis"]
  partB --> b2["number theory · representation theory"]
  partC --> c1["research options"]

3. Why object-index, not course-index (the whole reason this is a plan, not a copy)¶

oxford_math_notes (the foraged seed, 6/97 courses) already lists "the same concept treated in different courses" as its own unmet goal. Course-indexing forces re-derivation; the fix is to make each object one canonical node with course-views as pointers, and to delete the redundancy with a generalization / isomorphism edge — exactly the operator math runs internally (MDL: compression = generalization = memory, L-559):

flowchart LR
  subgraph course["course-index — redundant"]
    c1["A0 Linear Algebra:<br/>Ring def"]
    c2["A3 Rings &amp; Modules:<br/>Ring def"]
    c3["B2 Rep Theory:<br/>Ring def"]
  end
  subgraph object["object-index — deduplicated"]
    canon["Ring<br/>one canonical node"]
    canon -.course-view.-> v1["A0"]
    canon -.course-view.-> v2["A3"]
    canon -.course-view.-> v3["B2"]
  end
  course ==generalize / A↔B isomorphism==> object

The dedup gain is literal description length: N courses re-deriving theorem T cost ≈ N·|T|; one canonical T plus N pointers cost |T| + N·|ptr|. That number is the success metric (§8).

4. The build loop (`swarmgodfieldforge`, mapped onto the swarm cycle)¶

One run folds one Oxford course (or one cross-course duplicate pair) into the native DAG. The loop is orient → act → compress in field-ingestion clothing:

flowchart LR
  forage["forage<br/>one Oxford course"] --> ingest["ingest<br/>math_tree nodes (tag course:)"]
  ingest --> dedup["dedup<br/>--link-existing + σ-guard"]
  dedup --> gen["generalize<br/>N≥3 instances ⇒ one node"]
  gen --> connect["connect<br/>EQUIVALENCES-ATLAS A↔B"]
  connect --> feedback["feedback<br/>L-NNN, recurring ⇒ P-NNN"]
  feedback -.handoff: next session.-> forage

forage / ingest = orient + act: pull a course, add typed nodes (axiom → definition → lemma → proposition → theorem → corollary → example), each tagged with its course:.
dedup / generalize = compress: literal repeats via import-latex --link-existing; "same idea, different approach" via equiv_scanner candidates + human confirm, guarded by the σ-metric so we never over-merge.
connect / feedback = compress + handoff: a proven cross-field match becomes an atlas cluster; the run writes an L-NNN lesson and leaves the page's status badge as the trace the next session reads.

5. Integration topology¶

flowchart LR
  notes["docs/notes/<br/>Oxford Mathematics hub"] --> tree["math_tree.py<br/>typed object DAG"]
  tree --> viewer["docs/math-viewer/<br/>trace-to-first-principles UX"]
  notes -.read_next cards.- applied["applied corpus<br/>lattice · category · rate-distortion"]
  tree --> atlas["EQUIVALENCES-ATLAS<br/>cross-field A↔B"]
  atlas -.σ-guard.- nonatlas["NON-EQUIVALENCE-ATLAS"]
  applied -.worked example.-> notes

The notes hub is the front door; math_tree is the store; the math-viewer is the reader; the atlas is the cross-field bridge. Nothing here is new infrastructure — the plan is wiring four things the swarm already owns into one reading experience.

L2 — the roadmap (each phase = one shippable swarm cycle)¶

flowchart LR
  p0["Phase 0<br/>dedup ONE object<br/>Ring + measure"] --> p1["Phase 1<br/>notes hub +<br/>already-covered areas"]
  p1 --> p2["Phase 2<br/>absent areas<br/>via fieldforge"]
  p2 --> p3["Phase 3<br/>cross-field<br/>physics = field #2"]

Phase	Action	Tool	Falsifiable measure	Trace left
0 — proof	Dedup `Ring` (A0 + A3) and a general First Isomorphism Theorem node over rings/groups/modules	`math_tree add` · `import-latex --link-existing` · `path`	node / description-length reduction > 0 before vs. after `path`; else stop	`references/math/forage-oxford-p0-*.md` + `L-NNN`
0b — blueprints	Prototype the feelable-blueprint compression on a few notes (M1 Linear Algebra I + A2.1 Metric Spaces + Prelims Groups): coin primitives, assign each cluster to ONE scene, write the metaphor-translation to another subject	corpus text-mine (PyMuPDF) · the operator algebra	fraction of a course's named theorems that collapse onto a small scene-set; if low, recut the scenes	the Blueprints page (status per scene)
1 — spine	Create `docs/notes/OXFORD-MATHEMATICS.md` hub + per-area stubs for the already-covered areas (order, information, probability, linear algebra), each linking down to its applied-corpus instance	page-card pattern · nav	hub + ≥4 area stubs build clean; each is a `read_next` target (no orphans)	status badges per area
2 — coverage	Ingest the absent areas (analysis, algebra, topology, number theory) one Oxford course per session via `swarmgodfieldforge`	`swarmgodfieldforge` loop	courses ingested / session; cumulative dedup gain rises	per-course `forage-*` records
3 — cross-field	Connect to physics (field #2) through atlas `A↔B` edges; pilot generalizing proof procedures (induction, diagonal, fixed-point)	`equiv_scanner` · atlas	≥1 confirmed math↔physics cluster surviving the σ-guard	new atlas cluster + `P-NNN`

Phase 0 is the gate. It is deliberately one object so it fits one session and either produces a real compression number or falsifies the premise cheaply. Everything after Phase 0 is only worth doing if Phase 0's number is positive.

Swarmgod alignment (doctrine → honoured how)¶

Per the rule anchor plans on investigations, every build doctrine here is drawn from existing analysis, not invented:

Doctrine	Source	How this plan honours it
Object-index, not course-index	NOTES-AS-INFORMATION-SPACE	one canonical node per object; courses are pointer views
Isomorphism = dedup operator; σ-guard	EQUIVALENCES-ATLAS · NON-EQUIVALENCE-ATLAS	`generalizes`/`A↔B` edges merge; σ-metric blocks false merges
`orient → predict → act → diff → compress → handoff`	SWARM	the fieldforge loop is the cycle; each phase one full turn
L0 → L1 → L2 compression	MERMAID-CONVENTIONS	hub + every node carries the three depths
Density-triggered compression	AGENT-TASK-LOOP-AND-COMPOUNDING	generalize at N≥3 instances, not on a clock
Stigmergic traces, no central manager	STIGMERGIC-ENGINE	status badges + forage records are the marks the next session reads
K_inter ≤ 2 coupling	SWARMGOD-WEIGHTED-ARCHITECTURE	each note reads ≤2 other notes; deep structure lives in the DAG, not in prose cross-refs
Card back-edges (no orphans)	push gate	every notes page is a `read_next` target before it ships
Measure the compression	NOTES-AS-INFORMATION-SPACE §L2.5	Phase 0's reduction number is the pre-registered measure
Schema invention over forcing old verbs	ACTION-VOCABULARY-CEILING	`swarmgodfieldforge` is the named, claimed-by-use primitive for field ingestion

Measurement & falsification¶

Success metric — cumulative description-length reduction (objects deduplicated × per-object pointer savings) + coverage (Oxford courses ingested) + connection (cross-links from notes into the applied corpus and atlas clusters).
What falsifies the approach — Phase 0 shows no measurable compression from object-indexing (premise dead); or pages drift back into course-indexed silos (the defect we are removing reappears); or coupling/orphan gates trip repeatedly (the structure is wrong for the card graph).
Honest ceiling — without a proof assistant, "same proof procedure" stays a tag-coincidence heuristic + human sign-off; imported nodes stay at stated, never auto-promoted past verified. Autoformalization (text → Lean) is named, not promised.

Open questions (carried from the anchor)¶

Can math_tree.py edges carry a proof_strategy tag so a tactic (induction, diagonal, contraction) becomes a first-class generalizing node?
Can equiv_scanner.py suggest same-idea merges (a human-confirmed prior), or only inventory existing clusters?
Licensing: under what terms can external course notes be ingested as derived nodes?
Physics as field #2 — which physics course corpus is the cleanest seed, and does the σ-guard hold across the math↔physics boundary?