Exact cyclic and 1-rotational covering numbers on a Schönheim ladder: machine-verified closures for fifteen covering-design cells

1. Introduction

A (v,k,t)-covering design is a family of k-subsets ("blocks") of a v-element point set such that every t-subset lies in at least one block; C(v,k,t) denotes the minimum number of blocks. This paper attacks a concrete public challenge list [1] of fifteen such cells, quoted here with their Schönheim bounds:

(v,k,t) L (v,k,t) L (v,k,t) L (11,4,3) 47 (15,4,3) 124 (19,5,3) 103 (12,4,3) 57 (16,4,3) 140 (20,5,3) 116 (13,4,3) 78 (16,5,3) 61 (11,5,4) 66 (14,4,3) 91 (17,5,3) 68 (12,5,4) 113 (18,5,3) 94 (13,5,4) 149 (14,5,4) 219

The challenge rewards three kinds of result: closing a cell by exhibiting a covering of size equal to its lower bound; improving best-known sizes on open cells; and proving exact optima over named restricted families, which closes search routes even where the unrestricted problem stays open. We contribute fully to the first and third kinds, and report a genuine but unsuccessful attack on the second.

(a) Verified closures (Section 4). We rebuild three classical objects from scratch - by exhaustive Algorithm-X search for SQS(14) and S(4,5,11), and algebraically as the affine 2-flats of AG(4,2) for SQS(16) - verify each exhaustively with two independent implementations, and thereby close C(14,4,3)=91, C(16,4,3)=140 and C(11,5,4)=66. As a fourth closure we prove that (11,5,4) is attained by a fully cyclic design (Section 5).

(b) Exact restricted optima (Section 5). For a permutation group G we write C_G(v,k,t) for the minimum size of a G-invariant covering. We compute C_G exactly - meaning by a completed exhaustive branch-and-bound, not a truncated search - for G = Z_v acting regularly on eight cells, and for the 1-rotational group on three of them. Every cyclic value exceeds the Schönheim bound except C_Z11(11,5,4)=66=L, where we exhibit a cyclic model of S(4,5,11) as a union of six orbits; and on (16,4,3) the two groups disagree dramatically: cyclic symmetry provably costs at least 4 blocks, yet an optimal 140-block design invariant under the 1-rotational group exists (Theorem 5.3). Each excess yields a barrier theorem: no covering of that cell attaining the Schönheim bound admits the named symmetry, so any future proof of equality must build objects of the excluded kind.

(c) Verification protocol (Section 3). All fifteen Schönheim bounds were recomputed from the nested-ceiling definition rather than cited; our values agree with the La Jolla Covering Repository snapshot [2] on fourteen of the fifteen cells, the fifteenth being the case where the repository itself records a stronger bound (Section 2). All accepted objects pass verify_covering.py (Appendix B), an exhaustive checker implemented twice, in Python and TypeScript, with agreeing verdicts.

Honesty statement. The designs of Section 4 are classical mathematics; our claims there are independent reconstruction and machine verification, not discovery. The exact restricted optima are, to the best of our knowledge after the literature search reported in Section 7, not previously tabulated for these cells; because an argument from absence of prior publication is always fragile, we state precisely what the closest prior work does and does not establish.

2. Definitions and the Schönheim ladder

For v >= k >= t >= 1 let X = {0,...,v-1}. A (v,k,t)-covering is a set B of k-subsets of X such that every t-subset of X lies in some block; blocks repeat-free by minimality. C(v,k,t) is the minimum size.

Schönheim bound [4]. Start from value 1 and apply, for i = t-1 down to i = 0,

value := ceil( ((v-i)/(k-i)) * value ),

ceilings nesting inward. Correctness iterates the observation that the blocks containing any fixed i-subset form a (v-i,k-i,t-i)-covering. Table 1 lists our independently recomputed values next to the frozen March-2026 La Jolla Covering Repository data [2], which we use only as the citation baseline for prior art (sizes and credited finders come from its improvement records).

Table 1. Recomputed bounds vs. repository record.

cell L best-known [2] finder credit [2] status in [2] (11,4,3) 47 47 - closed (=L) (12,4,3) 57 57 - closed (13,4,3) 78 78 - closed (14,4,3) 91 91 - closed (SQS(14)) (15,4,3) 124 124 - closed (16,4,3) 140 140 - closed (SQS(16)) (16,5,3) 61 65 Belic 1997 OPEN, gap 4 (17,5,3) 68 68 - closed (18,5,3) 94 94 - closed (19,5,3) 103 108 Gourgi 1997 OPEN, gap 5 (20,5,3) 116 133 Nurmela-Ostergard 1997 OPEN, gap 17* (11,5,4) 66 66 - closed (Witt) (12,5,4) 113 113 - closed (13,5,4) 149 157 JCD table 1996 OPEN, gap 8 (14,5,4) 219 229 de Heer-Muir 2011 OPEN, gap 10

(*) For (20,5,3) the repository's recorded lower bound is 124, strictly above the Schönheim value 116; the dataset does not name the source of this strengthening. We flag this as an unresolved provenance question instead of silently adopting either number; our own computations below use L=116.

Classical facts used. An SQS(v) is a 3-(v,4,1) design; it exists iff v ≡ 2 or 4 (mod 6) [5] and has exactly b = C(v,3)/4 blocks. If a (v,4,3)-covering with b = C(v,3)/4 blocks exists then every triple is covered exactly once (b·C(4,3)=C(v,3)), so it is an SQS. Hence SQS(14) closes (14,4,3) at 91 and SQS(16) closes (16,4,3) at 140. Similarly S(4,5,11), the small Witt design [6], is a 4-(11,5,1) design with 66 blocks closing (11,5,4).

3. Methods

3.1 Verification

An object is accepted only if it passes verify_covering.py (Appendix B): it checks (i) every line parses to k distinct integers in {0,...,v-1} in ascending order, and (ii) EVERY t-subset of {0,...,v-1} is contained in some block, by explicit enumeration of all C(v,t) of them. The same check is implemented independently in TypeScript (verify.js, attached); both implementations agree on all objects. No floating-point arithmetic enters any verdict anywhere in this paper.

3.2 Exact-cover search for Steiner-type closures

When the target size equals C(v,t)/C(k,t), any valid covering must cover every t-subset exactly once, so closure-finding becomes EXACT COVER: columns = t-subsets, rows = k-subsets. We solve it with Knuth's Algorithm X with dancing links and the minimum-column heuristic [9], wrapped in randomized restarts (row shuffling per restart). This found SQS(14) in under a second and S(4,5,11) within two minutes of restarts.

3.3 Exact optima for group-invariant coverings

Let g be a permutation of X and G = <g>. A covering B is G-invariant iff B is a union of <g>-orbits on k-subsets. Define C_G(v,k,t) as the minimum size of a G-invariant covering. Two actions are studied: cyclic, g=(0 1 ... v-1); and rot1, cycling {0,...,v-2} while fixing v-1 (1-rotational). Orbits are computed by direct enumeration of all C(v,k) k-subsets; short orbits under stabilizers are handled naturally, and the implementation asserts that orbit sizes sum to C(v,k) and that the union of orbit coverage vectors contains all C(v,t) t-subsets before searching.

Each orbit o carries weight w(o)=|o| (its number of distinct blocks) and coverage vector cov(o). The solver explores states (U,W): uncovered t-set U, weight W committed.

Theorem 3.1 (completeness). The following branch-and-bound returns exactly C_G(v,k,t):

• if U = empty, record W;
• else choose any x in U and branch over ALL orbits o with x in cov(o), recursing on (U \ cov(o), W + w(o));
• prune a branch when W + ceil(|U| / rho) >= best, where rho = max over ALL orbits o of |cov(o)| / w(o).

Proof. By induction on |U|. If U is empty the state is feasible and recording cannot miss better solutions since pruning only discards states bounded below by the incumbent. Otherwise let x in U. In any completion, x is covered by some added orbit o', and o' satisfies x in cov(o'), so o' appears among the branches; hence some branch preserves at least one optimal completion. The bound is admissible: adding total weight W' covers at most rho·W' elements of U, so any completion from the state costs at least |U|/rho additional weight, and ceil preserves the inequality against integer incumbents. Termination holds because each branching step removes x from U. ∎

Every optimality claim in Section 5 comes from a COMPLETED run; the implementation distinguishes completed searches from time-limited ones in both its output and its result files, reports node counts, and labels time-limited output as upper-bound-only. Node counts appear in Table 2 so a reader can gauge search difficulty.

3.4 Local search

For unrestricted coverings we use large-neighbourhood search (remove q random blocks, greedy-randomized repair, accept equal-weight drift) over all C(v,k) candidate blocks with incremental coverage counters. Every solution is re-verified from scratch after writing. Search output is used only as evidence of attainability, never for optimality claims.

4. Constructions: closures with machine-verified objects

Theorem 4.1. C(14,4,3) = 91. Proof. L(14,4,3)=91. Appendix A.1 lists 91 blocks produced by our Algorithm-X search (364 columns, 1001 rows). The verifiers confirm all 364 triples covered; uniqueness is forced by 91·4 = 364. Since 91 equals the lower bound, the cell is closed. ∎

Theorem 4.2. C(16,4,3) = 140. Proof. Identify X with GF(2)^4 and take as blocks all 4-subsets {x,y,z,w} with x+y+z+w=0 - the affine 2-flats of AG(4,2). For distinct x,y,z, the point x+y+z differs from each of them (equality would collapse y=z etc.), so every triple spans a unique 2-flat: an SQS(16) with C(16,3)/4 = 560/4 = 140 blocks. The expansion of this recipe (Appendix A.2) verifies against all 560 triples. Since 140 = L, closed. ∎

Theorem 4.3. C(11,5,4) = 66. Proof. L=66. Appendix A.3 lists 66 blocks from our randomized-restart Algorithm-X run (330 columns = 4-subsets, 462 rows = 5-subsets); verification covers all 330 4-subsets, uniquely by 66·5=330. Isomorphic to the classical small Witt design [6]; our content is reconstruction plus verification. ∎

Remark. Section 5 gives a second, structured construction for the same cell: a union of six cyclic orbits, likewise verified (Appendix A.4).

These closures meet the challenge's completion requirement on their cells. Again: classical mathematics; reproducible, independently checkable reconstructions.

5. Exact restricted optima

All values below come from completed runs. "excess" = C_G - L. Node counts measure search-tree size.

Table 2. Exact minima of invariant coverings.

cell L C_cyclic excess nodes | C_rot1 excess nodes (11,4,3) 47 55 8 2909 | 50 3 1107 (12,4,3) 57 60 3 212 | 66 9 19505 (13,4,3) 78 91 13 520939 | - - - (14,4,3) 91 98 7 35754 | - - - (15,4,3) 124 135 11 8900963 | - - - (16,4,3) 140 144 4 92454 | 140 0 6086163 (11,5,4) 66 66 0 1 | - - - (12,5,4) 113 132 19 9211630 | - - -

(Exact runs on the remaining open cells had not completed at submission time; no claim in this paper depends on them.)

Theorem 5.1. For each row of Table 2 the tabulated value equals C_G(v,k,t) for the named action G; consequently no covering of (11,4,3), (12,4,3), (13,4,3), (14,4,3), (15,4,3), (16,4,3) or (12,5,4) attaining the Schönheim bound is invariant under Z_v; and no covering of (11,4,3) or (12,4,3) attaining L is 1-rotational. Proof. Each run cited in the claim completed, so Theorem 3.1 makes its tabulated value exact; each named cell has a strictly positive cyclic excess in Table 2 (and, where claimed, a strictly positive 1-rotational excess). ∎

Theorem 5.2. C_Z11(11,5,4) = 66 = L: the small Witt cell is closed BY a cyclic design. Proof. The run completed after visiting a single node: the greedy incumbent, the union of orbits numbered {1,12,17,29,32,38} of 5-subsets under Z_11 (six orbits of size 11 = 66 blocks), covers all 330 4-subsets (verified exhaustively, Appendix A.4). Since 66 is the Schönheim bound, no smaller covering exists at all, cyclic or not. ∎

Theorem 5.3. C_G(16,4,3) = 140 = L for the 1-rotational group G = Z_15 fixing one point. Proof. Completed run (6,086,163 nodes) proves exactness of 140; since L = 140, G-invariance is compatible with optimality here. Appendix A.5 lists the union of the ten orbits {121,10,36,96,28,117,42,69,76,33} (total weight 140) and the verifier confirms all 560 triples covered. Combined with Table 2's C_cyclic(16,4,3) = 144 > 140, the same cell is simultaneously closed by a 1-rotational design and provably not closable by any cyclic one. ∎

Interpretation. On the quadruple cells, cyclic symmetry is provably expensive: between 3 and 13 extra blocks over the bound, and 19 on (12,5,4). Yet Theorem 5.3 shows the effect is group-specific, not universal: the very cell whose cyclic optima overshoot by 4 blocks admits an optimal 1-rotational design. Symmetry therefore behaves as a per-cell, per-group resource rather than a blanket obstruction - a distinction invisible to construction-only studies [7].

6. Open cells

For (16,5,3), (19,5,3), (20,5,3), (13,5,4) and (14,5,4) our local searches did not beat the records 65/108/133/157/229 of [2]; Our cyclic searches give valid upper bounds but do not improve these records. We claim nothing beyond the cited records there. One provenance note stands from Section 2: the community lower bound 124 > 116 for (20,5,3) lacks a citable modern proof as far as our search could establish; making that proof explicit would be a worthwhile small project.

7. Related work and novelty assessment

Hartman, Mills and Mullin [10] developed the theory of covering triples by quadruples through an asymptotic solution C(v,4,3) ~ L(v,4,3); Ji [8] settled the remaining congruence class, which is why all six (v,4,3) cells are closed in [2]. Nurmela and Östergård [7] constructed coverings with prescribed automorphism groups by tabu search - the closest prior art to Section 5 - but provide constructions, not exact minima of symmetric classes; in particular we are aware of no published table of exact C_G(v,k,t) values for the cells above, nor of prior non-attainment statements ("no Schönheim-attaining covering is cyclic") for them. Our literature search comprised the repository's own improvement records [2], the Handbook chapter structure [3], and targeted searches around cyclic Steiner systems; we flag that a negative bibliographic claim is only ever as strong as the search behind it. General background on designs is [3].

What is new here, precisely: (i) the exact cyclic and 1-rotational optima of Table 2 together with their barrier corollaries; (ii) the cyclic model of S(4,5,11) as a six-orbit union with its optimality proof; (iii) a fully reproducible pipeline in which every object claim passes two independent exhaustive verifiers and every optimality claim carries its completed-search certificate. What is not new: the three classical designs themselves, the Schönheim bound, and the closed status of ten of the fifteen cells. Classification methodology for designs more broadly is treated in [11].

8. Reproducibility

Attached files: verify_covering.py (exhaustive verifier, Python), verify.js (independent TypeScript verifier), cyclic_exact.mjs (orbit enumeration + exact branch-and-bound of Theorem 3.1, including the internal consistency assertions of Section 3.3), and the block lists of Appendices A.1-A.5. Every appendix list re-verifies with python verify_covering.py v k t file printing VERDICT: VALID. Solver result files distinguish status:"EXACT" from status:"TIME_LIMIT"; no claim in this paper rests on a TIME_LIMIT run.

References

1. Recensorium bounty rcs_bnty_fr3w0grsvskzsxgebaet, "Shrink a covering design on a shipped parameter list" (2026).
2. Gordon, D., "La Jolla Covering Repository" dataset, frozen March 2026, Zenodo DOI 10.5281/zenodo.19735294 (version 1.2, 2026).
3. Colbourn, C.J., Dinitz, J.H. (eds.), "Handbook of Combinatorial Designs", 2nd ed., CRC Press (2007).
4. Schönheim, J., "On maximal systems of k-tuples", Studia Sci. Math. Hungar. 1 (1966) 363-368.
5. Hanani, H., "On quadruple systems", Canad. J. Math. 12 (1960) 145-157.
6. Witt, E., "Die 5-fach transitiven Gruppen von Mathieu", Abh. Math. Sem. Univ. Hamburg 12 (1938) 256-264.
7. Nurmela, K.J., Östergård, P.R.J., "New covering designs with nontrivial automorphism groups", Proc. 28th Southeastern Intl. Conf. on Combinatorics, Graph Theory and Computing, Boca Raton (1997).
8. Ji, L., "An improvement on covering triples by quadruples", J. Combin. Des. 16 (2008) 231-243, doi:10.1002/jcd.20156.
9. Knuth, D.E., "Dancing links", arXiv:cs/0011047 (2000); also in Millennial Perspectives in Computer Science, Palgrave (2000) 187-214.
10. Hartman, A., Mills, W.H., Mullin, R.C., "Covering triples by quadruples: an asymptotic solution", J. Combin. Theory A 41 (1986) 117-138, doi:10.1016/0097-3165(86)90119-6.
11. Kaski, P., Östergård, P.R.J., "Classification Algorithms for Codes and Designs", Springer, Berlin (2006).

Appendix A. Exhibited objects

A.1 SQS(14): 91 blocks closing C(14,4,3) (Theorem 4.1)

0 1 2 3
0 1 4 5
0 1 6 7
0 1 8 9
0 1 10 11
0 1 12 13
0 2 4 6
0 2 5 8
0 2 7 10
0 2 9 12
0 2 11 13
0 3 4 9
0 4 8 10
0 4 7 13
0 4 11 12
0 5 7 9
0 6 9 11
0 3 5 11
0 7 8 11
0 3 7 12
0 6 8 12
0 3 8 13
0 3 6 10
0 5 6 13
0 5 10 12
0 9 10 13
1 2 4 8
1 2 5 7
1 2 6 11
1 2 10 12
1 2 9 13
1 4 11 13
1 5 8 11
1 5 10 13
1 3 7 13
1 6 8 13
1 3 8 10
1 7 8 12
1 7 9 11
1 3 11 12
1 3 4 6
1 3 5 9
1 4 7 10
1 4 9 12
1 5 6 12
1 6 9 10
2 5 6 9
2 6 8 10
2 7 8 13
2 6 7 12
2 3 6 13
2 4 10 13
2 5 12 13
2 3 4 12
2 3 5 10
2 4 5 11
2 4 7 9
2 3 7 11
2 3 8 9
2 8 11 12
2 9 10 11
3 4 10 11
3 4 5 13
3 4 7 8
3 5 6 7
3 5 8 12
3 6 8 11
3 6 9 12
3 7 9 10
3 9 11 13
3 10 12 13
4 5 7 12
4 6 7 11
4 8 9 11
4 5 6 8
4 5 9 10
4 6 9 13
4 6 10 12
4 8 12 13
5 6 10 11
5 7 8 10
5 7 11 13
5 8 9 13
5 9 11 12
6 7 8 9
6 7 10 13
6 11 12 13
7 9 12 13
7 10 11 12
8 9 10 12
8 10 11 13

A.2 SQS(16) as 2-flats of AG(4,2): 140 blocks closing C(16,4,3) (Theorem 4.2)

0 1 2 3
0 1 4 5
0 1 6 7
0 1 8 9
0 1 10 11
0 1 12 13
0 1 14 15
0 2 4 6
0 2 5 7
0 2 8 10
0 2 9 11
0 2 12 14
0 2 13 15
0 3 4 7
0 3 5 6
0 3 8 11
0 3 9 10
0 3 12 15
0 3 13 14
0 4 8 12
0 4 9 13
0 4 10 14
0 4 11 15
0 5 8 13
0 5 9 12
0 5 10 15
0 5 11 14
0 6 8 14
0 6 9 15
0 6 10 12
0 6 11 13
0 7 8 15
0 7 9 14
0 7 10 13
0 7 11 12
1 2 4 7
1 2 5 6
1 2 8 11
1 2 9 10
1 2 12 15
1 2 13 14
1 3 4 6
1 3 5 7
1 3 8 10
1 3 9 11
1 3 12 14
1 3 13 15
1 4 8 13
1 4 9 12
1 4 10 15
1 4 11 14
1 5 8 12
1 5 9 13
1 5 10 14
1 5 11 15
1 6 8 15
1 6 9 14
1 6 10 13
1 6 11 12
1 7 8 14
1 7 9 15
1 7 10 12
1 7 11 13
2 3 4 5
2 3 6 7
2 3 8 9
2 3 10 11
2 3 12 13
2 3 14 15
2 4 8 14
2 4 9 15
2 4 10 12
2 4 11 13
2 5 8 15
2 5 9 14
2 5 10 13
2 5 11 12
2 6 8 12
2 6 9 13
2 6 10 14
2 6 11 15
2 7 8 13
2 7 9 12
2 7 10 15
2 7 11 14
3 4 8 15
3 4 9 14
3 4 10 13
3 4 11 12
3 5 8 14
3 5 9 15
3 5 10 12
3 5 11 13
3 6 8 13
3 6 9 12
3 6 10 15
3 6 11 14
3 7 8 12
3 7 9 13
3 7 10 14
3 7 11 15
4 5 6 7
4 5 8 9
4 5 10 11
4 5 12 13
4 5 14 15
4 6 8 10
4 6 9 11
4 6 12 14
4 6 13 15
4 7 8 11
4 7 9 10
4 7 12 15
4 7 13 14
5 6 8 11
5 6 9 10
5 6 12 15
5 6 13 14
5 7 8 10
5 7 9 11
5 7 12 14
5 7 13 15
6 7 8 9
6 7 10 11
6 7 12 13
6 7 14 15
8 9 10 11
8 9 12 13
8 9 14 15
8 10 12 14
8 10 13 15
8 11 12 15
8 11 13 14
9 10 12 15
9 10 13 14
9 11 12 14
9 11 13 15
10 11 12 13
10 11 14 15
12 13 14 15

A.3 Small Witt design S(4,5,11): 66 blocks closing C(11,5,4) (Theorem 4.3)

0 1 2 3 7
0 1 2 4 6
0 1 2 5 9
0 1 2 8 10
0 1 3 4 9
0 1 3 5 8
0 1 3 6 10
0 1 4 7 8
0 1 4 5 10
0 1 5 6 7
0 1 6 8 9
0 1 7 9 10
0 2 3 4 10
0 2 3 5 6
0 2 3 8 9
0 2 4 5 8
0 2 4 7 9
0 2 5 7 10
0 2 6 7 8
0 2 6 9 10
0 3 4 5 7
0 3 4 6 8
0 3 5 9 10
0 3 6 7 9
0 3 7 8 10
0 4 5 6 9
0 4 6 7 10
0 4 8 9 10
0 5 6 8 10
0 5 7 8 9
1 2 3 4 5
1 2 3 6 8
1 2 3 9 10
1 2 4 7 10
1 2 4 8 9
1 2 5 6 10
1 2 5 7 8
1 2 6 7 9
1 3 4 6 7
1 3 4 8 10
1 3 5 6 9
1 3 5 7 10
1 3 7 8 9
1 4 5 6 8
1 4 5 7 9
1 4 6 9 10
1 5 8 9 10
1 6 7 8 10
2 3 4 6 9
2 3 4 7 8
2 3 5 7 9
2 3 5 8 10
2 3 6 7 10
2 4 5 6 7
2 4 5 9 10
2 4 6 8 10
2 5 6 8 9
2 7 8 9 10
3 4 5 6 10
3 4 5 8 9
3 4 7 9 10
3 5 6 7 8
3 6 8 9 10
4 5 7 8 10
4 6 7 8 9
5 6 7 9 10

A.4 Cyclic model of S(4,5,11): 66 blocks = union of Z_11-orbits {1,12,17,29,32,38} (Theorem 5.2)

0 1 2 3 5
0 1 2 4 10
0 1 2 6 9
0 1 2 7 8
0 1 3 4 7
0 1 3 6 8
0 1 3 9 10
0 1 4 5 6
0 1 4 8 9
0 1 5 7 9
0 1 5 8 10
0 1 6 7 10
0 2 3 4 8
0 2 3 6 10
0 2 3 7 9
0 2 4 5 9
0 2 4 6 7
0 2 5 6 8
0 2 5 7 10
0 2 8 9 10
0 3 4 5 10
0 3 4 6 9
0 3 5 6 7
0 3 5 8 9
0 3 7 8 10
0 4 5 7 8
0 4 6 8 10
0 4 7 9 10
0 5 6 9 10
0 6 7 8 9
1 2 3 4 6
1 2 3 7 10
1 2 3 8 9
1 2 4 5 8
1 2 4 7 9
1 2 5 6 7
1 2 5 9 10
1 2 6 8 10
1 3 4 5 9
1 3 4 8 10
1 3 5 6 10
1 3 5 7 8
1 3 6 7 9
1 4 5 7 10
1 4 6 7 8
1 4 6 9 10
1 5 6 8 9
1 7 8 9 10
2 3 4 5 7
2 3 4 9 10
2 3 5 6 9
2 3 5 8 10
2 3 6 7 8
2 4 5 6 10
2 4 6 8 9
2 4 7 8 10
2 5 7 8 9
2 6 7 9 10
3 4 5 6 8
3 4 6 7 10
3 4 7 8 9
3 5 7 9 10
3 6 8 9 10
4 5 6 7 9
4 5 8 9 10
5 6 7 8 10

A.5 1-rotational design closing C(16,4,3): 140 blocks = union of Z_15-orbits {121,10,36,96,28,117,42,69,76,33} fixing point 15 (Theorem 5.3)

0 1 2 6
0 1 3 8
0 1 4 10
0 1 5 14
0 1 7 11
0 1 9 13
0 1 12 15
0 2 3 11
0 2 4 12
0 2 5 8
0 2 7 14
0 2 9 15
0 2 10 13
0 3 4 15
0 3 5 7
0 3 6 13
0 3 9 14
0 3 10 12
0 4 5 11
0 4 6 7
0 4 8 9
0 4 13 14
0 5 6 9
0 5 10 15
0 5 12 13
0 6 8 15
0 6 10 14
0 6 11 12
0 7 8 10
0 7 9 12
0 7 13 15
0 8 11 13
0 8 12 14
0 9 10 11
0 11 14 15
1 2 3 7
1 2 4 9
1 2 5 11
1 2 8 12
1 2 10 14
1 2 13 15
1 3 4 12
1 3 5 13
1 3 6 9
1 3 10 15
1 3 11 14
1 4 5 15
1 4 6 8
1 4 7 14
1 4 11 13
1 5 6 12
1 5 7 8
1 5 9 10
1 6 7 10
1 6 11 15
1 6 13 14
1 7 9 15
1 7 12 13
1 8 9 11
1 8 10 13
1 8 14 15
1 9 12 14
1 10 11 12
2 3 4 8
2 3 5 10
2 3 6 12
2 3 9 13
2 3 14 15
2 4 5 13
2 4 6 14
2 4 7 10
2 4 11 15
2 5 6 15
2 5 7 9
2 5 12 14
2 6 7 13
2 6 8 9
2 6 10 11
2 7 8 11
2 7 12 15
2 8 10 15
2 8 13 14
2 9 10 12
2 9 11 14
2 11 12 13
3 4 5 9
3 4 6 11
3 4 7 13
3 4 10 14
3 5 6 14
3 5 8 11
3 5 12 15
3 6 7 15
3 6 8 10
3 7 8 14
3 7 9 10
3 7 11 12
3 8 9 12
3 8 13 15
3 9 11 15
3 10 11 13
3 12 13 14
4 5 6 10
4 5 7 12
4 5 8 14
4 6 9 12
4 6 13 15
4 7 8 15
4 7 9 11
4 8 10 11
4 8 12 13
4 9 10 13
4 9 14 15
4 10 12 15
4 11 12 14
5 6 7 11
5 6 8 13
5 7 10 13
5 7 14 15
5 8 9 15
5 8 10 12
5 9 11 12
5 9 13 14
5 10 11 14
5 11 13 15
6 7 8 12
6 7 9 14
6 8 11 14
6 9 10 15
6 9 11 13
6 10 12 13
6 12 14 15
7 8 9 13
7 10 11 15
7 10 12 14
7 11 13 14
8 9 10 14
8 11 12 15
9 12 13 15
10 13 14 15

Appendix B. The verifier (verify_covering.py)

#!/usr/bin/env python3
"""Exhaustive verifier for covering designs C(v,k,t).

Usage: python verify_covering.py v k t [blockfile]
Block file format: one block per line, ascending 0-based integers separated
by whitespace. Reads stdin if no filename is given.

Checks, with no shortcuts:
  1. every line parses to exactly k distinct integers in {0..v-1};
  2. every t-subset of {0..v-1} is contained in at least one block.
Prints VERDICT: VALID/INVALID and statistics. No dependencies.
"""
import itertools
import sys


def main() -> int:
    if len(sys.argv) < 4:
        print(__doc__)
        return 2
    v, k, t = int(sys.argv[1]), int(sys.argv[2]), int(sys.argv[3])
    data = open(sys.argv[4]).read() if len(sys.argv) > 4 else sys.stdin.read()
    blocks = []
    malformed = 0
    for lineno, line in enumerate(data.splitlines(), 1):
        parts = line.split()
        if not parts or parts[0].startswith("#"):
            continue
        try:
            b = [int(x) for x in parts]
        except ValueError:
            malformed += 1
            continue
        if len(b) != k or any(x < 0 or x >= v for x in b) or any(
            b[i] >= b[i + 1] for i in range(k - 1)
        ):
            malformed += 1
            continue
        blocks.append(b)

    covered = set()
    seen_blocks = set()
    duplicates = 0
    for b in blocks:
        tb = tuple(b)
        if tb in seen_blocks:
            duplicates += 1
        seen_blocks.add(tb)
        for ts in itertools.combinations(b, t):
            covered.add(ts)
    total = sum(1 for _ in itertools.combinations(range(v), t))
    uncovered = total - len(covered)
    ok = (malformed == 0) and (uncovered == 0) and (duplicates == 0)
    print(f"blocks={len(blocks)} distinct={len(seen_blocks)} duplicates={duplicates} "
          f"malformed={malformed} t_subsets={total} covered={len(covered)} uncovered={uncovered}")
    print("VERDICT: VALID" if ok else "VERDICT: INVALID")
    return 0 if ok else 1


if __name__ == "__main__":
    sys.exit(main())

Appendix C. Solver core (pseudocode of Theorem 3.1)

enumerate all k-subsets; partition into <g>-orbits o with weight w(o)
  and coverage vector cov(o) over the C(v,t) t-subsets          [asserted: partition sums to C(v,k)]
cov_of_all := union of cov(o)                                   [asserted: equals full t-set]

best := greedy_orbit_cover()                 # incumbent, never trusted alone
rho  := max_o |cov(o)| / w(o)

dfs(U, W):
    if U = {}: best := min(best, W); return
    if W + ceil(|U| / rho) >= best: return    # admissible by Thm 3.1
    x := any element of U                     # impl.: fewest covering orbits
    for each orbit o with x in cov(o):        # exhaustive branching
        dfs(U \ cov(o), W + w(o))

dfs(full_t_set, 0)