The proof
More than 19 blocks are required
The argument assumes a covering of the 4-point subsets of 24 points by 19 blocks of 14, and squeezes it until it breaks. Each step opens with the idea, in plain words and with things to try. The full argument and the Lean code are one click away.
Download as PDFNot yet reviewed by a mathematicianAI agents wrote this argument. Lean checks the formal proof, not this prose.
Before the proof
A covering picks blocks, sets of points, so that every small set of points sits inside at least one block. Here is one you can finish yourself.
Why not let a computer check?
There are 1,961,256 ways to choose 14 of 24 points, so about 10102 ways to choose 19 blocks. No search can try them all. The best arrangement a computer search found still misses 264 of the 10,626 four-point sets (try it). Only a proof can say that 19 blocks never work.
The map
Eight steps, ten numbered results. Click one to jump to it. As you read, the step you’re on lights up.
The statement and notation
A covering is a family of -element subsets (blocks) of a -element set such that every -element subset lies in at least one block. The covering number is the least number of blocks in a covering.
Theorem. and .
The previous lower bounds were 19 and 32. The best known coverings have 23 and 42 blocks, so neither number is determined.
In Lean, a family is a list of blocks, so the same block may appear more than once. Every
statement below holds in that generality: nothing in the argument assumes the blocks are
distinct. Challenge.lean states the theorem with Mathlib’s Finset, and
IndependentCheck.lean derives that form from the list form.
Notation
Fix a family of blocks on a point set .
- The degree of a point is the number of blocks containing .
- The codegree of two points is the number of blocks containing both.
- If is a covering and , the blocks through , with removed, form a covering of with blocks. This is the derived covering at . Deriving twice, the blocks through two points form a covering with blocks.
- Two points are twins if they lie in exactly the same blocks.
- and are the identity and all-ones matrices, and is the all-ones vector.
Counting incidences of the derived covering gives the Schönheim bound [Sch64].
Step 1 of 8
Counting floors
Covering pairs of 22 points with blocks of 12 takes at least 6 blocks. Restricting a covering to the blocks through one point, or two, turns that into the old bound of 19, and into two facts used everywhere below.
The idea
Everything starts with counting. Take any covering and keep only the blocks through one point x, with x removed. Any three other points, together with x, make a 4-point set, and the block covering it contains x. So these blocks still cover every 3-point set of the other 23 points: a smaller covering, called the derived covering.
Doing it at two points x and y leaves the blocks through both, which cover every pair of the other 22 points with blocks of 12. Lemma 1 says that takes at least 6 blocks, so any two points share at least 6 blocks. Lemma 1 is itself a counting puzzle:
Counting incidences turns 6 into 11, and 11 into 19: that is Schönheim’s bound. A covering of triples of 23 points needs at least 11 blocks, so every point lies in at least 11. It is also where the old lower bound of 19 came from.
The full argument
Lemma 1. .
Proof. Suppose five 12-subsets of a 22-set cover every pair. They have 60 incidences, so some point has degree at most 2. A single block through meets only 11 of the 21 other points, so lies in exactly two blocks and , and . Then , and and have 10 points each.
The 100 pairs with , lie in neither nor , so the other three blocks cover them. A block with points of and points of covers such pairs, and gives . A block containing all of (or all of ) covers at most , so if one did, the three blocks would cover at most . So no block contains a whole side. Then each point of must lie in at least two of the three blocks: a single block through it would have to contain all of . The same holds for , so the three blocks need at least 40 incidences, but they have only 36.
Deriving and counting incidences now gives and . These are the previous lower bounds.
Corollary 2. In any covering, every point has degree at least 11 and every pair has codegree at least 6.
Proof. The derived covering at a point is a covering, and at a pair it is a covering.
From here until Step 8, is a covering of a 24-set by exactly 19 blocks. The goal is a contradiction.
In Lean
Checked by Lean4 Lean declarations
pair_cover_22_12_ge_sixcampaigns/async_goal/lean/recovered/PairLowerBoundRecoveredV4.lean:131Lemma 1: C(22,12,2) ≥ 6.
theorem pair_cover_22_12_ge_six (F : Family 22) (hrows : ∀ R, R ∈ F → ValidBlock 12 R) (hcover : IsCovering 2 F) : 6≤F.lengthtriple_cover_23_13_ge_elevenFormalResume20261003/PairFloorV1.lean:32theorem triple_cover_23_13_ge_eleven (F : Family 23) (hrows : ∀ R, R ∈ F → ValidBlock 13 R) (hcover : IsCovering 3 F) : 11≤F.lengthpoint_floor_elevenA19PhysicalFloors.lean:11Corollary 2: every point lies in at least 11 blocks.
theorem point_floor_eleven (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (p : Fin 24) : 11 ≤ degree T ppair_floor_sixFormalResume20261003/PairFloorV1.lean:51Corollary 2: every pair lies in at least 6 blocks.
theorem pair_floor_six (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (p q : Fin 24) (hpq : p≠q) : 6≤pairDegree T p q
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 2 of 8
Degrees and excess
With only 19 blocks there is almost no slack: all but one or two points lie in exactly 11 blocks, and each of those has exactly 5 units of excess to share out.
The idea
Now suppose 19 blocks were enough, and squeeze. Nineteen blocks of 14 points have 266 places. Every point needs at least 11, which uses 264, so only 2 are left: either one point is in 13 blocks, or two points are in 12. The other 22 or 23 points are in exactly 11. Call those the low points.
Pairs are just as tight. Every pair needs 6 shared blocks; call anything above that the pair’s excess. A low point is in 11 blocks with 13 other points each: 143 slots shared with the other 23 points. They need 6 each, 138 in all, so a low point has exactly 5 units of excess to hand out. The rest of the proof follows where that excess goes.
The full argument
The 19 blocks have incidences, and every degree is at least 11. So the degrees are either
- (a) one point of degree 13 and all others 11, or
- (b) two points of degree 12 and all others 11.
Call the degree-11 points low and the others high. Let be the set of low points, so or .
For distinct points, let the excess be . Each block through contains 13 other points, so , and
The excess graph has vertex set , with an edge of weight between low points whenever . Write for the weighted degree of in ; it is at most 5.
In Lean
Checked by Lean3 Lean declarations
degree_patternsA19PhysicalCounts.lean:30The two possible degree patterns.
lemma degree_patterns (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (hlen : T.length = 19) : (∃ p, degree T p = 13 ∧ ∀ q, q ≠ p → degree T q = 11) ∨ (∃ p q, p ≠ q ∧ degree T p = 12 ∧ degree T q = 12 ∧ ∀ r, r ≠ p → r ≠ q → degree T r = 11)fullExcess_row_sumA19PhysicalCounts.lean:72The excess of a point adds up to 13 d(x) − 138.
lemma fullExcess_row_sum (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (p : Fin 24) : ∑ q, fullExcess T p q = 13 * (degree T p : ℝ) - 138lowExcess_row_le_fiveA19PhysicalCounts.lean:98lemma lowExcess_row_le_five (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (p : LowPoint T) : ∑ q, lowExcess T p q ≤ 5
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 3 of 8
A rank bound forces balanced components
Only 19 blocks for 22 or 23 low points means the incidence matrix has a kernel. Its vectors live on balanced components: groups of low points whose excess stays among themselves, split into two equal sides.
The idea
This is the key idea. Write the incidence matrix of the low points: a row per low point, a column per block. That is 22 or 23 rows but only 19 columns, so the rows can’t be independent. There are at least 3 (or 4) independent ways to give each low point a number so that, in every block, the numbers add up to zero.
An energy identity says what those numbers can look like. Join two low points when their pair has excess, and give each low point its budget of 5. The numbers must be zero on a point that sends some excess to a high point, and must flip sign across every edge. That only works on balanced components: groups of low points whose excess stays among themselves, split into two equal sides.
So there are at least 3 balanced components, and Lemma 3 draws four more facts from them. Every block contains equally many points from the two sides of each one. A point in one shares exactly 6 blocks with every point outside it. Together they hold at most 16 points. And a component of 2 points is a pair of twins: two points that lie in exactly the same blocks.
The full argument
Call a connected component of balanced if it is bipartite, with sides of equal size, and every vertex of has .
Lemma 3. In a 19-block covering:
- there are at least balanced components, so at least 3, and at least 4 in case (a);
- every block contains equally many points from the two sides of each balanced component;
- a point of a balanced component has for every point outside it, including the high points, and for every on the same side;
- the balanced components cover at most 16 points;
- each balanced component has even size, and a balanced component of size 2 is a pair of twins.
Proof. Let be the incidence matrix of low points against blocks and its Gram matrix. Its diagonal entries are 11 and its off-diagonal entries are , so
where is the weighted adjacency matrix of . For any real vector on ,
Both sums are nonnegative, so is positive semidefinite, and is in its kernel exactly when wherever and along every edge. So kernel vectors live on bipartite components whose vertices all have , with opposite signs on the two sides. In such a component the total edge weight is , so the sides have equal size: these are exactly the balanced components. The kernel of is spanned by their alternating vectors ( on one side, on the other).
An alternating vector sums to zero, so and it is also in the kernel of . Conversely, , so forces into the kernel of . Hence the nullity of is the number of balanced components. Since has rank at most 19, there are at least of them. This is part 1.
For an alternating vector , , so every block meets the two sides equally. This is part 2.
A vertex of a balanced component has , which is its entire excess, so it has no excess to high points or to low points outside its component. It has none to its own side either, because the component is bipartite. This is part 3.
For part 4, let be the union of the balanced components. By part 3 no high point has excess to , and each low point has total excess 5. In case (a), the degree-13 point has excess 31, all of it to low points outside , at most 5 each; so at least 7 low points lie outside , and . In case (b), the two degree-12 points have excess 18 each and , so together they send at least excess to low points outside . Each low point absorbs at most 5, so at least 5 low points lie outside , and . Since is even (part 5), .
For part 5, the sides have equal size, so the size is even. In a size-2 component the edge has weight 5, so , and and lie in the same blocks.
In Lean
Checked by Lean7 Lean declarations
low_gram_identityA19WeightedFrontend.lean:26G = 5I + 6J + W.
lemma low_gram_identity (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) : (lowSystem T hrows hcover).gram 6 = lowIncidence T * (lowIncidence T).transposeenergy_identityWeightedSignlessKernel.lean:30lemma energy_identity (W : Matrix V V ℝ) (hW : ∀ i j, W i j = W j i) (d : ℝ) (x : V → ℝ) : (∑ i, x i * (signless W d *ᵥ x) i) = (∑ i, (d - rowSum W i) * x i ^ 2) + (∑ i, ∑ j, W i j * (x i + x j) ^ 2) / 2nullity_eq_balanced_bipartite_componentsWeightedKernelClassification.lean:87lemma nullity_eq_balanced_bipartite_components (hd : S.d ≠ 0) : Module.finrank ℝ S.kernel = Nat.card {c // S.BalancedBipartite c}component_count_from_physicalA19WeightedFrontend.lean:42At least |L| − 19 balanced components.
lemma component_count_from_physical (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (hlen : T.length = 19) : Fintype.card (LowPoint T) - 19 ≤ Nat.card {c // (lowSystem T hrows hcover).BalancedBipartite c}component_slot_balanceA19PhysicalBalance.lean:12Every block meets the two sides equally.
lemma component_slot_balance (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (c : (lowSystem T hrows hcover).graph.ConnectedComponent) (hc : (lowSystem T hrows hcover).BalancedBipartite c) : ∃ s t : Finset (LowPoint T), s.Nonempty ∧ t.Nonempty ∧ _root_.Disjoint s t ∧ s.card = t.card ∧ (∀ p, (lowSystem T hrows hcover).graph.connectedComponentMk p = c ↔ p ∈ s ∨ p ∈ t) ∧ (∀ j : Fin T.length, (s.filter fun p => p.val ∈ T.get j).card = (t.filter fun p => p.val ∈ T.get j).card)component_closed_in_all_pointsA19WeightedFrontend.lean:79lemma component_closed_in_all_points (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (c : (lowSystem T hrows hcover).graph.ConnectedComponent) (hc : (lowSystem T hrows hcover).RegularComponent c) (p : LowPoint T) (hp : (lowSystem T hrows hcover).graph.connectedComponentMk p = c) (q : Fin 24) (hw : fullExcess T p.val q ≠ 0) : ∃ hq : degree T q = 11, (lowSystem T hrows hcover).graph.connectedComponentMk ⟨q, hq⟩ = cgood_vertices_le_sixteenA19ComponentUnion.lean:127lemma good_vertices_le_sixteen (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (hlen : T.length = 19) : (lowSystem T hrows hcover).goodVertices.card ≤ 16
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 4 of 8
The rigidity lemma
Both remaining cases lead to 11 blocks of size 12 covering every triple of 22 points, with every point in 6 blocks. A trace inequality shows it must be a symmetric 2-(11,6,3) design with every point doubled.
The idea
Both remaining cases run into the same object: 11 blocks of 12 points that cover every triple of 22 points, with every point in exactly 6 blocks. Lemma 4 says it must be a symmetric 2-(11,6,3) design with every point doubled. Every point gets a twin; twins share 6 blocks, and any other two points share exactly 3.
The proof hangs on one inequality. Put K = MMT − 3J, where M is the 22 × 11 incidence matrix. With only 11 blocks, K has at most 11 non-zero eigenvalues. None is negative, and they add up to 66. Eleven such numbers have squares adding up to at least 66²/11 = 396, and to exactly 396 only when all of them are 6.
Counting the entries of K gives the other side: the sum of squares is at most 396 − 8f, where f counts pairs that share only 2 blocks. So f = 0, every eigenvalue is 6, and the codegrees are forced. The same shape appears inside 20 points (Corollary 5): six 10-point blocks covering every pair, completed by five 12-point blocks. Adding two new points to the six blocks makes them a doubled design, so the 20 points fall into 10 twin classes.
The full argument
Both remaining cases lead to an 11-block covering of 22 points. This lemma shows such a covering, if regular, has a unique shape: a doubled symmetric design, in which every point has a twin.
Lemma 4 (rigidity). Let be 11 blocks of size 12 on a 22-set that cover every triple, with every point of degree 6. Then there is a fixed-point-free involution of such that
- and are twins, so ;
- whenever .
Collapsing each twin pair to a point gives a symmetric - design. Consequently, two distinct blocks of share exactly 6 points, the incidence matrix of has rank 11, and every real vector on that sums to zero on each block satisfies .
Proof. Every codegree is at least 2: the blocks through and , with removed, are 10-sets covering the other 20 points. If , those two 10-sets partition the other 20 points, so the two blocks through and have union and intersection .
Codegree-2 pairs form a matching. Suppose with . The two blocks through and the two through share a block (they cannot share both, since two blocks with union meet in only two points). Let and be the others. Then , and with (10 points) and (9 points) we have and . The other three blocks through avoid and , and they must cover all 90 triples with , . Each has 11 points besides , so it covers at most of the pairs . All three must attain 30, splitting 5/6 between and . Then no block contains a whole side, so every point of needs two of these blocks: 38 incidences, but only 33 are available.
Codegrees are 3 or 4 off the matching. Let be a codegree-2 pair. Besides the two common blocks, and each lie in 4 more blocks, all different, which uses 8 of the other 9 blocks; call the remaining one . Any other point is in exactly one of the two common blocks and in 5 of the other 9, so
Since is not matched to or , both terms are at least 3, so each is 3 or 4.
No codegree-2 pairs at all. Let be the incidence matrix, and let have off-diagonal entries and zero diagonal, so . Each row of sums to . A matched point has row entries (its partner) and otherwise 0 or 1, so its row has four entries 1 and squared sum 5. An unmatched point has nonnegative entries summing to 3, so its squared sum is at most 9.
Let . Since , the matrix has the eigenvector with eigenvalue 6 and agrees with on . So is positive semidefinite with rank at most 11 and trace 66. By Cauchy–Schwarz on its eigenvalues, . But , so the squared row sums of total at least 198. With matching edges they total at most . So , and every row of has squared sum exactly 9: one entry 3 and the rest 0. The entry 3 marks a partner with , a twin, and all other codegrees are 3.
Consequences. Collapsing twin pairs gives 11 blocks of 6 classes on 11 classes, with every two classes in 3 common blocks: a symmetric - design. Its incidence matrix satisfies , which is invertible, so it has rank 11, and in a symmetric design two blocks share classes, which is 6 points. If sums to zero on each block, then is a vector on classes that sums to zero on each block of the quotient, so by invertibility.
Corollary 5 (20-point completions). Let be a 20-set, six 10-subsets of covering every pair, and five 12-subsets in which every point has degree 3, such that covers every triple. Then:
- every point has degree 3 in ;
- there is a fixed-point-free involution of whose pairs are twins in both and ;
- two blocks of share exactly 4 points;
- for , and ;
- is determined by alone: is the only other point that lies in all three -blocks through .
Proof. Two 10-sets through reach at most 18 other points, so pair coverage needs 3, and 60 incidences make every degree exactly 3. Add two new points to every block of . The result, together with , is 11 blocks of size 12 on 22 points with every degree 6, and it covers every triple: triples inside by assumption, and triples through a new point because covers pairs. Lemma 4 applies. The two new points are twins of each other, so restricts to , and parts 2–4 follow from Lemma 4 (blocks share 6 points, 2 of them new). If for a non-twin , then , and and would need disjoint triples of the five -blocks, which is impossible. That gives the bound in part 4 and part 5.
Part 5 matters below: two completions and of the same give the same pairing.
In Lean
Checked by Lean7 Lean declarations
codegree_two_matchingFormalResume20261003/Regular22MatchingV1.lean:98Codegree-2 pairs form a matching.
theorem codegree_two_matching (F : Family 22) (hrows : ∀ R, R ∈ F → ValidBlock 12 R) (hcover : IsCovering 3 F) (u v w : Fin 22) (huv : u≠v) (huw : u≠w) (hu : degree F u=6) (hv : pairDegree F u v=2) (hw : pairDegree F u w=2) : v=wtrace_square_ge_396MatrixFoundation.lean:41The trace inequality.
theorem trace_square_ge_396 (K : Matrix n n ℝ) (hK : K.IsHermitian) (ht : K.trace = 66) (hr : K.rank ≤ 11) : 396 ≤ (K * K).traceregular22_physical_twinsRegular22PhysicalRigidity.lean:112Lemma 4: every point has a twin; other codegrees are 3.
theorem regular22_physical_twins (F : Family 22) (hrows : ∀ R, R ∈ F → ValidBlock 12 R) (hcover : IsCovering 3 F) (hlen : F.length=11) (hregular : ∀ p, degree F p=6) : ∃ σ : Fin 22 → Fin 22, (∀ p, σ p≠p) ∧ (∀ p, σ (σ p)=p) ∧ (∀ p q, pairDegree F p q=if p=q ∨ q=σ p then 6 else 3) ∧ (∀ p R, R ∈ F → (p ∈ R ↔ σ p ∈ R))regular22_twins_with_balanceRegular22TwinBalance.lean:55theorem regular22_twins_with_balance (F : Family 22) (hrows : ∀ R, R ∈ F → ValidBlock 12 R) (hcover : IsCovering 3 F) (hlen : F.length=11) (hregular : ∀ p, degree F p=6) : ∃ σ : Fin 22 → Fin 22, (∀ p, σ p≠p) ∧ (∀ p, σ (σ p)=p) ∧ (∀ p q, pairDegree F p q=if p=q ∨ q=σ p then 6 else 3) ∧ (∀ p R, R ∈ F → (p ∈ R ↔ σ p ∈ R)) ∧ (∀ z : Fin 22 → ℝ, (incidence F).transpose *ᵥ z=0 → ∀ p, z (σ p) = -z p)regular22_row_intersection_sixRegular22RowGram.lean:68theorem regular22_row_intersection_six (F : Family 22) (hrows : ∀ R, R ∈ F → ValidBlock 12 R) (hcover : IsCovering 3 F) (hlen : F.length=11) (hregular : ∀ p, degree F p=6) (i j : Fin F.length) (hij : i≠j) : (CrossGrid.hits (F.get i) (F.get j)).length=6CompletionRegular20Extension.lean:11The hypotheses of Corollary 5.
structure Completion (H E : Family 20) : Prop where H_length : H.length=6 E_length : E.length=5 H_rows : ∀ R, R ∈ H → ValidBlock 10 R E_rows : ∀ R, R ∈ E → ValidBlock 12 R H_degree : ∀ p, degree H p=3 E_degree : ∀ p, degree E p=3 H_cover : IsCovering 2 H all_cover : IsCovering 3 (H++E)completions_share_pairingRegular20Twins.lean:113Corollary 5, part 5.
theorem completions_share_pairing (H E F : Family 20) (hE : Completion H E) (hF : Completion H F) (σ τ : Fin 20 → Fin 20) (hσ : TwinData H E σ) (hτ : TwinData H F τ) : σ=τ
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 5 of 8
Two cases
Balanced components come in even sizes and fit in 16 points. Either two of them combine into a balanced quadruple of points, or they have sizes exactly 2, 6 and 6, or 2, 6 and 8.
The idea
Lemma 3 left at least 3 balanced components, of even sizes, inside 16 points. Two shapes give the proof a handle: a component of 4 points, or two components of 2. Either one produces a balanced quadruple: four low points u, v, s, t with every block containing as many of u, v as of s, t, where u and v share exactly 6 blocks with each other and with every other point.
If neither shape appears, only one option is left: two points of degree 12, and components of sizes 2, 6 and 6, or 2, 6 and 8. Try to find another:
The next two steps rule out each case.
The full argument
Definition. A balanced quadruple is a set of four distinct low points with
- ;
- for every block ;
- for every other point .
Lemma 6. Either has a balanced quadruple, or we are in case (b) and the balanced components have sizes exactly or .
Proof. A balanced component of size 4 has sides and ; Lemma 3 gives the three conditions with because are on the same side. Two balanced components of size 2, and , are twin pairs, and again Lemma 3 gives the conditions. Otherwise every component has size 2 or at least 6, with at most one of size 2. By Lemma 3 there are at least 3 components on at most 16 points, so the sizes are or . Case (a) would need four components, at least points.
In Lean
Checked by Lean2 Lean declarations
GadgetDataA19GadgetInterface.lean:14A balanced quadruple (the agents called it a gadget).
structure GadgetData (T : Family 24) where u : LowPoint T v : LowPoint T s : LowPoint T t : LowPoint T distinct : u ≠ v ∧ u ≠ s ∧ u ≠ t ∧ v ≠ s ∧ v ≠ t ∧ s ≠ t pivot_codegree : pairDegree T u.val v.val = 6 row_balance : ∀ R, R ∈ T → (if u.val ∈ R then (1 : ℕ) else 0) + (if v.val ∈ R then 1 else 0) = (if s.val ∈ R then 1 else 0) + (if t.val ∈ R then 1 else 0) outside_codegree : ∀ x : Fin 24, x ≠ u.val → x ≠ v.val → x ≠ s.val → x ≠ t.val → pairDegree T u.val x = 6 ∧ pairDegree T v.val x = 6gadget_or_exceptional_componentsA19ComponentDichotomy.lean:28lemma gadget_or_exceptional_components (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (hlen : T.length = 19) : HasGadget T ∨ Nonempty (ExceptionalComponents T hrows hcover)
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 6 of 8
No balanced quadruple
A balanced quadruple sorts the 19 blocks into four families, and the rigidity lemma pairs the other 20 points into ten twin classes. Those classes form the Petersen graph, which stays connected after deleting two vertices, and that forces 16 points into a group that holds only 6.
The idea
Suppose u, v, s, t is a balanced quadruple. Sort the 19 blocks by which of u and v they contain: 6 contain both (𝓗), 5 contain only u (𝓔), 5 only v (𝓕), and 3 neither (𝓖). On the other 20 points, 𝓗 with 𝓔 is exactly the 20-point shape of Corollary 5, and so is 𝓗 with 𝓕. So those 20 points pair into 10 twin classes, the same pairing both times.
Join two classes when they share two blocks of 𝓗. The matrix identities force A² + A − 2I = J: three neighbours each, no triangles, and exactly one common neighbour for every non-adjacent pair. That is the Petersen graph, and it stays connected after deleting any two vertices.
Now the three 𝓖-blocks. Two of the 20 points lie in all three; every other point lies in exactly two, so it misses exactly one, its colour. Each 𝓖-block misses only 6 points, so a colour holds at most 6. But two points in neighbouring classes share 2 blocks of 𝓗 and 1 each of 𝓔 and 𝓕, so they need at least 2 more from 𝓖, which gives them the same colour.
One matrix C that fits every equation: the six blocks of 𝓗 (rows) against the ten classes (columns).
The full argument
Proposition 7. A 19-block covering has no balanced quadruple.
Proof. Suppose is one, and let be the other 20 points. Sort the 19 blocks:
| Family | Blocks containing | Count | Gadget points | Size on |
|---|---|---|---|---|
| and | all four | 10 | ||
| , not | and one of | 12 | ||
| , not | 5 | and one of | 12 | |
| neither | 3 | none | 14 |
The gadget-point column follows from the balance condition. On , covers every pair (the 4-set needs a block through and ), and and each cover every triple (look at and ). By Corollary 5 every has , so , and likewise . So and are both completions, and by part 5 of Corollary 5 they share one pairing of into ten twin classes.
The quotient graph. Let be the incidence matrix of against twin classes. Rows have 5 ones, columns have 3, and two rows share 2 classes, so . The off-diagonal entries of are class codegrees in , which are 1 or 2 (at least 1 because covers pairs). Let be the 0/1 matrix marking codegree 2, so . Then
using . Row sums of are , so . Expanding the square then gives
So the graph with adjacency matrix is 3-regular on 10 vertices, adjacent vertices have no common neighbour, and non-adjacent vertices have exactly one. (This is the Petersen graph, though the argument never needs that.)
Removing two vertices leaves it connected. Let be a set of at most 2 vertices, and suppose the graph minus is disconnected. Fix a remaining vertex . A remaining vertex outside ‘s component is not adjacent to , so they have exactly one common neighbour, and it lies in (otherwise it would join the two components). A vertex of adjacent to has only two other neighbours, so at most remaining vertices lie outside ‘s component. So every component contains all but at most of the remaining vertices. If , two components would each have at least 7 vertices, which is too many. If , there are exactly two components of 4 vertices each, and the count is tight only if every remaining vertex is adjacent to both vertices of . Then the vertices of have degree 8, not 3.
Colours. Every has degree , so . The three -blocks have 42 incidences on 20 points, so exactly two points have and the other 18 have . Each of those 18 misses exactly one -block; call that block its colour. A -block misses exactly 6 points of , so each colour has at most 6 points.
Edges force equal colours. If classes are adjacent, then for any in and in , and by Corollary 5. Since , the two points share at least 2 -blocks. If both have , they are in the same two blocks and have the same colour.
Contradiction. Delete the at most two classes containing or . The remaining classes (at least 8) induce a connected graph, every remaining class has a neighbour, and all their points (at least 16) have . Colours agree along every edge, for both points of each class, so all of these points share one colour. But a colour has at most 6 points.
In Lean
Checked by Lean5 Lean declarations
actual_completionsGadgetPhysicalTraces.lean:172theorem actual_completions (g : GadgetData T) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) : CoveringMatrixRegular20.Completion (H g) (E g) ∧ CoveringMatrixRegular20.Completion (H g) (F g)adjacency_polynomialQuotientMatrixGraph.lean:85A² + A − 2I = J.
theorem adjacency_polynomial : D.adjacency * D.adjacency + D.adjacency - (2 : ℝ) • (1 : Matrix (Fin 10) (Fin 10) ℝ) = ones (Fin 10) (Fin 10)cubic_ten_connected_delete_le_twoSmallCutConnectivity.lean:125theorem cubic_ten_connected_delete_le_two (G : SimpleGraph (Fin 10)) [DecidableRel G.Adj] (hdegree : ∀ x, G.degree x = 3) (hadj : ∀ x y, G.Adj x y → G.commonNeighbors x y = ∅) (hnonadj : ∀ x y, x ≠ y → ¬G.Adj x y → ∃! z, z ∈ G.commonNeighbors x y) (R : Finset (Fin 10)) (hR : R.card ≤ 2) : (G.induce {x | x ∉ R}).Connectedcolor_fiber_capacityGadgetResidualColors.lean:144Each colour has at most 6 points.
theorem color_fiber_capacity (F : Family 20) (hlen : F.length=3) (hr : ∀ R, R ∈ F → ValidBlock 14 R) (L : Finset (Fin 20)) (hL : ∀ p, p∈L → degree F p=2) (c : Finset (Fin F.length)) : (L.filter (fun p => color F p=c)).card≤6gadget_impossibleGadgetExclusion.lean:21Proposition 7.
theorem gadget_impossible (T : Family 24) (hrows : ∀ R, R∈T → ValidBlock 14 R) (hcover : IsCovering 4 T) (hlen : T.length=19) (g : GadgetData T) : False
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 7 of 8
No exceptional components
The size-2 component is a twin pair whose 11 blocks are again a doubled design. That splits every twin pair across the larger components, leaving six or more points whose missing blocks would need 18 different pairs of blocks out of 15.
The idea
In the other case the size-2 component is a twin pair q, q′. Their 11 blocks, with q and q′ removed, are exactly the object of Lemma 4: every triple of the other 22 points covered, each point in 6. So those 22 points pair into twins, and every signing that adds up to zero on each block is opposite on twins. That splits every twin pair across the two sides of each larger component.
Take one side of each larger component: 6 or 7 low points, no two of them twins. Each is in 11 blocks, 6 of them through q, so it misses exactly 3 of the other 8. Counting shows any two of these missing triples share exactly one block, and a high point misses 2 blocks that none of them touch. So six or more triples, pairwise sharing one block, must fit into the remaining 6 blocks:
The full argument
Proposition 8. A 19-block covering in case (b) cannot have balanced components of sizes or .
Proof. Let be the high points and the size-2 component, a twin pair. Let be the 11 blocks through (and ), let be the other 8, and let be the other 22 points.
The providers are rigid. On , consists of 11 blocks of size 12 covering every triple (look at ). By Lemma 3, for every , so every point of has degree 6 in . Lemma 4 gives a twin involution of with off the twin pairs. In , low points of have degree and have degree .
Components split twin pairs. Let be one of the two larger components, with alternating vector . By Lemma 3, sums to zero on every block, in particular on every block of , so Lemma 4 gives . Hence maps each side of onto the other.
Selected points. Let be one side of the size-6 component together with one side of the other large component: 6 or 7 low points, no two of them twins. For distinct , by Lemma 3 and , so . For , likewise and (the twin of is a low point on the other side), so .
Counting in . For let be the 3 blocks of missing , and let be the 2 missing . Inclusion–exclusion in the 8 blocks gives
So at least six triples lie inside the 6 blocks outside , and any two share exactly one block. Each triple contains 3 pairs of blocks, and no pair is in two triples, so they need at least 18 different pairs. A 6-set has only 15.
In Lean
Checked by Lean5 Lean declarations
twin_frame_of_exceptionTwinProviderTrace.lean:155lemma twin_frame_of_exception (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (E : ExceptionalComponents T hrows hcover) : ∃ f : TwinFrame T, ∀ r : LowPoint T, (lowSystem T hrows hcover).graph.connectedComponentMk r = E.c2 ↔ r = f.q ∨ r = f.mateprovider_side_of_componentProviderSides.lean:27lemma provider_side_of_component (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (E : ExceptionalComponents T hrows hcover) (f : TwinFrame T) (hf : ∀ r : LowPoint T, (lowSystem T hrows hcover).graph.connectedComponentMk r = E.c2 ↔ r = f.q ∨ r = f.mate) (e : Fin 22 ≃ Outside f.removed) (c : (lowSystem T hrows hcover).graph.ConnectedComponent) (hc2 : c ≠ E.c2) (hc : (lowSystem T hrows hcover).BalancedBipartite c) : Nonempty (ProviderSide T hrows hcover f e c)no_six_omission_triplesFormalResume20261003/SixPointTriplesV1.lean:150theorem no_six_omission_triples (P : Block 8) (F : Family 8) (hP : ValidBlock 2 P) (hrows : ∀ R, R ∈ F → ValidBlock 3 R) (havoid : ∀ R, R ∈ F → Disjoint R P) (hpairs : F.Pairwise (fun R S => (hits R S).length=1)) (hlen : 6≤F.length) : Falseeight_slot_obstructionOmissionSlotCounting.lean:79lemma eight_slot_obstruction {n : ℕ} (R : Family n) (hlen : R.length = 8) (S : Finset (Fin n)) (hS : 6 ≤ S.card) (high : Fin n) (hh : degree R high = 6) (hdegree : ∀ p ∈ S, degree R p = 5) (hpair : ∀ p ∈ S, ∀ q ∈ S, p ≠ q → pairDegree R p q = 3) (hhigh : ∀ p ∈ S, pairDegree R p high = 3) : Falseexception_impossiblePhysicalExceptionExclusion.lean:25Proposition 8.
lemma exception_impossible (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) (hlen : T.length = 19) (E : ExceptionalComponents T hrows hcover) : False
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Step 8 of 8
Conclusion
No 19-block covering exists, fewer blocks can be padded up to 19, and so at least 20 are needed. Counting through one point of a (25,15,5) covering then gives 34.
The idea
Both cases fail, so no covering has exactly 19 blocks. A covering with fewer could be padded to 19 by repeating one of its blocks; nothing in the argument assumed the blocks were different, so that fails too. Every covering needs at least 20 blocks.
The bound climbs from there. The blocks through any point of a (25,15,5) covering form a (24,14,4) covering, so every point is in at least 20 of them, and 25 × 20 / 15 rounds up to 34. The same step keeps going:
The full argument
By Lemma 6, a 19-block covering has a balanced quadruple or exceptional components, and Propositions 7 and 8 rule out both. So no covering has exactly 19 blocks. A covering with fewer blocks can be padded to 19 by repeating a block, and nothing above assumed distinct blocks, so that is impossible too. Hence
For : the derived covering at any point of a covering is a covering, so every point has degree at least 20, and gives .
The same Schönheim step also raises the tabulated lower bounds for from 52 to 56, from 83 to 89 and from 130 to 139. These are not formalized here.
In Lean
Checked by Lean3 Lean declarations
exact_nineteen_excludedFinalCoveringBounds.lean:16theorem exact_nineteen_excluded : ExactNineteenExcludedc24_14_4_lower_twentyFinalCoveringBounds.lean:21theorem c24_14_4_lower_twenty (T : Family 24) (hrows : ∀ R, R ∈ T → ValidBlock 14 R) (hcover : IsCovering 4 T) : 20 ≤ T.lengthc25_15_5_lower_thirty_fourFinalCoveringBounds.lean:25theorem c25_15_5_lower_thirty_four (F : Family 25) (hrows : ∀ R, R ∈ F → ValidBlock 15 R) (hcover : IsCovering 5 F) : 34 ≤ F.length
Spotted a mistake? Suggest a fix to PROOF.md, which this page is built from.
Questions
What does Lean actually check?
Lean’s kernel checks every step of the formal proof, starting from the definitions of a covering, and the final theorems use only Lean’s three standard axioms. Comparator checks that the proved statement is exactly the textbook one. What Lean doesn’t check is this page: the explanations here were written by AI from the agents’ notes. More on what’s checked.
Why does the proof allow repeated blocks?
The agents modelled a covering as a list of blocks, so the same block can appear twice. That makes the theorem slightly stronger, and it makes Step 8 work: a covering with fewer than 19 blocks can be padded to exactly 19 by repeating one.
What is a symmetric 2-(11,6,3) design?
Eleven points and eleven blocks of six points each, such that every two points lie in exactly three common blocks. Any two blocks then share exactly three points. It is the complement of the Paley biplane, whose blocks are the translates of the squares 1, 3, 4, 5, 9 modulo 11. Step 4’s figure shows it with every point doubled.
Is this result new?
The covering repositories list 19 as the best lower bound for C(24,14,4), derived from C(22,12,2) = 6 by Schönheim’s bound, and a literature search found no published proof of 20. A mathematician’s review is still pending.
Does this say what C(24,14,4) is?
No. It is at least 20, and the best known covering has 23 blocks. Whether 20, 21 or 22 blocks can work is open.