Size forces structure
Four questions, each of the form "how large must an object be before some structure is unavoidable?"
- Cliques. How many edges can a graph on vertices have without containing a triangle? Without a ? (Mantel, 1907; Turán, 1941.)
- Homogeneous sets. How many people must be at a party before there are who all know each other or who are all strangers? For the answer is ; for it is ; for nobody knows — it lies between and .
- Progressions. How large can a subset of be with no three terms in arithmetic progression? Roth (1953) proved: . Szemerédi (1975) proved the same for progressions of any length .
- Primes. The primes have density zero, so Szemerédi's theorem does not apply to them. Yet Green and Tao (2004) proved that they contain arithmetic progressions of every finite length: is one of length six.
Extremal combinatorics asks for the maximum size of an object avoiding a forbidden substructure (Turán numbers, Ramsey numbers); additive combinatorics studies the additive structure of sets of integers or of abelian groups (progressions, sumsets, sum–product phenomena). Szemerédi's theorem belongs to both, and the methods that grew around it — the regularity lemma, Fourier analysis and its higher-order generalisation, ergodic theory, the probabilistic method and the polynomial method — form one of the most active areas of modern mathematics. This lesson builds on graph theory (where , Mantel's theorem and the basic Ramsey bounds are proved), the probabilistic method and elementary number theory.
Structure versus randomness
A useful slogan (popularised by Tao): every large object is a mixture of structure and randomness, and both parts force patterns. A random set of integers of density contains about three-term progressions in , simply by counting. A structured set — say all integers in a sub-progression, or all integers with in a short interval — contains progressions for structural reasons. The proofs make this dichotomy precise:
- Graphs. Szemerédi's regularity lemma splits any large graph into boundedly many pieces between which the edges look random. Counting then works as in a random graph.
- Integers. Fourier analysis detects structure: if a set has few three-term progressions, its indicator function correlates with a character , so it is denser on some long sub-progression. Iterating this density increment proves Roth's theorem. Longer progressions need "higher-order" Fourier analysis (Gowers norms).
- Lower bounds go the other way: random objects are unstructured. A random red–blue colouring of has no large monochromatic clique, which is why Ramsey numbers grow exponentially. Ironically, nobody can construct colourings explicitly that are as good as random ones.
Definitions
Definition— Turán number and Turán graph
The Turán number is the maximum number of edges of an -vertex graph containing no copy of . The Turán graph is the complete -partite graph on vertices with parts of sizes or ; it contains no , and has edges.
Definition— Ramsey number
The Ramsey number is the least such that every red–blue colouring of the edges of contains a red or a blue . Equivalently: every graph on vertices contains a clique of size or an independent set of size .
Definition— density, progressions and Roth numbers
A set has positive upper density if . A -term arithmetic progression (-AP) is with . The Roth number is the largest size of a subset of with no -AP; we write for three-term progressions.
Definition— sumsets and doubling
For finite sets in an abelian group, and similarly. The doubling constant of is . A generalised arithmetic progression of dimension is a set .
Definition— ε-regular pairs and partitions
For disjoint vertex sets of a graph, the density is . The pair is -regular if for all , with , . A partition into parts of almost equal size is -regular if all but at most of the pairs are -regular.
Definition— Fourier transform on ℤ/Nℤ
For put , where and . Then and Parseval's identity holds: .
Definition— cap set
A cap set is a subset of containing no three distinct points on a line, i.e. no , not all equal, with — the analogue of a 3-AP-free set.
Examples
Example— Turán graphs
has edges and no triangle; (the octahedron) has edges and no . The first experiment checks all graphs on six vertices: these are the maxima, and the only graphs attaining them are copies of the Turán graphs ( labelled copies of , of ).
Example— The Paley graph and R(4, 4) > 17
Join when is a non-zero square (). This graph is -regular, it is isomorphic to its complement (multiply by the non-square ), every adjacent pair has exactly common neighbours and every non-adjacent pair — a "pseudo-random" graph. It has no and, by self-complementarity, no independent set of size . So ; Greenwood and Gleason (1955) showed .
Example— Sets without three-term progressions
The integers whose base- digits are all or contain no 3-AP: if with such digits, then adding digit by digit produces no carries and neither does doubling , so the digits agree and . Below there are of them, about . Behrend (1946) did much better: lattice points on a sphere in a high-dimensional box, read as base- digits, give . This is larger than for every , yet still , as Roth's theorem requires. The squares, by contrast, contain many 3-APs (; in general , , ), but no 4-term progression (Fermat, proved by Euler).
Example— Sums versus products
For , but is much larger (asymptotically with , by Ford's work on the multiplication table). For , but . The second experiment computes both for : in each case one of the two is large.
Example— Cap sets
In the largest cap set has points (e.g. ). The maximum sizes for are , the last found by Potechin (2008). They are the maximum numbers of cards in the game SET (for ) with no "set" among them.
Extremal graph theory and Ramsey numbers
Theorem— Theorem 1 (Turán 1941)
Let . Every graph on vertices with no has at most edges, with equality only for . In particular .
Proof
(Zykov symmetrisation.) Let be -free on vertices with the maximum number of edges. For a vertex , "replacing by a copy of " means deleting and adding a new vertex adjacent exactly to . The new graph is still -free: a clique cannot contain both and (they are not adjacent), and a clique through but not becomes a clique through when is replaced by .
Step 1: non-adjacency is transitive. Suppose and but (so ). If , replace by a copy of : since , this changes the edge count by , contradicting maximality; similarly if . Otherwise and ; replace both and by copies of (neither is a neighbour of , so is unchanged). We lose edges (the edge is counted twice) and gain , a net gain of at least — again a contradiction.
So "equal or non-adjacent" is an equivalence relation, and is complete multipartite. It has at most parts, since one vertex from each of parts would form a .
Step 2: the parts are balanced. A complete multipartite graph with parts of sizes has edges. If , moving a vertex from part to part changes the edge count by . So in the extremal graph all parts differ in size by at most one: . Finally by the Cauchy–Schwarz inequality, giving the bound .
∎
Mantel's theorem is the case . Turán's theorem is the starting point of a large theory. The Erdős–Stone theorem (1946), in the form noted by Erdős and Simonovits (1966), says : the chromatic number of alone determines the asymptotics — except when is bipartite, where it only says . Bipartite Turán problems are much harder: the Kővári–Sós–Turán theorem gives , and , but even the order of magnitude of is unknown.
Theorem— Theorem 2 (Ramsey 1930; Erdős–Szekeres 1935)
for , and . In particular .
Proof
Colour with and pick a vertex . Its other vertices split into red neighbours and blue neighbours, and by the pigeonhole principle there are at least of the first or at least of the second. In the first case they contain a blue (done) or a red , which with is a red ; the second case is symmetric. The binomial bound follows by induction on from and Pascal's rule. (The formal section proves exactly this in Lean, for graphs on any vertex type.)
∎
Theorem— Theorem 3 (Erdős 1947; Spencer 1975)
For , . More precisely .
Proof
(First part.) Colour the edges of , , independently at random. A fixed -set is monochromatic with probability , so the expected number of monochromatic is . Some colouring therefore has none. (Optimising in the same computation gives ; the deletion method — take larger, then delete one vertex from each monochromatic — improves the constant to , and Spencer's application of the Lovász local lemma to .)
∎
So . The lower bound has not been improved exponentially since 1947, and no explicit construction comes close to it. On the upper side, Thomason (1988), Conlon (2009) and Sah (2020) improved the lower-order factors, but the exponential base stood for 88 years until Campos, Griffiths, Morris and Sahasrabudhe (2023) proved for some ; subsequent work by Gupta, Ndiaye, Norin and Wei (2024) brought the base down to about .
Progressions: regularity, Fourier analysis and beyond
Theorem— Theorem 4 (Szemerédi's regularity lemma, 1975–78)
For every there is such that every graph has an -regular partition into parts with .
The proof refines partitions step by step, using an "energy" (mean square density) that is bounded by and increases by at each refinement as long as the partition is not regular; the resulting is a tower of 's of height polynomial in , and Gowers (1997) showed that tower-type growth is necessary. Its most famous consequence:
Theorem— Theorem 5 (triangle removal lemma; Ruzsa–Szemerédi 1978)
For every there is such that every graph on vertices with at most triangles can be made triangle-free by deleting at most edges.
(Apply the regularity lemma, delete the edges inside parts, between irregular pairs and between sparse pairs — at most in all — and observe that a triangle surviving among three dense regular pairs would force, by the counting lemma, triangles.)
Theorem— Theorem 6 (Roth 1953)
: for every , every with contains a three-term progression once is large enough.
Proof
(Via the removal lemma, Ruzsa–Szemerédi.) Let contain no 3-AP, and let , so that is invertible in and no progression of elements of wraps around. Build a tripartite graph with parts , each a copy of , joining to if , to if , and to if . A triangle gives , , in with , hence (all three lie in and ): this is the progression , which is trivial only if . So the only triangles are the "trivial" ones , and they are edge-disjoint (each edge determines and ). Fix and let be as in the removal lemma. The graph has vertices and triangles once , so deleting at most edges destroys all of them. Each deleted edge destroys at most one of the edge-disjoint triangles, so , i.e. . As was arbitrary, .
∎
Roth's original proof was Fourier-analytic, and it gives quantitative bounds () that the removal lemma cannot. Its heart is the following lemma, which we prove in full.
Theorem— Lemma 7 (the key lemma of Roth's argument)
Let be odd and have density with . If contains no non-trivial 3-AP (), then for some .
Proof
Let and . Substituting , (so ), and expanding each by Fourier inversion,
because is when and , and otherwise. If has no non-trivial 3-AP, only contributes to , so . The term is . Hence
using that is a bijection of the non-zero residues ( odd) and Parseval's identity . So some .
∎
The density increment (outline). A large coefficient means that correlates with the character . By Dirichlet's approximation theorem one can partition into progressions of length about on each of which is nearly constant modulo ; averaging, has density at least on one of them, for an absolute constant (after a standard reduction to avoid wrap-around). Restrict to that progression, rescale it to with , and repeat. The density cannot exceed , so after steps the process must stop — which can only happen because contains a 3-AP or has become too small. This gives .
Theorem— Theorem 8 (Szemerédi 1975)
Every subset of the integers with positive upper density contains arbitrarily long arithmetic progressions; equivalently for every .
There are four fundamentally different proofs: Szemerédi's combinatorial proof (which introduced the regularity lemma); Furstenberg's ergodic-theoretic proof (1977), via a multiple recurrence theorem for measure-preserving systems; Gowers's proof (1998–2001) by "higher-order Fourier analysis" with the norms , the first with reasonable bounds; and proofs via the hypergraph removal lemma (Gowers; Nagle, Rödl, Schacht and Skokan, 2004–07).
Theorem— Theorem 9 (Green–Tao 2004, published 2008)
The primes contain arbitrarily long arithmetic progressions.
The proof is a transference principle: Szemerédi's theorem holds not only for dense subsets of the integers but for dense subsets of suitably pseudorandom sparse sets. Green and Tao show that the primes are a dense subset of the "almost primes", weighted by a majorant built from the sieve weights of Goldston and Yıldırım, which is pseudorandom in the required sense. The theorem gives arbitrarily long finite progressions — the primes contain no infinite one (see the misconceptions). Tao and Ziegler (2008) extended it to polynomial progressions.
Theorem— Theorem 10 (Dvir 2008: finite-field Kakeya)
If contains a line in every direction, then .
Proof
The polynomials of degree at most in variables over form a vector space of dimension . If were smaller, the linear conditions " for " would have a non-zero solution: a polynomial of degree vanishing on . Since , is not a non-zero constant, so . Write with homogeneous of degree . For every direction , contains a line , so , a polynomial in of degree at most , has roots and is identically zero. Its coefficient of is , so for all , and by homogeneity. Thus vanishes on all of although its degree in each variable is at most , which forces (induct on : a non-zero one-variable polynomial of degree has fewer than roots). This contradiction proves .
∎
The same philosophy — find a low-degree polynomial vanishing on the set, then exploit the structure — solved several famous problems: the cap set problem (Croot, Lev and Pach for ; Ellenberg and Gijswijt, 2016: every cap set in has size at most for large , using what is now called the slice-rank method), and Guth and Katz's near-solution of Erdős's distinct distances problem (2010). Over , the Kakeya conjecture is much harder; for a proof was announced by Wang and Zahl in 2025.
Theorem— Theorem 11 (Freiman 1964–73; Ruzsa 1994)
If is finite with , then is contained in a generalised arithmetic progression of dimension at most and size at most .
The simplest case is formalised below: , with equality only for arithmetic progressions. The polynomial Freiman–Ruzsa conjecture asks for bounds polynomial in ; Gowers, Green, Manners and Tao proved it in in November 2023 (over it remains open).
The landscape: known and open
Recent theorems. Kelley and Meka (2023) proved , close in shape to Behrend's lower bound (Bloom and Sisask improved to ); an earlier bound of Bloom and Sisask (2020) already settled the case of the Erdős–Turán conjecture below. For longer progressions, Leng, Sah and Sawhney (2024) proved . In Ramsey theory: (Ajtai–Komlós–Szemerédi, 1980; Kim, 1995); Mattheus and Verstraete (2023) showed , matching the upper bound up to logarithms; and the exponential improvement of the diagonal upper bound described above.
Open problems (well documented; consult recent surveys for progress):
- Small Ramsey numbers. is unknown; it lies between (Exoo, 1989) and (Angeltveit and McKay, 2024).
- Growth of . Does exist, and what is it? It lies between and about . Erdős offered a prize for the existence of the limit.
- Erdős–Turán. If , must contain arbitrarily long progressions? Known for ; open for (it would imply Green–Tao).
- Sum–product. Erdős and Szemerédi (1983) proved for finite and conjectured exponent . The best exponents known are plus small explicit improvements (Solymosi, 2009; Konyagin–Shkredov; Rudnev–Stevens).
- Cap sets. The largest cap set in has size with (roughly); the true base is unknown.
- Bipartite Turán problems, such as the order of magnitude of or ; and the polynomial Freiman–Ruzsa conjecture over .
Combinatorics in Lean and Mathlib
Additive combinatorics is one of the best-formalised parts of modern mathematics: Mathlib contains Szemerédi's regularity lemma, the triangle removal lemma, Roth's theorem, the Cauchy–Davenport theorem, Plünnecke–Ruzsa inequalities and Turán's theorem, much of it by Yaël Dillies and Bhavik Mehta. Moreover, the November 2023 proof of the polynomial Freiman–Ruzsa conjecture over was completely formalised in Lean 4 with Mathlib about three weeks after it appeared, in an open collaborative project led by Terence Tao.
Turán's theorem, structural form:
/-- **Turán's theorem**, structural form: for `r ≥ 1`, a graph on `n` vertices is
*Turán-maximal* (it has no `K_{r+1}` and as many edges as possible among such graphs) if and
only if it is isomorphic to the Turán graph `T(n, r)`, the complete `r`-partite graph with parts
as equal as possible. This applies Mathlib's `SimpleGraph.isTuranMaximal_iff_nonempty_iso_turanGraph`
(proved there by Zykov symmetrisation). -/
theorem turan_structure {V : Type*} [Fintype V] (G : SimpleGraph V) [DecidableRel G.Adj] {r : ℕ}
(hr : 0 < r) :
G.IsTuranMaximal r ↔ Nonempty (G ≃g SimpleGraph.turanGraph (Fintype.card V) r) :=
SimpleGraph.isTuranMaximal_iff_nonempty_iso_turanGraph hrRamsey numbers. We define the Ramsey property for graphs on any vertex type and prove the Erdős–Szekeres recursion and its consequences ourselves, mirroring the proof of Theorem 2 (the graph theory module proves by a direct argument; here the bounds are general):
/-- `RamseyProp α s t m` says: in **every** graph `G` on the vertex type `α`, **every** set `W` of
at least `m` vertices contains `s` vertices that are pairwise adjacent (an `s`-clique of `G`) or
`t` vertices that are pairwise non-adjacent (a `t`-clique of the complement `Gᶜ`). Colouring
the edges of `G` red and the non-edges blue, this is "`m ≥ R(s, t)`" for colourings of the
complete graph on `W`. Quantifying over all `W` inside one type avoids induced subgraphs. -/
def RamseyProp (α : Type*) (s t m : ℕ) : Prop :=
∀ (G : SimpleGraph α) (W : Finset α), m ≤ W.card →
∃ S ⊆ W, G.IsNClique s S ∨ Gᶜ.IsNClique t S/-- `R(1, t) ≤ 1`: any single vertex is a `1`-clique. -/
theorem ramsey_one_left {α : Type*} (t : ℕ) : RamseyProp α 1 t 1 := by
intro G W hW
obtain ⟨v, hv⟩ : W.Nonempty := Finset.card_pos.mp (by omega)
exact ⟨{v}, Finset.singleton_subset_iff.mpr hv, Or.inl (SimpleGraph.isNClique_one.mpr ⟨v, rfl⟩)⟩/-- `R(s, 1) ≤ 1`: any single vertex is a `1`-clique of the complement. -/
theorem ramsey_one_right {α : Type*} (s : ℕ) : RamseyProp α s 1 1 := by
intro G W hW
obtain ⟨v, hv⟩ : W.Nonempty := Finset.card_pos.mp (by omega)
exact ⟨{v}, Finset.singleton_subset_iff.mpr hv, Or.inr (SimpleGraph.isNClique_one.mpr ⟨v, rfl⟩)⟩/-- **The Erdős–Szekeres recursion** `R(s + 1, t + 1) ≤ R(s, t + 1) + R(s + 1, t)`.
Proof, as in the lesson: pick a vertex `v ∈ W` and split the other `|W| − 1 ≥ a + b − 1` vertices
into neighbours `N` and non-neighbours `M`. By pigeonhole `|N| ≥ a` or `|M| ≥ b`. In `N` we find
an `s`-clique (add `v` to get an `(s + 1)`-clique) or an independent `(t + 1)`-set; in `M` an
`(s + 1)`-clique or an independent `t`-set (add `v`). -/
theorem ramsey_step {α : Type*} [DecidableEq α] {s t a b : ℕ}
(hA : RamseyProp α s (t + 1) a) (hB : RamseyProp α (s + 1) t b) (hab : 0 < a + b) :
RamseyProp α (s + 1) (t + 1) (a + b) := by
classical
intro G W hW
obtain ⟨v, hv⟩ : W.Nonempty := Finset.card_pos.mp (by omega)
-- neighbours and non-neighbours of `v` in `W`
set N := (W.erase v).filter (G.Adj v) with hN
set M := (W.erase v).filter (fun w => ¬ G.Adj v w) with hM
have hcard : N.card + M.card = W.card - 1 := by
rw [hN, hM, Finset.card_filter_add_card_filter_not, Finset.card_erase_of_mem hv]
have hNW : N ⊆ W := (Finset.filter_subset _ _).trans (Finset.erase_subset _ _)
have hMW : M ⊆ W := (Finset.filter_subset _ _).trans (Finset.erase_subset _ _)
by_cases hNa : a ≤ N.card
· obtain ⟨S, hSN, hS | hS⟩ := hA G N hNa
· -- an `s`-clique of neighbours, plus `v`
refine ⟨insert v S, Finset.insert_subset hv (hSN.trans hNW), Or.inl ?_⟩
exact hS.insert fun w hw => (Finset.mem_filter.mp (hSN hw)).2
· exact ⟨S, hSN.trans hNW, Or.inr hS⟩
· -- pigeonhole: otherwise `M` is large
have hMb : b ≤ M.card := by omega
obtain ⟨S, hSM, hS | hS⟩ := hB G M hMb
· exact ⟨S, hSM.trans hMW, Or.inl hS⟩
· -- an independent `t`-set of non-neighbours, plus `v`
refine ⟨insert v S, Finset.insert_subset hv (hSM.trans hMW), Or.inr ?_⟩
refine hS.insert fun w hw => ?_
have hw' := Finset.mem_filter.mp (hSM hw)
rw [SimpleGraph.compl_adj]
exact ⟨fun h => (Finset.ne_of_mem_erase hw'.1) h.symm, hw'.2⟩/-- **The Erdős–Szekeres bound** (1935): `R(s + 1, t + 1) ≤ C(s + t, s)`, i.e.
`R(s, t) ≤ C(s + t − 2, s − 1)`. Induction on `s` and `t`, with the base cases `R(1, t) = R(s, 1)
= 1` and Pascal's rule `C(s + t + 2, s + 1) = C(s + t + 1, s) + C(s + t + 1, s + 1)` matching
the recursion `ramsey_step`. -/
theorem ramsey_binomial {α : Type*} [DecidableEq α] :
∀ s t : ℕ, RamseyProp α (s + 1) (t + 1) ((s + t).choose s) := by
intro s
induction s with
| zero => intro t; simpa using ramsey_one_left (α := α) (t + 1)
| succ s ihs =>
intro t
induction t with
| zero => simpa using ramsey_one_right (α := α) (s + 1 + 1)
| succ t iht =>
have hc : (s + 1 + (t + 1)).choose (s + 1) =
(s + (t + 1)).choose s + (s + 1 + t).choose (s + 1) := by
rw [show s + 1 + (t + 1) = (s + t + 1) + 1 by omega, Nat.choose_succ_succ,
show s + (t + 1) = s + t + 1 by omega, show s + 1 + t = s + t + 1 by omega]
rw [hc]
exact ramsey_step (ihs (t + 1)) iht
(by have := Nat.choose_pos (show s ≤ s + (t + 1) by omega); omega)/-- The diagonal case: `R(k + 1, k + 1) ≤ C(2k, k) ≤ 4ᵏ`. Every graph on `4ᵏ` vertices contains
`k + 1` vertices that are pairwise adjacent or pairwise non-adjacent. (Erdős's random colourings
show that the base `4` cannot be replaced by anything below `√2`.) -/
theorem ramsey_diag {α : Type*} [DecidableEq α] (k : ℕ) :
RamseyProp α (k + 1) (k + 1) (4 ^ k) := by
intro G W hW
apply ramsey_binomial k k G W
calc (k + k).choose k ≤ 2 ^ (k + k) := Nat.choose_le_two_pow _ _
_ = 4 ^ k := by rw [← two_mul, pow_mul]; norm_num
_ ≤ W.card := hWSumsets: an independent proof of in , Mathlib's general version, and Cauchy–Davenport in :
/-- **The simplest inverse-theorem bound**: for non-empty finite `A, B ⊆ ℤ`,
`|A + B| ≥ |A| + |B| − 1` (equality when `A` and `B` are progressions with the same difference).
Proof by induction on `A`, adding its largest element `a` last: `a + max B` is larger than every
sum in `A' + B`, where `A' = A \ {a}`, so `|A + B| ≥ |A' + B| + 1`. -/
theorem sumset_lower (B : Finset ℤ) (hB : B.Nonempty) :
∀ A : Finset ℤ, A.Nonempty → A.card + B.card - 1 ≤ (A + B).card := by
intro A
induction A using Finset.induction_on_max with
| empty => intro h; exact absurd h Finset.not_nonempty_empty
| insert a s hlt ih =>
intro _
have has : a ∉ s := fun h => lt_irrefl a (hlt a h)
rcases s.eq_empty_or_nonempty with rfl | hs
· simp [Finset.card_singleton_add]
· set m := B.max' hB
-- the new sum `a + max B` exceeds every old sum
have hnot : a + m ∉ s + B := by
intro h
obtain ⟨x, hx, y, hy, hxy⟩ := Finset.mem_add.mp h
have h1 := hlt x hx
have h2 := Finset.le_max' B y hy
omega
have hsub : insert (a + m) (s + B) ⊆ insert a s + B :=
Finset.insert_subset (Finset.add_mem_add (Finset.mem_insert_self _ _) (Finset.max'_mem _ _))
(Finset.add_subset_add (Finset.subset_insert _ _) (subset_refl B))
have := Finset.card_le_card hsub
rw [Finset.card_insert_of_notMem hnot] at this
rw [Finset.card_insert_of_notMem has]
have := ih hs
omega/-- Mathlib's version of `sumset_lower`, for any linearly ordered cancellative additive
semigroup. This applies `cauchy_davenport_add_of_linearOrder_isCancelAdd`. -/
theorem cauchy_davenport_ordered {α : Type*} [LinearOrder α] [Add α] [IsCancelAdd α]
[AddLeftMono α] [AddRightMono α] {A B : Finset α} (hA : A.Nonempty) (hB : B.Nonempty) :
A.card + B.card - 1 ≤ (A + B).card :=
cauchy_davenport_add_of_linearOrder_isCancelAdd hA hB/-- **The Cauchy–Davenport theorem** (Cauchy 1813, Davenport 1935): for non-empty `A, B ⊆ ℤ/pℤ`
with `p` prime, `|A + B| ≥ min(p, |A| + |B| − 1)`. In `ℤ/pℤ` sums can wrap around, so the
ordering argument fails; Mathlib proves it by DeVos's induction for arbitrary groups. This
applies `ZMod.cauchy_davenport`. -/
theorem cauchy_davenport_zmod {p : ℕ} (hp : p.Prime) {A B : Finset (ZMod p)} (hA : A.Nonempty)
(hB : B.Nonempty) : min p (A.card + B.card - 1) ≤ (A + B).card :=
ZMod.cauchy_davenport hp hA hBThree-term progressions: a base- set checked by the kernel, hence ; Roth's theorem; and the regularity lemma.
/-- The numbers below `14` whose base-3 digits are all `0` or `1`,
`{0, 1, 3, 4, 9, 10, 12, 13}`, contain no three-term arithmetic progression `a, b, c` with
`a + c = 2b` and `a ≠ b`. (Doubling a number with digits `0, 1` creates no carries in base 3, so
`a + c = 2b` forces equal digits.) Checked here by the kernel (`decide`) using Mathlib's
`ThreeAPFree`. -/
theorem stanley_three_ap_free :
ThreeAPFree ((({0, 1, 3, 4, 9, 10, 12, 13} : Finset ℕ)) : Set ℕ) := by
decide/-- Hence `r₃(14) ≥ 8`: `{0, …, 13}` contains a 3AP-free set of size 8. (In fact `r₃(14) = 8`.)
Uses Mathlib's `ThreeAPFree.le_rothNumberNat`. -/
theorem roth_number_14 : 8 ≤ rothNumberNat 14 :=
ThreeAPFree.le_rothNumberNat _ stanley_three_ap_free (by decide) (by decide)/-- **Roth's theorem** (1953): `r₃(N) = o(N)` — for every `δ > 0`, every subset of `{0, …, N − 1}`
with at least `δN` elements contains a non-trivial three-term progression once `N` is large.
Mathlib proves it (Dillies and Mehta) through the triangle removal lemma and the
corners theorem — a different route from Roth's Fourier-analytic proof sketched in the
lesson. This applies `rothNumberNat_isLittleO_id`. -/
theorem roth_theorem :
(fun N => (rothNumberNat N : ℝ)) =o[Filter.atTop] (fun N => (N : ℝ)) :=
rothNumberNat_isLittleO_id/-- **Szemerédi's regularity lemma** (1975–78), effective form: for every `ε > 0` and `l`, every
graph on at least `l` vertices has an `ε`-uniform equipartition into at least `l` and at most
`bound ε l` parts, where the bound depends only on `ε` and `l`, not on the graph. (The bound is
a tower of exponentials, and Gowers showed towers are necessary.) This applies Mathlib's
`szemeredi_regularity`, formalised by Dillies and Mehta. -/
theorem szemeredi_regularity_lemma {α : Type*} [DecidableEq α] [Fintype α] (G : SimpleGraph α)
[DecidableRel G.Adj] {ε : ℝ} {l : ℕ} (hε : 0 < ε) (hl : l ≤ Fintype.card α) :
∃ P : Finpartition (Finset.univ : Finset α), P.IsEquipartition ∧ l ≤ P.parts.card ∧
P.parts.card ≤ SzemerediRegularity.bound ε l ∧ P.IsUniform G ε :=
szemeredi_regularity G hε hlWhat is and is not formalised. Formalised here: the Ramsey recursion and the bounds and ; the sumset bound; an explicit 3-AP-free set. From Mathlib: Turán, Cauchy–Davenport, Roth (via removal, not via Lemma 7), the regularity lemma. Not formalised: Erdős's lower bound and the deletion method, Lemma 7 and the density increment, Szemerédi's theorem for , Green–Tao, Dvir's theorem and the cap set bound (the latter has been formalised in Lean 3 by Dahmen, Hölzl and Lewis, 2019, but is not in Mathlib), and the sum–product estimates.
Exhaustive searches and what they cannot show
The first experiment confirms Turán's theorem on six vertices by checking all labelled graphs, verifies that the Paley graph on vertices has no homogeneous -set (so ), and tabulates the probabilistic lower bounds and the Erdős–Szekeres upper bound for .
"""Extremal graphs and Ramsey numbers by exhaustive search.
1. Turan's theorem on 6 vertices: we run through all 2^15 = 32768 labelled
graphs on 6 vertices, find the maximum number of edges with no triangle and
with no K4, and check that every extremal graph is a Turan graph
(complete multipartite with parts as equal as possible).
2. R(4, 4) > 17: the Paley graph on Z/17 (x ~ y when x - y is a non-zero
square) has no 4-clique and no independent set of 4 vertices; we check all
2380 four-element subsets.
3. Bounds for diagonal Ramsey numbers: Erdos's first-moment bound, the
improvement from the deletion method, and the Erdos-Szekeres upper bound.
"""
import itertools
import math
def edge_bits(n):
"""Map each pair {i, j}, i < j, of range(n) to a bit position."""
return {e: b for b, e in enumerate(itertools.combinations(range(n), 2))}
def clique_masks(n, r, bits):
"""Bit masks of the edge sets of all r-cliques of K_n."""
masks = []
for S in itertools.combinations(range(n), r):
m = 0
for e in itertools.combinations(S, 2):
m |= 1 << bits[e]
masks.append(m)
return masks
def is_free(graph, masks):
"""True if the graph (an edge bit mask) contains none of the given cliques."""
return all(graph & m != m for m in masks)
def non_adjacency_classes(graph, n, bits):
"""Sizes of the classes of 'equal or non-adjacent', if it is an equivalence
relation (i.e. the graph is complete multipartite); otherwise None."""
def adj(i, j):
return i != j and graph >> bits[(min(i, j), max(i, j))] & 1
classes, seen = [], set()
for i in range(n):
if i in seen:
continue
cls = {j for j in range(n) if not adj(i, j)}
if any(adj(a, b) for a in cls for b in cls):
return None
seen |= cls
classes.append(len(cls))
return sorted(classes)
def turan_part_sizes(n, r):
"""Part sizes of the Turan graph T(n, r): as equal as possible."""
return sorted([n // r + (1 if i < n % r else 0) for i in range(r)])
def turan_edges(n, r):
"""Number of edges of T(n, r)."""
parts = turan_part_sizes(n, r)
return (n * n - sum(p * p for p in parts)) // 2
def extremal_graphs(n, r):
"""(max edges, list of extremal graphs) among K_(r+1)-free graphs on n vertices."""
bits = edge_bits(n)
masks = clique_masks(n, r + 1, bits)
best, graphs = -1, []
for g in range(1 << len(bits)):
if is_free(g, masks):
e = bin(g).count("1")
if e > best:
best, graphs = e, [g]
elif e == best:
graphs.append(g)
return best, graphs
def paley_graph(q):
"""Adjacency sets of the Paley graph on Z/q (q prime, q = 1 mod 4)."""
squares = {x * x % q for x in range(1, q)}
return [{y for y in range(q) if (x - y) % q in squares} for x in range(q)]
def homogeneous_sets(adj, k):
"""Number of k-sets that are cliques or independent sets."""
count = 0
for S in itertools.combinations(range(len(adj)), k):
pairs = [(a, b) for a, b in itertools.combinations(S, 2)]
edges = sum(1 for a, b in pairs if b in adj[a])
count += edges == 0 or edges == len(pairs)
return count
def erdos_bound(k):
"""Largest n with C(n, k) 2^(1 - C(k, 2)) < 1 (so R(k, k) > n)."""
n = k
while math.comb(n + 1, k) * 2 < 2 ** math.comb(k, 2):
n += 1
return n
def deletion_bound(k):
"""max over n of floor(n - C(n, k) 2^(1 - C(k, 2))) (so R(k, k) > it).
Exact integer arithmetic: floor(n - x) = n - ceil(x)."""
best, n, denominator = 0, k, 2 ** math.comb(k, 2)
while True:
value = n - (-(-2 * math.comb(n, k) // denominator))
if value < best - 50:
return best
best = max(best, value)
n += 1
def main():
n = 6
bits = edge_bits(n)
print(f"1. All {2 ** len(bits)} labelled graphs on {n} vertices:")
for r in (2, 3):
best, graphs = extremal_graphs(n, r)
shapes = {tuple(non_adjacency_classes(g, n, bits) or ()) for g in graphs}
print(f" no K{r + 1}: max {best} edges (T({n},{r}) has "
f"{turan_edges(n, r)}); {len(graphs)} extremal graphs,")
print(f" all complete multipartite with parts {sorted(shapes)} "
f"(Turan: {tuple(turan_part_sizes(n, r))})")
print()
adj = paley_graph(17)
print("2. Paley graph on Z/17 (x ~ y iff x - y is a non-zero square):")
print(f" degree {len(adj[0])}; 4-sets that are cliques or independent: "
f"{homogeneous_sets(adj, 4)} of {math.comb(17, 4)}")
print(f" triangles or independent 3-sets: {homogeneous_sets(adj, 3)}")
print(" so R(4, 4) > 17 (and R(4, 4) = 18: Greenwood-Gleason, 1955)")
print()
print("3. Bounds for R(k, k):")
print(" k first moment deletion Erdos-Szekeres C(2k-2, k-1)")
for k in range(4, 11):
print(f" {k:2d} {erdos_bound(k):12d} {deletion_bound(k):8d} "
f"{math.comb(2 * k - 2, k - 1):27d}")
print(" (lower bounds: R(k, k) exceeds the number shown)")
print()
print("Epistemic status: parts 1 and 2 are exact and exhaustive for 6 and 17")
print("vertices, so they prove these finite statements if the code is right;")
print("Turan's and Ramsey's theorems for all n are proved in the lesson. Part")
print("3 is exact arithmetic applied to proved bounds; it says nothing about")
print("the true values, which are unknown for k >= 5.")
if __name__ == "__main__":
main()The second computes the Roth numbers for exactly by backtracking (each search is pruned using the smaller Roth numbers already computed), finds the progressions of primes of lengths to with the smallest last term, and compares with .
"""Progressions in dense sets and in the primes; sums versus products.
1. Roth numbers: r3(N), the size of the largest subset of {0, ..., N-1} with no
three-term arithmetic progression, computed exactly by backtracking for
N <= 40. Roth's theorem says r3(N)/N -> 0, but the decay is extremely slow.
We compare with the "base-3 digits 0 and 1" sets, which are 3AP-free.
2. Green-Tao: the primes contain arbitrarily long (finite) progressions. We
find, for k = 3, ..., 7, the k-term progression of primes with the smallest
last term.
3. Sum-product: for A = {1, ..., n}, |A + A| is small and |A . A| is large;
for a geometric progression it is the other way round. Erdos and
Szemeredi conjectured that one of the two is always nearly |A|^2.
"""
import math
def roth_number(N, smaller=()):
"""r3(N): the largest size of a subset of {0, ..., N-1} with no 3-term AP.
`smaller` may list the known values r3(0), r3(1), ..., r3(N - 1). They speed
up the exhaustive search: the elements still to be chosen lie in an interval
of length L and form a 3AP-free set, so there are at most r3(L) of them."""
table = list(smaller)
def room(length):
if length < len(table):
return table[length]
return length if not table else table[-1] + length - len(table) + 1
best = table[-1] if table else 0 # a set for N - 1 also works for N
chosen, member = [], [False] * N
def ends_progression(x):
# x is larger than every chosen element: it ends an AP a, b, x iff
# a = 2b - x was chosen for some chosen b
for b in chosen:
a = 2 * b - x
if a >= 0 and member[a]:
return True
return False
def extend(x, size):
nonlocal best
if size + room(N - x) <= best:
return # cannot beat the best set known so far
if x == N:
best = size
return
if not ends_progression(x):
chosen.append(x)
member[x] = True
extend(x + 1, size + 1)
chosen.pop()
member[x] = False
extend(x + 1, size)
extend(0, 0)
return best
def roth_numbers(n_max):
"""[r3(1), ..., r3(n_max)], each search using all the smaller values."""
table = [0]
for N in range(1, n_max + 1):
table.append(roth_number(N, table))
return table[1:]
def has_three_ap(A):
"""True if the set A contains a, b, c with a < b < c and a + c = 2b."""
s = sorted(set(A))
members = set(s)
return any((a + c) % 2 == 0 and (a + c) // 2 in members
for i, a in enumerate(s) for c in s[i + 2:])
def base3_set(N):
"""Numbers below N whose base-3 digits are all 0 or 1 (a 3AP-free set)."""
def ok(n):
while n:
if n % 3 == 2:
return False
n //= 3
return True
return [n for n in range(N) if ok(n)]
def prime_sieve(n):
"""sieve[i] is 1 exactly when i < n is prime."""
sieve = bytearray([1]) * max(n, 2)
sieve[0] = sieve[1] = 0
for i in range(2, int(n ** 0.5) + 1):
if sieve[i]:
sieve[i * i::i] = bytearray(len(range(i * i, n, i)))
return sieve
def smallest_prime_progression(k, limit=2000):
"""The k-term AP of primes with the smallest last term below limit, or None."""
sieve = prime_sieve(limit)
for last in range(2, limit):
if not sieve[last]:
continue
for d in range(1, (last - 2) // (k - 1) + 1):
if all(sieve[last - i * d] for i in range(1, k)):
return [last - i * d for i in range(k - 1, -1, -1)]
return None
def sum_and_product_sizes(A):
"""(|A + A|, |A . A|) for a finite set of integers A."""
return (len({a + b for a in A for b in A}),
len({a * b for a in A for b in A}))
def main():
values = roth_numbers(40)
print("1. Roth numbers r3(N), N = 1..40 (exact, exhaustive):")
print(" " + " ".join(str(v) for v in values[:20]))
print(" " + " ".join(str(v) for v in values[20:]))
for N in (10, 20, 40):
b = base3_set(N)
print(f" N = {N}: r3/N = {values[N - 1] / N:.2f}; base-3 set has "
f"{len(b)} elements, 3AP-free: {not has_three_ap(b)}")
print(" base-3 sets have about N^0.63 elements; Behrend (1946) does")
print(" better: N exp(-c sqrt(log N)), still o(N) as Roth requires.")
print()
print("2. Progressions of k primes with the smallest last term:")
for k in range(3, 8):
ap = smallest_prime_progression(k)
print(f" k = {k}: {', '.join(map(str, ap))} (difference {ap[1] - ap[0]})")
print()
print("3. Sums versus products, |A| = 20:")
n = 20
for name, A in [("{1, ..., 20}", list(range(1, n + 1))),
("{1, 2, 4, ..., 2^19}", [2 ** i for i in range(n)])]:
s, p = sum_and_product_sizes(A)
print(f" A = {name:20s} |A + A| = {s:3d} |A . A| = {p:3d}")
print(f" (|A|^2 = {n * n}; max(|A+A|, |A.A|) is large in both cases)")
print()
print("Epistemic status: exact, exhaustive computations for the sizes shown.")
print("Roth's theorem (r3(N)/N -> 0) and Green-Tao are theorems about")
print("N -> infinity; finite tables cannot confirm or refute them, and the")
print("sum-product conjecture remains open despite such examples.")
if __name__ == "__main__":
main()These computations are exact and exhaustive for the sizes shown, so they prove finite statements such as or (assuming the code is correct). They say nothing reliable about asymptotics: falls from to between and , but Roth's theorem — that it tends to — is invisible at this scale, and Behrend's construction shows the decay is slower than any power of . The same caution applies to Ramsey numbers: the exhaustive methods that settle are hopeless for , where has colourings.
Exploring extremal and pseudo-random graphs
A Turán graph. has parts of sizes and edges. Use the colouring tab: three colours suffice (one per part), so it has no ; "Fewest possible?" confirms that it needs exactly three. Then try to add an edge mentally: any new edge lies inside a part, and together with one vertex from each of the other two parts it creates a — Turán's theorem says no -free graph on vertices has more edges.
The Turán graph T(7, 3)
Complete 3-partite with parts {a}, {b}, {c}: 16 edges and no K₄.
0
colours used
0
clashes
7
uncoloured
Give every vertex a colour so that the two ends of each edge differ.
The Paley graph on 17 vertices. Open the matrix tab and look at : its off-diagonal entries count common neighbours, and they take only two values — for adjacent pairs, for non-adjacent pairs. Every pair "sees" almost exactly the number of common neighbours a random graph of density would give (). This quasirandomness (in the sense of Chung, Graham and Wilson) is why the graph has no homogeneous -set, and why Paley graphs are good, though not optimal for large , Ramsey colourings.
The Paley graph on Z/17
x ~ y when x − y is a non-zero square mod 17: no 4-clique and no independent 4-set.
Choose a cell: its row is the start vertex, its column the end vertex.
Each row of A adds up to the degree of its vertex.
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | |||||||||||||||||
| 1 | |||||||||||||||||
| 2 | |||||||||||||||||
| 3 | |||||||||||||||||
| 4 | |||||||||||||||||
| 5 | |||||||||||||||||
| 6 | |||||||||||||||||
| 7 | |||||||||||||||||
| 8 | |||||||||||||||||
| 9 | |||||||||||||||||
| 10 | |||||||||||||||||
| 11 | |||||||||||||||||
| 12 | |||||||||||||||||
| 13 | |||||||||||||||||
| 14 | |||||||||||||||||
| 15 | |||||||||||||||||
| 16 |
Exercises
1. Extremal and additive combinatorics
Warm-upHumanHow many edges does the Turán graph have? (By Turán's theorem, this is the maximum number of edges of a -free graph on vertices.)
2. Extremal and additive combinatorics
Warm-upHumanWhat is the maximum number of edges in a triangle-free graph on vertices?
3. Extremal and additive combinatorics
CoreHumanWhat upper bound does the Erdős–Szekeres inequality give for ?
4. Extremal and additive combinatorics
CoreHumanIn the Zykov symmetrisation proof of Turán's theorem, we replace a vertex by a copy of a vertex with (so is adjacent exactly to ). Why does the new graph still contain no ?
5. Extremal and additive combinatorics
CoreHumanSzemerédi's theorem assumes positive upper density. Which infinite set shows that being infinite is not enough to force even a three-term progression?
6. Extremal and additive combinatorics
Warm-upHumanWhat exactly does the Green–Tao theorem say?
7. Extremal and additive combinatorics
StretchHumanIn the proof of Lemma 7 (Roth's key lemma) we bounded . Which facts does this step use?
8. Extremal and additive combinatorics
CoreFormalRecall RamseyProp α s t m: in every graph on α, every vertex set W with m ≤ W.card contains an s-clique or an independent t-set. Which statement expresses , and which theorem of the lesson proves it?
9. Extremal and additive combinatorics
CoreHumanDvir's theorem says that a Kakeya set has . What lower bound does it give for a Kakeya set in ?
10. Extremal and additive combinatorics
StretchComputationalWrite three_ap_free(A) (does the set A of integers contain no with ?) and roth_number(N), the largest size of a 3-AP-free subset of range(N), by trying all subsets from the largest size down. Check for .
Common misconceptions
Misconception
"Small Ramsey numbers are easy to compute." is a pleasant exercise and took real work, but is still unknown: deciding whether every colouring of contains a monochromatic means, naively, examining colourings. Erdős's famous quip imagined aliens demanding on pain of destroying Earth — we should marshal all our computers — but demanding , when we should rather try to destroy the aliens.
Misconception
"Green–Tao says the primes contain an infinite arithmetic progression." They contain arbitrarily long finite progressions, and no infinite one: if are all prime with , then the term is composite. Likewise Szemerédi's theorem gives arbitrarily long finite progressions in dense sets, not infinite ones (the set of numbers with an even number of decimal digits has positive upper density and contains no infinite progression).
Misconception
"An infinite set must contain long progressions." Size in the sense of cardinality is not enough: the powers of contain no 3-AP at all ( forces ). Szemerédi needs positive density; Green–Tao needs the special pseudorandomness of the primes; and the Erdős–Turán conjecture asks whether divergence of suffices.
Misconception
"The probabilistic method gives constructions." It proves existence: most colourings of with avoid monochromatic , but no one can write one down explicitly for large . The best explicit constructions — from Frankl and Wilson (1981) to recent work on randomness extractors by Chattopadhyay, Zuckerman, Cohen, Li and others — still give lower bounds far below .
Misconception
"The regularity lemma gives good bounds." It gives qualitative theorems with tower-type bounds, and Gowers showed that the towers cannot be avoided in the lemma itself. Quantitative results such as Kelley–Meka's bound for come from Fourier-analytic and probabilistic methods instead.
Viewpoints
Topology— Borsuk–Ulam, Kneser and recurrence
Topology proves combinatorial theorems that resist combinatorics. Kneser conjectured (1955) that if the -subsets of are coloured with colours, two disjoint subsets get the same colour; Lovász (1978) proved it with the Borsuk–Ulam theorem, founding topological combinatorics (Bárány's and Greene's short proofs followed). In the other direction, topological dynamics proves Ramsey-type statements: Furstenberg and Weiss (1978) deduced van der Waerden's theorem — any finite colouring of has monochromatic progressions of every length — from a multiple recurrence theorem for commuting homeomorphisms of a compact metric space. See algebraic topology.
Geometry— Incidences and the sum–product theorem
Elekes (1997) proved for finite by pure geometry. Consider the point set and the lines for . Each line contains the points , , of , so there are at least incidences. The Szemerédi–Trotter theorem bounds the incidences between points and lines in the plane by ; hence , so . Geometry over finite fields is subtler (no ordering), which is why the polynomial method and Dvir's theorem were such breakthroughs.
Analysis— Fourier analysis, Gowers norms and ergodic theory
Three-term progressions are controlled by Fourier coefficients (Lemma 7): the count is . Four-term progressions are not — there are sets with uniformly tiny Fourier coefficients but the "wrong" number of 4-APs, such as . Gowers introduced the uniformity norms that do control -APs, and the inverse theorems for these norms (Green–Tao–Ziegler, 2012) identify the obstructions as nilsequences: polynomial phases on nilmanifolds. Furstenberg's correspondence principle translates Szemerédi's theorem into multiple recurrence for a measure-preserving system : for some whenever ; the structure theory of Host–Kra (2005) found the same nilmanifolds. See harmonic analysis and ergodic theory.
Probability— Random graphs and quasirandomness
The random graph has clique number and independence number about with high probability — which is exactly why . Chung, Graham and Wilson (1989) showed that many "random-like" properties of a graph sequence of density are equivalent: the right count of -cycles (), the right count of every fixed subgraph, small second eigenvalue, uniform edge distribution. The Paley graphs are quasirandom in this sense. The dichotomy "quasirandom or structured" is the probabilistic face of the regularity lemma, and Lovász and Szegedy's theory of graph limits (graphons) packages it analytically. See the probabilistic method.
Number theory— Primes and pseudorandomness
For number theorists the prize is the primes. Van der Corput (1939) proved that the primes contain infinitely many 3-APs, using the circle method of Hardy and Littlewood; Green and Tao proved arbitrarily long progressions, and Green, Tao and Ziegler (2010–12) then proved the Hardy–Littlewood asymptotic for the number of -APs of primes up to , and for any "finite complexity" linear pattern. The Möbius function's lack of correlation with nilsequences (Green–Tao) is a key input. Twin primes, a pattern of "infinite complexity" for these methods, remain out of reach, although Zhang (2013) and Maynard–Tao proved bounded gaps between primes.
Logic— Unprovability and ultrafilters
Ramsey's theorem was a lemma in logic (on the decision problem, 1930). A mild strengthening of the finite Ramsey theorem — the homogeneous set must be "large", of size at least its minimum element — is true but unprovable in Peano arithmetic (Paris–Harrington, 1977), because the corresponding Ramsey function grows faster than any function PA can prove total. In the other direction, ultrafilters give slick proofs: Hindman's theorem (any finite colouring of has an infinite set all of whose finite sums have one colour) follows from the existence of an idempotent ultrafilter in (Galvin–Glazer). See incompleteness.
History and global context
- 1907–1930. Willem Mantel's triangle theorem (1907); Issai Schur (1916) proves that any finite colouring of , large, has a monochromatic solution of , motivated by Fermat's Last Theorem modulo ; B. L. van der Waerden (1927) proves his theorem on monochromatic progressions; Frank Ramsey (1930) proves his theorem as a lemma in logic.
- 1935–1947. Erdős and Szekeres rediscover Ramsey's theorem in a geometric problem (1935); Erdős and Turán conjecture that dense sets contain long progressions (1936); Pál Turán proves his theorem (1941), while in a labour camp; Erdős's random colourings found the probabilistic method (1947); Behrend's construction (1946).
- 1953–1978. Klaus Roth's theorem (1953); Gregory Freiman's structure theory of sets with small doubling (1960s); Endre Szemerédi's theorem (1969 for , 1975 in general) and the regularity lemma; Hillel Furstenberg's ergodic proof (1977); Ruzsa–Szemerédi's removal lemma (1978); Lovász's proof of Kneser's conjecture (1978).
- 1983–2008. Erdős–Szemerédi's sum–product theorem (1983); Imre Ruzsa's new proof of Freiman's theorem (1994); Elekes's incidence proof (1997); Timothy Gowers's quantitative Szemerédi theorem (1998–2001); Ben Green and Terence Tao's theorem on primes (2004); Zeev Dvir's Kakeya theorem (2008).
- 2010–2024. Larry Guth and Nets Katz on distinct distances (2010); Croot–Lev–Pach and Ellenberg–Gijswijt on cap sets (2016); Kelley–Meka on three-term progressions and Campos–Griffiths–Morris–Sahasrabudhe on diagonal Ramsey numbers (2023); the polynomial Freiman–Ruzsa conjecture over (Gowers–Green–Manners–Tao, 2023), formalised in Lean within weeks; (Angeltveit–McKay, 2024).
The subject grew largely from the Hungarian school around Paul Erdős — Turán, Rényi, Sós, Szemerédi, Lovász, Ruzsa, Elekes — and is now pursued worldwide, from Brazil (IMPA, where Morris works) and India to Israel, China and beyond.
Further reading
- Yufei Zhao, Graph Theory and Additive Combinatorics: Exploring Structure and Randomness (2023) — the best modern introduction: Turán, regularity, removal, Roth via Fourier, Freiman, sum–product, with exercises.
- Terence Tao and Van H. Vu, Additive Combinatorics (2006) — the standard reference for sumsets, Freiman's theorem, Fourier and higher-order methods.
- Stasys Jukna, Extremal Combinatorics, with Applications in Computer Science (2001; 2nd ed. 2011) — short chapters on Turán, Ramsey, the probabilistic and linear-algebra methods.
- Noga Alon and Joel H. Spencer, The Probabilistic Method (1992; 4th ed. 2016) — random colourings, deletion, the local lemma.
- Ronald L. Graham, Bruce L. Rothschild and Joel H. Spencer, Ramsey Theory (2nd ed. 1990).
- Larry Guth, Polynomial Methods in Combinatorics (2016) — Dvir's theorem, incidences, distinct distances.
- Ben Green and Terence Tao, "The primes contain arbitrarily long arithmetic progressions", Annals of Mathematics 167 (2008).
- Jordan S. Ellenberg and Dion Gijswijt, "On large subsets of with no three-term arithmetic progression", Annals of Mathematics 185 (2017).
A reading path: Zhao, Chapters 1–6 (extremal graph theory, regularity, Roth) → Tao–Vu for the additive theory → Alon–Spencer for probabilistic tools → Guth for the polynomial method → the Green–Tao paper and the survey literature on higher-order Fourier analysis.