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?
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 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.
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.
| Warrant | What it checks | What it can support | What it cannot |
|---|---|---|---|
| Formal proof | Each step follows from the axioms and prior steps by a rule | A theorem in the formal system | That the formal statement is the intended claim; that the axioms are consistent |
| Exhaustive check | Every case in a finite, correctly enumerated space | A universal claim over that space | Anything outside the enumeration; that the enumeration is complete |
| Held-out prediction | Error on data not used to fit | Generalization to a similar distribution | Extrapolation, causal claims, or the truth of the hypothesis |
| Controlled experiment | An intervention against a comparison | A causal claim relative to the design | That the design controls every confound; that the result transfers |
| Benchmark score | Performance on a fixed task set | A comparative, empirical claim | That 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.
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.
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.
| Component | Responsibility | Failure if it is wrong | Can it certify? |
|---|---|---|---|
| Language model | Propose useful auxiliary constructions at a stall | A bad proposal wastes search; a missed proposal loses the proof | No |
| Deduction engine | Apply sound rules and derive the goal | A gap in the rules or an implementation bug invalidates the proof | Yes, relative to its rules |
| Formalization | Translate the problem into the formal language | A missing assumption proves a different theorem | No |
| Search loop | Alternate proposals and deductions | Non-termination or a proof that is too long to find | No |
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.
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.
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.
| Check | What it compares | What it supports | What it leaves open |
|---|---|---|---|
| Experimental structure | Predicted coordinates against a measured structure | Agreement with that experiment, for that construct and condition | Other conformations; other conditions; disordered regions |
| Blind assessment (CASP) | Predictions made before the experimental structure is released | Generalization to unseen targets in the assessment set | Targets outside the distribution; complexes; ligands |
| pLDDT | A learned per-residue confidence | Where the model expects to be accurate | Whether the confidence is calibrated for a new class of targets |
| PAE | A learned estimate of relative position error | Which domain placements are uncertain | The 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.
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.
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.
| Component | Role | What it is trusted for | What it is not |
|---|---|---|---|
| Language model | Propose variations of programs | Plausible code that respects the signature | A verifier; it can be wrong and often is |
| Evaluator | Execute and score candidates | The definition of “good” for this search | The intended objective, unless the specification is right |
| Program database | Keep a diverse population and feed the best back | Search memory and selection pressure | A guarantee of coverage or completeness |
| Independent check | Verify a construction or a claimed property | The property, for the concrete object | The 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.
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.
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:
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.
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 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.
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).
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.
| Component | Job | Trust | Failure mode |
|---|---|---|---|
| Autoformalizer | Translate the informal statement into a formal one | None by default; it is a proposal | The formal statement is weaker, stronger, or different |
| Search / model | Propose tactics, lemmas, and proof steps | None; a heuristic | Fails to find a proof; wastes budget; loops |
| Kernel | Check the proof term against the statement | The trusted base | A 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.
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.
| Gap | Mechanism | Symptom | Mitigation |
|---|---|---|---|
| Formalization | The formal statement, grammar, or specification is not the intended claim | A proof of the wrong theorem; an equation in the wrong grammar | Independent formalization; cross-checks; explicit assumptions |
| Evaluator | The check measures a proxy, not the goal | High score on a gameable evaluator; benchmark overfitting | Independent checks; held-out evaluators; adversarial tests |
| Search | The proposer is incomplete or the budget is too small | A missed proof or law; a result that depends on the seed | Better proposals; restarts; completeness bounds where available |
| Underdetermination | The data do not identify the hypothesis | Many expressions fit; extrapolation fails | More data; units and symmetry; perturbation and stability tests |
| Trust | The checker, axioms, or measurement is wrong | A kernel bug; an inconsistent axiom; a biased experiment | Small 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.
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.
| System | Representation | Inference | Coupling | Checked artifact | Guarantee |
|---|---|---|---|---|---|
| AlphaGeometry | Language model + DDAR | Deduction | Search + proof check | Proof | Formal, relative to formalization and engine |
| AlphaFold | Evoformer + geometry | Prediction | Structured output | 3D coordinates + confidence | Empirical, relative to experiments |
| FunSearch | LLM + programs | Induction | Evolutionary search | Executable program | Empirical, relative to the evaluator |
| Symbolic regression | Expression over a grammar | Induction | Search over trees | Equation | Empirical, relative to held-out data and units |
| Lean + LLM | Tactics + kernel | Deduction | Verifier | Proof term | Formal, 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.
Separate the proposal from the warrant: a candidate is not knowledge until an independent check supports it.
Name the three parts of a warrant: the artifact, the checker, and the specification it is relative to.
Explain AlphaGeometry’s division of labour: the model proposes auxiliary constructions; the deduction engine checks the proof.
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.
Describe AlphaFold’s checked artifact and its check: coordinates plus confidence, validated by experimental structures.
Explain FunSearch’s loop: LLM proposals, evaluator scores, program database, and the evaluator as the specification.
Explain symbolic regression’s search and complexity penalty, and read a Pareto front without treating the simplest point as the truth.
Diagnose a discovery claim with the five gaps: formalization, evaluator, search, underdetermination, and trust.
Exercises
- 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.
- 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.
- Audit a confidence score. For AlphaFold, list three things a high pLDDT does not tell you. Then list one experiment that would test each.
- 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.
- Run the front. In the lab, try to find a
λthat selects2·sin(x). Then setλso the selected expression issin(x). Explain why the first is impossible with a linear penalty and the second is not. - 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
Highly accurate protein structure prediction with AlphaFold
Jumper et al. · Nature, 2021 · Evoformer, structure module, and experimental validation
Mathematical discoveries from program search with large language models
Romera-Paredes et al. · Nature, 2024 · FunSearch: programs, evaluators, and a search loop
AI Feynman: a physics-inspired method for symbolic regression
Udrescu & Tegmark · Science Advances, 2020 · divide-and-conquer, units, symmetry, Pareto
Interpretable scientific discovery with symbolic regression: a review
Makke & Chawla · Artificial Intelligence Review, 2024 · the method space and its limits
Distilling free-form natural laws from experimental data
Schmidt & Lipson · Science, 2009 · the classic symbolic-regression demonstration
Genetic Programming: On the Programming of Computers by Means of Natural Selection
Koza · MIT Press, 1992 · the evolutionary search behind many symbolic-regression systems
The Lean 4 Theorem Prover and Programming Language
de Moura & Ullrich · CADE-28, 2021 · the kernel and the tactic language
The Seventeen Provers of the World
Wiedijk (ed.) · Springer LNAI 3600, 2006 · the de Bruijn criterion and the trusted base
Generative Language Modeling for Automated Theorem Proving
Polu & Sutskever · 2020 · GPT-f and the neural proposal pattern
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.