A plain-language guide to this whole project

Why geometric function theory matters, what problem we actually solved, and every trick we used to solve it — written so you can argue with any part of it.

1. The field in two minutes

Geometric Function Theory (GFT) studies analytic functions on the unit disk — functions you can write as a power series

f(z) = z + a₂z² + a₃z³ + a₄z⁴ + …

that are univalent (one-to-one: no two points of the disk map to the same place). One-to-one analytic maps are exactly the "distortion-free" ways to deform the disk into some other shape, which is why they show up in conformal mapping, fluid flow, and pure complex analysis.

The central miracle of the field: the coefficients a₂, a₃, … encode the geometry of the image shape. If you constrain the shape (say, the image must be star-shaped), the coefficients can't be arbitrary — they get squeezed into a specific region, and finding the exact edges of that region is what the field has been doing for a century. The most famous result of this type is the Bieberbach conjecture (|aₙ| ≤ n for all univalent f), posed in 1916 and only proved by de Branges in 1985. That 69-year gap for one inequality tells you how hard "find the exact edge" problems are here.

Why anyone still cares: after Bieberbach, attention moved to subclasses (more constrained shapes) and functionals (combinations of coefficients). Each subclass × functional pair is a self-contained optimization problem: "over all functions in this class, how big can this expression get, and which function achieves the max?" These are clean, hard, and publishable — which is both the field's strength and, as we'll see, its problem.

2. Our specific playground: Ma–Minda classes

In 1994, Ma and Minda unified hundreds of one-off subclasses into a single family. Pick any nice function φ with φ(0)=1, and define the class S*(φ) as all univalent f satisfying

zf′(z)/f(z) ≺ φ(z)

The "≺" is subordination — it means the left side's values stay inside the region φ paints over the disk. Intuition: zf′/f measures, at each point, how the function is locally rotating and stretching; φ is a budget region this quantity must live in. Different φ's give differently-shaped budgets, hence differently-shaped image domains:

…and our catalog has 27 of these. The functionals people bound over them:

• Fekete–Szegő: |a₃ − μa₂²| for a parameter μ — the oldest and most-studied.
• Hankel determinants: H₂(2) = a₂a₄ − a₃², and the notorious H₃(1), a 3×3 determinant mixing a₂…a₅.
• Zalcman: |a₂a₃ − a₄| and friends.

A typical GFT paper today: pick a φ, pick a functional, grind through a hand computation, publish "the sharp bound is C, with equality for this function." There are hundreds of such papers, they follow a template, the computations are error-prone, and the results are scattered with no central record. That's the gap this project lives in.

3. What we built, end to end

Six layers, each feeding the next. Crucially, the layers have different trust levels, and nothing untrusted ever touches a proof.

Layer 1 — The registry (collect the field)

We scraped 548 papers in this area, then used LLM agents to extract structured data — which class, which functional, what bound is claimed — producing 651 recorded bounds across 204 structured papers. Because LLMs hallucinate, every extraction passes a deterministic gate: a sympy script recomputes the power series of the claimed φ and checks it against the claimed class; mismatches get nulled, not trusted. The LLM is a librarian here, never a mathematician — no LLM output is in the proof path anywhere.

Layer 2 — Discovery (guess the answers numerically)

Heavy numerical optimization over each class × functional: find the apparent maximum, refine it, and record the shape of the maximizing configuration (which parameters sit at 0, which at 1). This produced conjectured values like "for the lemniscate class, H₂(2) appears to max out at exactly 1/4." Numerics prove nothing — but they tell us what to try to prove, and what the extremal function should look like. (This phase was the first report and blog post.)

Layer 3 — The reduction (turn analysis into algebra)

This is the mathematical heart, and it rests on two classical, hand-checkable lemmas — by design, these are the only pieces of classical math a referee must verify:

Step A. Write f's coefficients in terms of a helper function. The subordination zf′/f ≺ φ is equivalent to zf′/f = φ(ω(z)) for some "Schwarz function" ω (analytic, ω(0)=0, |ω|<1). Expanding both sides as power series gives exact polynomial formulas: a₂, a₃, a₄, a₅ are polynomials in the coefficients c₁, c₂, c₃, … of ω. So our functional L(f) becomes a polynomial in c₁, c₂, c₃….

Step B (the key trick). What set do (c₁, c₂, c₃) actually range over? It's a weird curved body — but Schur's 1917 parameterization maps a flat box (each parameter in [0,1] or a disk) exactly onto that body. "Onto" matters: we cover every admissible function, not just most. (Citations: Schur 1917; Simon's OPUC book, Thm 1.5.5.)

Step C. A rotation symmetry lets us fix one parameter to be real, dropping a dimension.

After A–C, the original infinite-dimensional problem over a function space has become, with zero approximation error:

maximize a known polynomial over a compact box in ℝᵐ (m = 3 to 7).

Layer 4 — The certifier (prove the max, with the computer's rounding errors accounted for)

Maximizing a polynomial sounds easy, but we need a proof, not a number from an optimizer. The tool is interval arithmetic + branch-and-bound:

• Compute with ranges instead of numbers. Feeding the box [0,1]×[0,1]×… through the polynomial yields a guaranteed range for its output — guaranteed because every arithmetic operation also adds the worst-case IEEE-754 floating-point rounding error to the result. Nothing is ever rounded inward.
• If the range's upper end is below our target (V+ε)², that whole box is certified: no point in it can violate the bound. If not, split the box in half and recurse. Repeat until every leaf box is certified — or some box provably violates the bound, in which case the run FAILs with a witness point (this happens, and it's a feature: the factory refuses false claims; we keep deliberately-false bounds in the test suite as negative controls).

Naive interval arithmetic is uselessly pessimistic (the "dependency problem": it treats x − x as having range [−1,1] when x ∈ [0,1] instead of being 0). So the certifier carries a family of progressively smarter bounds, taking the best on each box:

1. Plain intervals — fast, loose.
2. Affine arithmetic — tracks which uncertainty each term depends on, so correlated terms cancel like they should.
3. Trig-correlated affine — the polynomials contain cos γ and sin γ of the same angle; we make their noise symbols shared, with an explicit h²/2 Taylor remainder.
4. Second-order Taylor enclosures — expand around the box center.
5. Monotonicity pruning — if a certified derivative sign says the max is on a face, slide to the face (one dimension cheaper).

And one structural lesson worth a paper section by itself: evaluate the factored expression, not the expanded polynomial. Expanding H₂(2)-type expressions into a monomial soup destroys the correlations affine arithmetic needs; keeping the computation as a factored DAG (directed acyclic graph, mirroring how the formula is actually built) tightened our bound floor from ~10⁻² to ~10⁻¹⁴. That single change is what makes ε = 10⁻⁶ certificates feasible at all.

Layer 5 — The trust chain (why you should believe a certificate)

Each proved statement ships with four independent artifacts:

1. The certificate — a JSON file naming the class, functional, bound, slack, and the full partition of the box into certified leaves (the leaf boxes are archived in .npz files, streamed to disk so RAM stays flat).
2. An independent recheck — a separate implementation re-verifies sampled leaves (concentrating near the maximum) in mpmath multiprecision interval arithmetic — different code, different number system, outward rounding for free. A bug in the fast certifier gets caught here; this actually happened once (the recheck initially lacked the trig-correlated bound, flagged a leaf, and we strengthened the recheck — the audit log records the incident).
3. An attainment witness — an explicit extremal function f₀ defined by zf₀′/f₀ = φ(zᵏ), whose class membership holds by construction (its Schwarz function is literally ω = zᵏ), evaluated to show |L(f₀)| equals the lower endpoint V.
4. An audit trail — every prove/recheck/report event appends a JSON line with timestamp, git commit, and outcome to an append-only log (/proofs/audit). Mistakes are disclosed there, not erased.

So the statement we publish is deliberately modest and precise:

The sharp constant lies in [V, V + ε] — lower end attained by an explicit function, upper end machine-certified, usually with ε = 10⁻⁶.

We call this a certified enclosure (or bracket), not a "sharp theorem." Closing the last ε to turn brackets into exact sharp theorems is a stated open step. This wording matters; an earlier draft oversold it and a review pass fixed it.

Layer 6 — Scaling up: the μ-grid (46 → 143)

Ma & Minda's 1994 paper gives a general formula for the Fekete–Szegő value of any S*(φ) as a function of μ. We use it as a candidate generator: for each of the 27 classes and μ ∈ {0, ¼, ¾, 2}, compute the formula's prediction exactly (as symbolic rationals/radicals), then make the factory certify it independently. The design is self-correcting — if the formula were misapplied somewhere, the certifier would FAIL with a witness rather than emit a false certificate. In the run: 97 proved, 3 honest refusals, 8 skipped for a principled reason (next section). Current corpus: 143 certified enclosures, each with all four trust artifacts, live at /proofs.

4. The actual scientific payoff: measuring why the hard problems are hard

Anyone can say "H₃(1) is hard." We can now say how hard, where, and why — with measurements. Three laws came out of the failure data:

Law 1 — The two-family tie. Fekete–Szegő certification fails at fine slack exactly when two different extremal families (the "tail" family ω = z² and the "face" family γ₀ = 1) attain the same value. A tie means the maximizer isn't a point but a positive-dimensional set — a whole curve of maximizers — and box-subdivision can never isolate it (boxes touching the curve never certify). A two-evaluation tie test predicts every failure in the corpus with zero exceptions. This is why 8 μ-grid cases were skipped: the tie test flagged them in advance.

Law 2 — Relative slack. For the 5-dimensional H₂(2) problems, certification succeeds when ε/V ≳ 15% and stalls below — a clean empirical threshold for how much breathing room interval methods need at this dimension.

Law 3 — The 7-D wall. H₃(1) lives in 7 box dimensions. We measured the fraction of the box that certifies at decreasing widths: 3% at width 1/8, 19% at 1/16, 81% at 1/32. Extrapolating, full certification needs ≈ 3×10¹⁰ boxes — out of reach. Crucially, the stubborn volume is bulk interior, not the neighborhood of the maximum — the obstruction is the dependency problem at scale, not the extremal itself.

Together these give a quantitative reading of recent history: when Kowalczyk–Lecko–Thomas proved H₃(1) ≤ 4/9 for starlike functions in 2022, they had to start with an analytic dimension reduction (the Carathéodory parameterization) before any estimation. Our wall measurement shows that reduction wasn't stylistic — it's the difference between a feasible search space and 3×10¹⁰ boxes. It also hands us the next milestone: mechanize that same chart (a certified Carathéodory reduction), which would put H₃(1)-class problems back in the factory's reach. Full details: /proofs/hardness.

5. What's new and what isn't (be careful repeating this part)

Not new: most of the constants. We verified mechanically that all our Fekete–Szegő values instantiate the Ma–Minda 1994 formula, and a bibliography pass matched most named-class values to existing papers. The full known/derivable/apparently-new split is the provenance table at /proofs/reconciliation; only a couple of values (e.g. Fekete–Szegő over the Kumar–Ravichandran rational class) appear to be first explicit instantiations.

New, we believe: (1) the certification method and certificate format for this problem family — nobody machine-verifies these bounds today; (2) the registry itself — a living, auditable, reproducible corpus where each entry is one command to re-verify, versus results scattered across hundreds of papers; (3) the hardness laws — the first quantified explanation of where hand analysis stops being optional in this field.

The honest one-line summary of the whole project:

We didn't discover new constants — we built the machine that certifies them wholesale, with receipts, and used its failures to measure exactly where a century-old field's remaining hard problems get their hardness.

6. Where to poke at it (your commenting guide)

• The two load-bearing classical lemmas (§3, Layer 3): Schur's parameterization being onto, and the rotation reduction. Everything else is arithmetic a machine checked. If these two are invoked correctly, the framework stands.
• The bracket wording: open any theorem card on /proofs — does "sharp constant lies in [V, V+10⁻⁶]" read as honest and clear?
• The extremal argument: zf₀′/f₀ = φ(zᵏ) ⇒ membership by construction. Simple enough to verify by hand for one example.
• The tie law: it's a falsifiable claim ("ties ⇔ fine-slack failure, zero exceptions"). A single counterexample in future runs would break it.
• The framing question for the paper: is "method + registry + hardness" the right pitch, with the constants demoted to a results table? (We think yes — see the one-page outline.)

Companion documents: methods (full technical detail) · hardness map · provenance table · audit log · paper outline (PAPER_OUTLINE.md in the repo).