Course / Act V · Applications Lecture 18

Science and mathematics.

A polynomial can fit a table of observations; a law is what survives the fit. This lecture follows the loop that turns a candidate — a proof, a structure, a program, an equation — into knowledge, and asks what each check actually guarantees.

~50 min read 9 sections 5 systems 1 interactive lab Updated 2026-11-17

Here is a dataset of sixteen points. A short expression fits it exactly; a longer one can fit it too. Training error cannot tell you which is the law and which is the coincidence. Something else has to.

00 / The hookThe fit is not the warrant.

The dataset in the lab comes from a known expression, and the expression is hidden. A search over a small grammar of +, ×, sin, and constants finds it at complexity six. The same search also finds simpler expressions that fit less well, and longer expressions that fit the sixteen points just as well. Every one of them is a candidate. Only some of them are knowledge.

The difference is a warrant: a reason to believe a candidate that is independent of the candidate’s own fit. A derivation from axioms, an exhaustive check of a finite case, a prediction on data the candidate never saw, a controlled experiment, or a proof term accepted by a kernel. The candidate is the proposal; the warrant is the check. Most of the engineering in this lecture is about keeping the two apart.

The separation is old. Kepler had a table of planetary observations, and a flexible curve can fit any finite table. The law P2 ∝ a3 is not valuable because it fits; it is valuable because it is stable across the solar system and follows from mechanics. Newton did not just fit better. He supplied a different kind of reason.

This lecture reads five systems through the same loop. AlphaGeometry proposes auxiliary constructions and a deduction engine checks the proof. AlphaFold predicts a structure and experiments check it. FunSearch proposes programs and an evaluator executes them. Symbolic regression proposes equations and held-out data check them. Theorem proving proposes proof terms and a kernel checks them. The question is always the same: what is the artifact, what is the checker, and what does passing the check guarantee?

Caveat · the toy is not the science

The lab’s data is synthetic and noise-free, and the generating expression is inside the grammar. Real discovery is harder: the data are noisy, the grammar may not contain the truth, and the check may be an experiment with error bars. The toy isolates the mechanism — search plus a complexity penalty plus a check — not the difficulty of a real scientific domain.

01 / Discovery vs verificationA proposal is not a proof, and a proof is not a measurement.

Discovery and verification are different activities, often performed by different components. Discovery proposes: it searches a space of hypotheses, programs, structures, or proofs and returns a candidate. Verification checks: it asks whether the candidate satisfies a specification, follows from axioms, or predicts what the world does. A system that does only the first is a generator; a system that does only the second is a filter. The interesting systems close the loop.

The loop has a shape. Something is observed — data, a problem statement, a goal. A proposer returns a candidate. The candidate becomes a checkable artifact. A checker returns accept, reject, or a score. The result becomes a warrant or feeds back into the next proposal. The proposer can be an inductive search, an abductive guess, or a language model. The checker can be a deductive engine, an evaluator, a held-out set, or an experiment. The architecture is the interface between them.

The propose-and-check loop A proposer returns a candidate artifact. A checker evaluates it against evidence, axioms, or a specification. The result is a warrant or a revision, and the revision returns to the proposer. The proposer and the checker draw on different resources. DISCOVERY VERIFICATION proposer search · model · guess neural or symbolic candidate artifact proof · program equation · structure checker kernel · evaluator experiment warrant accept reject score revise · re-search · repair evidence · axioms · specification · data what the check is relative to
Fig. 1.1 The propose-and-check loop. The proposer and the checker use different resources, and the check is always relative to something: axioms, a specification, a dataset, or an experimental design. Schematic, not a system diagram.

The three classical inferences map onto the loop, but not one-to-one. Induction generalizes from examples; abduction infers the best explanation; deduction derives consequences and is the typical shape of the check. A discovery system usually needs induction or abduction to generate, and deduction or experiment to verify. The mistake is to treat the generating inference as the verifying one.

It helps to name the checked artifact: the object the checker accepts or rejects. In AlphaGeometry it is a proof — a sequence of deductions from the premises and proposed constructions. In FunSearch it is a program, and the checker is an evaluator that executes it. In symbolic regression it is an equation, and the check is empirical. In AlphaFold it is a set of coordinates, checked against an experimental structure. In a proof assistant it is a proof term, checked by the kernel. The artifact is not the world; it is what the warrant is about.

Definition · a warrant

A warrant is an independent check that a candidate artifact satisfies a stated criterion. It has three parts: the artifact (what is checked), the checker (what performs the check), and the specification (what the check is relative to). “Verification” without those three parts is a slogan.

The guarantees are not interchangeable. A formal proof is binary and deductive: if the kernel accepts, the conclusion follows from the axioms by the rules. A held-out prediction is graded and statistical: it supports a claim about a distribution, not a theorem about the world. A controlled experiment is causal only relative to a design. A benchmark score is comparative and vulnerable to leakage. The table below is the lecture’s spine.

Table 1.1 · Five warrants, five scopes. The right column is the part that is usually omitted from the abstract.
WarrantWhat it checksWhat it can supportWhat it cannot
Formal proofEach step follows from the axioms and prior steps by a ruleA theorem in the formal systemThat the formal statement is the intended claim; that the axioms are consistent
Exhaustive checkEvery case in a finite, correctly enumerated spaceA universal claim over that spaceAnything outside the enumeration; that the enumeration is complete
Held-out predictionError on data not used to fitGeneralization to a similar distributionExtrapolation, causal claims, or the truth of the hypothesis
Controlled experimentAn intervention against a comparisonA causal claim relative to the designThat the design controls every confound; that the result transfers
Benchmark scorePerformance on a fixed task setA comparative, empirical claimThat the benchmark measures the intended capability

Two symbols make the difference precise. A deductive judgment has the form Γ ⊢ π : φ: in context Γ, the proof term π has type φ. An empirical claim is a statement about error: errD(f) is the error of f on dataset D, and a good fit is a small number, not a truth value. The first is a relation between a proof and a specification. The second is a relation between a function and a sample. Confusing them is the most common failure in the rhetoric of AI discovery.

Caveat · the verification gap

A check is a relation between artifacts, not a relation to the world. The world enters through measurement, formalization, and experimental design, and each of those can fail. “The proof checker accepted it” and “the experiment confirmed it” are both partial warrants, not a substitute for the other.

02 / AlphaGeometryA language model proposes; a deduction engine checks.

An olympiad geometry problem rarely yields to a direct derivation. The proof usually needs an auxiliary construction: a new point, a line, a circle, or a midpoint that is not in the statement. Finding the construction is the hard part; checking the proof once the construction is present is comparatively mechanical. AlphaGeometry is built around exactly that division of labour (Trinh et al., Nature, 2024, DOI 10.1038/s41586-023-06747-5).

The system has three parts. A formal language describes the diagram: points, lines, circles, and predicates such as collinearity, concyclicity, and equal angles. A symbolic deduction engine — DDAR, for deductive database arithmetic and rewriting — applies sound rules to the facts and derives consequences. A language model is trained on synthetic proofs generated from random diagrams; when the engine stalls, the model proposes an auxiliary construction. The engine then resumes. If it reaches the goal, the result is a proof; if not, the loop continues.

A ∼ pθ(A | K, g)     π = DDAR(K ∪ A, g)
(2.1)

Here K is the formalized problem, g the goal, A the proposed auxiliary constructions, and π the proof the engine returns. The model samples A; the engine derives g from K ∪ A or fails. The model is a proposal distribution, not the checker.

Table 2.1 · Who does what in AlphaGeometry. The separation is the architecture.
ComponentResponsibilityFailure if it is wrongCan it certify?
Language modelPropose useful auxiliary constructions at a stallA bad proposal wastes search; a missed proposal loses the proofNo
Deduction engineApply sound rules and derive the goalA gap in the rules or an implementation bug invalidates the proofYes, relative to its rules
FormalizationTranslate the problem into the formal languageA missing assumption proves a different theoremNo
Search loopAlternate proposals and deductionsNon-termination or a proof that is too long to findNo

The proof check is real, and it is narrow. When the engine accepts a step, the step is an instance of a derivation rule; when it reaches the goal, the goal follows from the formalized premises and the proposed constructions. That is a genuine soundness property: the conclusion is a consequence, not a plausible sentence. But the guarantee is conditional on the engine’s rules and implementation, and on the formalization of the problem.

The formalization is the weak link. A diagram can carry implicit assumptions — a point is between two others, a line is not tangent, a configuration is non-degenerate. If the formal statement omits one, the engine can prove a theorem about a different configuration. The proof is valid; the claim is not the claim you meant. This is the formalization gap, and it appears in every formal-mathematics system in this lecture.

What the proof check guarantees — and what it does not

It guarantees: each accepted step follows from the premises and earlier steps by a sound rule; the conclusion follows from the formalized statement plus the auxiliary constructions. It does not guarantee: that the formalized statement matches the natural-language problem; that the deduction engine’s implementation is correct; that the proof is short, readable, or general; or that the result is new. A rejected construction is not a disproof. A proved theorem about the wrong formalization is still the wrong theorem.

The “without human demonstrations” part of the paper’s title matters. The language model is trained on synthetic proofs produced by the deduction engine, not on human olympiad solutions. The engine supplies the data and the check; the model learns where a construction tends to help. This is proof search guided by a learned proposal distribution, with a symbolic verifier at the end.

Source note · AlphaGeometry

Trinh, Wu, Le, He & Luong, “Solving olympiad geometry without human demonstrations,” Nature 625 (2024), DOI 10.1038/s41586-023-06747-5. The architecture description follows the paper’s account of the formal language, the DDAR engine, and the model trained on synthetic proofs. No benchmark number is quoted; the paper reports results on a benchmark of olympiad geometry, and the scope of that benchmark is part of the caveat.

03 / AlphaFoldA structured prediction, checked by experiment.

AlphaFold is a different kind of case. The task is to predict a protein’s three-dimensional structure from its amino-acid sequence. The output is a structured object — a set of coordinates — and the check is not a proof. It is an experimental structure, determined by X-ray crystallography, cryo-electron microscopy, or NMR, compared against the prediction. The paper is Jumper et al., Nature, 2021, DOI 10.1038/s41586-021-03819-2.

At the level of architecture, the system takes a multiple sequence alignment and pairwise residue features. A stack of Evoformer blocks updates two coupled representations: an MSA representation and a pair representation. Attention over the MSA is biased by the pair representation, and the pair representation is updated with operations that respect the triangle inequality of distances, including triangular multiplicative updates and triangular self-attention. A structure module then operates on a residue “gas” of backbone frames, using invariant point attention to produce Cartesian coordinates; the network is recycled for a few iterations. Training uses experimental structures from the Protein Data Bank and a frame-aligned point error loss.

The checked artifact is not only the coordinates. AlphaFold also reports a per-residue confidence, pLDDT, and a predicted aligned error matrix, PAE, estimating the error in the relative position of two residues. These are learned estimates, not guarantees. They tell the user where the prediction is likely to be reliable; they are not a proof that the structure is right.

Table 3.1 · What checks an AlphaFold structure, and what each check leaves open.
CheckWhat it comparesWhat it supportsWhat it leaves open
Experimental structurePredicted coordinates against a measured structureAgreement with that experiment, for that construct and conditionOther conformations; other conditions; disordered regions
Blind assessment (CASP)Predictions made before the experimental structure is releasedGeneralization to unseen targets in the assessment setTargets outside the distribution; complexes; ligands
pLDDTA learned per-residue confidenceWhere the model expects to be accurateWhether the confidence is calibrated for a new class of targets
PAEA learned estimate of relative position errorWhich domain placements are uncertainThe absolute accuracy of a confident placement

Is AlphaFold neurosymbolic? Not in the strong sense used in this course. There is no logic program, no explicit rule base, and no symbolic executor. The symbolic content is geometry and chemistry — backbone frames, equivariance, bond geometry, steric constraints — encoded as inductive biases and losses rather than as a knowledge base. It belongs here because it makes the propose-and-check pattern visible at scientific scale: a neural model produces a structured object, and the trust comes from an external, empirical check.

Caveat · a structure is not a mechanism

A predicted structure is a snapshot, not a dynamics. It does not tell you how the protein folds, what it binds, how it changes conformation, or what happens in a cell. Experimental structures are also models, with resolution, refinement, and disorder of their own. Confidence scores are learned estimates; a high pLDDT in a disordered region is not evidence that the region is ordered. The check is empirical, and empirical checks have scope conditions.

Source note · AlphaFold

Jumper et al., “Highly accurate protein structure prediction with AlphaFold,” Nature 596 (2021), DOI 10.1038/s41586-021-03819-2. The architecture summary is at the level of the Evoformer, the structure module, recycling, and the confidence outputs; it is not a reproduction of the paper’s figures. The caveats are about scope, not about the reported accuracy.

04 / FunSearchPrograms that are executed, not believed.

FunSearch asks whether a language model can discover a program that solves a mathematical or algorithmic problem, when the program is judged by execution rather than eloquence. This is program synthesis with an executable check. The answer is a search loop in which the model proposes code and an evaluator scores it (Romera-Paredes et al., Nature, 2024, DOI 10.1038/s41586-023-06924-6).

A specification gives the function signature, a docstring, and the contract. An evaluator executes a candidate and returns a score. A program database stores candidates and scores, grouped into islands to preserve diversity. A pretrained language model is prompted with the specification and the best programs; it returns new programs, which are evaluated and added. The model is not fine-tuned. It is a proposal operator inside an evolutionary search, and the evaluator is the check.

The checked artifact is the program itself. For a construction problem, the program builds an object and an independent check verifies the defining property; the paper’s cap-set result is of this kind. For a heuristic problem such as online bin packing, the program is a heuristic and the evaluator scores it on instances. In both cases the check is execution against a specification, not a proof that the program is optimal or that the specification captures the intended problem.

Table 4.1 · The FunSearch loop, and where the trust sits.
ComponentRoleWhat it is trusted forWhat it is not
Language modelPropose variations of programsPlausible code that respects the signatureA verifier; it can be wrong and often is
EvaluatorExecute and score candidatesThe definition of “good” for this searchThe intended objective, unless the specification is right
Program databaseKeep a diverse population and feed the best backSearch memory and selection pressureA guarantee of coverage or completeness
Independent checkVerify a construction or a claimed propertyThe property, for the concrete objectThe optimality or generality of the program

The guarantee is empirical and relative to the evaluator. If the evaluator faithfully implements the specification, a high score is evidence that the program satisfies it on the evaluation instances. If the evaluator is incomplete, the search will find the gap and exploit it. Any search that optimizes a proxy will discover the proxy’s loopholes, and a language model is a very good loophole finder. The evaluator is the specification in executable form, and a specification bug becomes a discovery of the wrong thing.

The separation between model and data is part of the design. The language model is prompted with the specification and the best programs; the evaluator runs the instances. That is why the approach can discover a construction no human wrote down: the model is proposing code the evaluator can test, not retrieving a memorized answer.

Caveat · the evaluator is the weak link

FunSearch does not prove that a program is correct, optimal, or general. It shows that the program scores well under an evaluator on a set of instances. The evaluator can be wrong, incomplete, or gameable; the instances can be unrepresentative; the search can overfit. The paper’s results are a proof of concept for a loop, not a guarantee that the loop finds truth in an arbitrary domain.

Source note · FunSearch

Romera-Paredes et al., “Mathematical discoveries from program search with large language models,” Nature 625 (2024), DOI 10.1038/s41586-023-06924-6. The description follows the paper’s account of the specification, evaluator, program database, and LLM proposal loop. The cap-set and bin-packing applications are the paper’s; no scores are quoted.

05 / Symbolic regressionThe simplest expression that fits is a hypothesis, not a law.

Symbolic regression is the search for a mathematical expression that explains a dataset. The input is a set of pairs (xi, yi); the output is an expression f built from variables, constants, and operations such as addition, multiplication, and sine. The expression is a program in a small grammar, and the search is over expression trees. The grammar’s expressivity is a hard boundary: a law outside it cannot be found, only approximated.

The search space is combinatorial. Even with a tiny grammar, the number of trees grows exponentially with depth. The general problem is NP-hard, and practical systems use heuristics: enumerate by size, prune by type, fit constants, use genetic programming (Koza, 1992), or exploit physics-inspired structure. AI Feynman uses divide-and-conquer, dimensional analysis, symmetry, and separability to reduce the search, and reports recovering all 100 equations in its Feynman benchmark (Udrescu & Tegmark, arXiv:1905.11481, Science Advances, 2020).

The objective has two terms. The first is fit: root-mean-square error on the data. The second is complexity: a count of nodes, operators, or constants. A larger expression can always fit at least as well, so fit alone gives no reason to prefer the shorter one. The standard remedy is a penalty:

RMSED(f) = √( (1/n) Σi (f(xi) − yi)2 )     score(f) = RMSED(f) + λ · C(f)
(5.1)

The penalty λ is a prior about simplicity, not a fact about the world. A large λ prefers short expressions and can select an underfit approximation; a small λ prefers fit and can select a complex coincidence. The regularization analogy is apt: the penalty trades bias for variance, and the right trade-off depends on the data, the noise, and the question. The alternative to a single λ is the Pareto front: the expressions not dominated by another with both lower error and lower complexity.

f dominates g  iff  RMSE(f) ≤ RMSE(g)  and  C(f) ≤ C(g), with at least one strict
(5.2)
A Pareto front of error against complexity Four points on a Pareto front: complexity one with high error, complexity two with lower error, complexity four with lower error still, and complexity six with zero error on the synthetic data. The front is the set of points not dominated in both error and complexity. COMPLEXITY ERROR better x sin(x) 2·sin(x) 2·sin(x)+0.5 DOMINATED
Fig. 5.1 The Pareto front computed by the lab on its synthetic dataset. The four points are the best error at complexity 1, 2, 4, and 6; points above and to the right are dominated. The numbers are computed from this dataset, not a benchmark.

The front makes the trade-off visible, but it does not choose. The choice of λ, or of a point on the front, is a modeling judgment. That judgment should be defended with something other than training error: a held-out set, a units check, a stability check under resampling, or a mechanism argument. Symbolic regression is induction, and its output is a hypothesis. The expression can be the true law, but the fit alone does not make it one.

The lab · the front, not the answer

The symbolic-regression lab generates 16 points from a hidden expression, enumerates 7,626 expressions up to complexity nine, fits the constants in each by coordinate descent, and keeps the Pareto front. Four points survive. Move the λ slider and the selected expression changes: at a low penalty the search recovers the generating expression; at a higher penalty it chooses a simpler approximation. One front point, 2·sin(x), is never selected by a linear penalty because it lies above the line between its neighbours; a Pareto front is a set of trade-offs, not a ranking.

Caveat · what the lab does not show

The data are noise-free, the generating expression is inside the grammar, and the constants are fitted by a deterministic grid search. The lab shows enumeration, constant fitting, the complexity penalty, and the Pareto front. It does not show that symbolic regression recovers laws from real data, that the selected expression extrapolates, or that a low-complexity expression is true.

06 / Theorem provingThe kernel checks the proof, not the problem.

A formal proof is a derivation in a formal system. The theorem prover’s kernel is a small program that checks whether a proposed proof term has the type of the claimed theorem. In Lean, Coq, and Isabelle, the kernel is deliberately small and independent of the tactics and automation that produced the proof. This is the de Bruijn criterion: the proof can be checked by a simple program, so the search can be large, heuristic, and untrusted (Wiedijk, The Seventeen Provers of the World, 2006).

Γ ⊢ π : φ
(6.1)

The judgment says: in the context Γ of definitions and axioms, the proof term π has type φ. If the kernel accepts, the theorem follows from the definitions and axioms by the rules. That is a strong guarantee, and it is still conditional. It does not say that the axioms are consistent — Gödel’s incompleteness theorem rules out a sufficiently strong system proving its own consistency. It does not say that φ is the informal theorem you meant, that the proof is interesting, or that the kernel has no bugs. It says that the trusted base is small enough to audit.

Neural theorem proving puts a language model in the proposal role. The model suggests tactics, lemmas, or proof steps; the kernel checks the resulting proof term. GPT-f is an early demonstration (Polu & Sutskever, 2020); AlphaGeometry is a specialized instance with a geometry-specific engine. The model can be wrong as often as it likes, because the kernel rejects wrong proofs. The bottleneck is search: the space of proofs is enormous, and the model’s proposals are a heuristic over it. The kernel makes the result trustworthy, not the search fast.

Table 6.1 · Three components of a neural theorem-proving system, and the trust each one carries.
ComponentJobTrustFailure mode
AutoformalizerTranslate the informal statement into a formal oneNone by default; it is a proposalThe formal statement is weaker, stronger, or different
Search / modelPropose tactics, lemmas, and proof stepsNone; a heuristicFails to find a proof; wastes budget; loops
KernelCheck the proof term against the statementThe trusted baseA kernel bug; an unsound axiom; a wrong definition

The formalization gap is sharper here than anywhere else. A proof assistant will happily verify a theorem about the wrong definition. If “continuous” omits a condition, or the statement quantifies over the wrong domain, the proof is valid and the claim is false. The kernel checks the proof against the statement, not the statement against the world. This is why autoformalization is a research problem: the translation from natural language to formal logic is itself a proposal that needs a check.

What “verified” means in a proof assistant

It means: the proof term type-checks against the stated theorem in the formal system, using the stated definitions and axioms. It does not mean: the theorem is the one you intended, the axioms are true, the system is consistent, the proof is elegant, or the result is new. Completeness is a property of a proof system, not a promise that the search will find a proof; decidability is a property of a logic, not a promise that the kernel will finish quickly.

07 / What failsFive gaps between a check and a claim.

The systems in this lecture fail in recurring ways. The failures cluster around the joints between the artifact, the checker, and the world. The table below is a diagnostic frame and a reading protocol: when a paper says “verified” or “discovered,” find which gap it is exposed to.

Table 7.1 · Five gaps. Each is a place where a passing check can still leave the claim unsupported.
GapMechanismSymptomMitigation
FormalizationThe formal statement, grammar, or specification is not the intended claimA proof of the wrong theorem; an equation in the wrong grammarIndependent formalization; cross-checks; explicit assumptions
EvaluatorThe check measures a proxy, not the goalHigh score on a gameable evaluator; benchmark overfittingIndependent checks; held-out evaluators; adversarial tests
SearchThe proposer is incomplete or the budget is too smallA missed proof or law; a result that depends on the seedBetter proposals; restarts; completeness bounds where available
UnderdeterminationThe data do not identify the hypothesisMany expressions fit; extrapolation failsMore data; units and symmetry; perturbation and stability tests
TrustThe checker, axioms, or measurement is wrongA kernel bug; an inconsistent axiom; a biased experimentSmall trusted base; independent replication; calibration

The formalization gap is the most important one here. AlphaGeometry’s proof is about a formal diagram; if the diagram misses an assumption, the proof is about a different configuration. A theorem prover’s proof is about a formal statement; if the statement is wrong, the proof is worthless. A symbolic-regression expression is about a grammar; if the true law is outside it, the search can only approximate. The check is sound relative to the artifact, and the artifact is the weak link.

The evaluator gap matters most for FunSearch and benchmarks. An evaluator is a program, and a program can be wrong. A search that optimizes an evaluator will find its loopholes, especially when the proposer is a language model trained on code. The cap-set check is relatively robust because the property is directly verifiable; a heuristic score on instances is much easier to overfit. A benchmark score is the same kind of proxy: it can be gamed, leaked, or mis-specified.

The search gap and the underdetermination gap are two sides of one coin. Search says the proposer may not find the candidate. Underdetermination says that even if it does, the data may not distinguish it from a simpler or more complex alternative. Symbolic regression shows both: the enumeration is exhaustive up to complexity nine, but the data are finite, and a more complex expression can fit them equally well. The Pareto front is the honest representation of that fact.

The trust gap is easiest to forget. A proof assistant’s kernel is small, but the trusted base is not empty: it includes a type theory, a parser, a compiler, and a runtime. An experiment has a calibration, a sample, and an instrument model. AlphaFold’s confidence scores are learned and can be miscalibrated on a new class of targets. The response is not to abandon the check; it is to state the trusted base and test it independently.

The five questions to ask a discovery claim

1 · Artifact. What exactly passed the check — a proof, a program, an equation, a structure? 2 · Checker. What performed the check, and what is its trusted base? 3 · Specification. What was the check relative to — axioms, an evaluator, a dataset, an experiment? 4 · Scope. On what distribution, benchmark, or configuration does the claim hold? 5 · Cost. What did the search cost, and would a different seed or budget change the answer? If a paper cannot answer these, “verified” is doing rhetorical work, not technical work.

08 / Tuple, cases, recapRead the system, not the headline.

The five systems can be read along the tuple this course uses: representation, inference, coupling, checked artifact, and guarantee. The tuple is not a scorecard. It is a way to see where the trust comes from.

Table 8.1 · Five systems, one tuple. “Guarantee” is relative to the artifact and the checker, not to the world.
SystemRepresentationInferenceCouplingChecked artifactGuarantee
AlphaGeometryLanguage model + DDARDeductionSearch + proof checkProofFormal, relative to formalization and engine
AlphaFoldEvoformer + geometryPredictionStructured output3D coordinates + confidenceEmpirical, relative to experiments
FunSearchLLM + programsInductionEvolutionary searchExecutable programEmpirical, relative to the evaluator
Symbolic regressionExpression over a grammarInductionSearch over treesEquationEmpirical, relative to held-out data and units
Lean + LLMTactics + kernelDeductionVerifierProof termFormal, relative to kernel and formalization

Three patterns are worth retaining. First, the strongest guarantees come from a checker that is independent of the proposer: AlphaGeometry’s engine and Lean’s kernel do not care how the candidate was produced. Second, a proxy evaluator gives a weaker guarantee than a proof, and the gap is exactly the evaluator gap. Third, an empirical check is not a failure of rigor; it is a different scope. AlphaFold’s experimental validation is the right kind of check for a structure prediction, just as a proof is the right kind of check for a theorem. The mistake is to use the vocabulary of one for the other.

01

Separate the proposal from the warrant: a candidate is not knowledge until an independent check supports it.

02

Name the three parts of a warrant: the artifact, the checker, and the specification it is relative to.

03

Explain AlphaGeometry’s division of labour: the model proposes auxiliary constructions; the deduction engine checks the proof.

04

State what a proof check guarantees and what it does not: the formal statement is not the informal claim, and the engine is not the world.

05

Describe AlphaFold’s checked artifact and its check: coordinates plus confidence, validated by experimental structures.

06

Explain FunSearch’s loop: LLM proposals, evaluator scores, program database, and the evaluator as the specification.

07

Explain symbolic regression’s search and complexity penalty, and read a Pareto front without treating the simplest point as the truth.

08

Diagnose a discovery claim with the five gaps: formalization, evaluator, search, underdetermination, and trust.

Exercises

  1. Find the artifact. Take the abstract of a recent “AI discovers” paper. Underline the claim, then write down the artifact that was actually checked and the checker that checked it. If the abstract does not name them, say so.
  2. Break a formalization. Take a theorem you know and write a formal statement of it. Remove one assumption that a reader would infer from context. Does the statement become false, vacuous, or merely weaker? This is the formalization gap in miniature.
  3. Audit a confidence score. For AlphaFold, list three things a high pLDDT does not tell you. Then list one experiment that would test each.
  4. Game an evaluator. Write a one-paragraph specification for a toy task (for example, “sort a list”). Then write an evaluator that is faithful but incomplete. Describe a program that scores well and does not do the task.
  5. Run the front. In the lab, try to find a λ that selects 2·sin(x). Then set λ so the selected expression is sin(x). Explain why the first is impossible with a linear penalty and the second is not.
  6. Propose a loop. Choose a domain you know — a lab measurement, a scheduling problem, a proof, a dataset. Specify the proposer, the artifact, the checker, and the specification. Then name the gap you are most worried about.

Check your understanding

Ten questions, with explanations. The score is not the point; the questions you cannot answer are the reading list.

Reading list

The first five are the spine of this lecture. The rest are the next layer.

Solving olympiad geometry without human demonstrations

Trinh et al. · Nature, 2024 · the language model, the DDAR engine, and the checked proof

Geometry

Highly accurate protein structure prediction with AlphaFold

Jumper et al. · Nature, 2021 · Evoformer, structure module, and experimental validation

Biology

Mathematical discoveries from program search with large language models

Romera-Paredes et al. · Nature, 2024 · FunSearch: programs, evaluators, and a search loop

Programs

AI Feynman: a physics-inspired method for symbolic regression

Udrescu & Tegmark · Science Advances, 2020 · divide-and-conquer, units, symmetry, Pareto

Equations

Interpretable scientific discovery with symbolic regression: a review

Makke & Chawla · Artificial Intelligence Review, 2024 · the method space and its limits

Survey

Distilling free-form natural laws from experimental data

Schmidt & Lipson · Science, 2009 · the classic symbolic-regression demonstration

Classic

Genetic Programming: On the Programming of Computers by Means of Natural Selection

Koza · MIT Press, 1992 · the evolutionary search behind many symbolic-regression systems

Classic

The Lean 4 Theorem Prover and Programming Language

de Moura & Ullrich · CADE-28, 2021 · the kernel and the tactic language

Proofs

The Seventeen Provers of the World

Wiedijk (ed.) · Springer LNAI 3600, 2006 · the de Bruijn criterion and the trusted base

Proofs

Generative Language Modeling for Automated Theorem Proving

Polu & Sutskever · 2020 · GPT-f and the neural proposal pattern

Models
Source note · what is redrawn and what is quoted

Figure 1.1 is a schematic redrawing, not a reproduction of a paper figure. Figure 5.1 and its points are computed by the lab on its synthetic dataset; they are not benchmark numbers. The Nature papers are cited by DOI; AI Feynman was verified through the arXiv API (arXiv:1905.11481, Science Advances 6, 2020), and the symbolic-regression review through the arXiv record (arXiv:2211.10873, Artificial Intelligence Review 57, 2024). Classics without an arXiv ID are cited by author, title, venue, and year.