op_1627_maximum_local_packing_realizable
There exist natural numbers r, s, t, n, D satisfying 1 ≤ t ∧ t ≤ s ∧ s ≤ r ∧ 2 ≤ n such that D is even, D = multiset_packing_number r s t (n - 1), for every multiset M of subsets of Fin r, if M is a feasible packing for parameters (r, s, t, n - 1) and M.card = D, then not every block S has even multiplicity M.count S in M, and there exists an edge-coloring ϕ : (⊤ : SimpleGraph (Fin (D + 1))).edgeSet → Finset (Fin r) assigning an s-element subset of Fin r to each edge of the complete graph on Fin (D + 1) such that for every vertex v : Fin (D + 1), the multiset of incident edge labels incident_edge_multiset ϕ v is a feasible packing for parameters (r, s, t, n - 1).
Statement
theorem op_1627_maximum_local_packing_realizable :
∃ (r s t n D : ℕ),
1 ≤ t ∧ t ≤ s ∧ s ≤ r ∧ 2 ≤ n ∧ Even D ∧
D = multiset_packing_number r s t (n - 1) ∧
(∀ M : Multiset (Finset (Fin r)),
is_feasible_packing r s t (n - 1) M ∧ M.card = D →
¬ (∀ S, Even (M.count S))) ∧
∃ ϕ : (⊤ : SimpleGraph (Fin (D + 1))).edgeSet → Finset (Fin r),
(∀ e, (ϕ e).card = s) ∧
∀ v : Fin (D + 1), is_feasible_packing r s t (n - 1) (incident_edge_multiset ϕ v)- Formalizes
- arXiv:2611.15376 Sec. 7, after Question 7.2
- Verified
- 14 Nov 2026
- Axioms
Classical.choiceQuot.soundpropext- Built on 3
- is_feasible_packingA multiset M of s-subsets of Fin r is a feasible packing for parameters (r, s, t, h) if every member of M has cardinality s and every…
- multiset_packing_numberFor natural numbers r, s, t, h, the multiset packing number multiset_packing_number r s t h is the supremum of the cardinalities of all…
- incident_edge_multisetGiven an edge-coloring ϕ of the complete graph on a finite type V assigning a finite subset of Fin r to each edge, incident_edge_multiset…
Read back from the Lean
There exist natural numbers $r$, $s$, $t$, $n$, and $D$ such that:
1. $1 \le t \le s \le r$;
2. $2 \le n$;
3. $D$ is even;
4. $D$ is equal to multiset_packing_number r s t (n - 1) (the maximum size of a multiset of $s$-subsets of a ground set of size $r$ such that every $t$-subset is contained in at most $n - 1$ elements of the multiset);
5. For every multiset $M$ of subsets of $\text{Fin } r$, if $M$ is a feasible $(r, s, t, n - 1)$-packing and has size $D$, then it is not the case that every subset $S \subseteq \text{Fin } r$ occurs an even number of times in $M$ (i.e., every maximum packing has at least one subset with odd multiplicity); and
6. There exists a function $\phi$ assigning to each edge of the complete graph on $D + 1$ vertices ($\text{Fin}(D + 1)$) a subset of $\text{Fin } r$ such that:
a. for every edge $e$, $|\phi(e)| = s$, and
b. for every vertex $v \in \text{Fin}(D + 1)$, the multiset of labels $\phi(\{u, v\})$ over all $u \ne v$ forms a feasible $(r, s, t, n - 1)$-packing.
Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.
The proof, explained
The theorem resolves Open Problem OP-1627 by providing explicit parameters (r, s, t, n, D) = (3, 2, 1, 4, 4). The maximum packing number ν(3, 2, 1, 3) is shown to be 4 by double counting: the sum of degrees of the 3 elements equals 2|M|, while each element has degree at most 3, forcing 2|M| ≤ 9 and thus |M| ≤ 4, attained by {{0, 1}, {0, 1}, {0, 2}, {1, 2}}. If a packing of size 4 had all block multiplicities even, each element would have even degree at most 3, hence at most 2, giving total degree at most 6, which contradicts 2 * 4 = 8. Finally, an explicit edge coloring of K₅ by 2-element subsets of Fin 3 is exhibited where every vertex receives a maximum feasible packing as its incident multiset.
The double-counting identity holds for the empty multiset: the sum of degrees of all elements is 0, which equals the sum of sizes of all blocks. automation
We set up induction on the multiset M using `Multiset.induction`. In the base case where M is empty, both sides evaluate to 0, which `simp` closes.
uses
Multiset.inductioninduction M using Multiset.induction with | empty => simp | cons S M ih =>
When prepending a block S to M, the degree of each element x increases by 1 if x ∈ S and by 0 otherwise.
Rewriting the sum of sizes on S :: M via `Multiset.map_cons` and `Multiset.sum_cons` isolates the size of S plus the sum over M. For the degree of an element x, a case split on x ∈ S shows that the filtered multiset gains S when x ∈ S (by `Multiset.filter_cons_of_pos` and `Multiset.card_cons`), increasing the count by 1 (using `if_pos`), and remains unchanged when x ∉ S (by `Multiset.filter_cons_of_neg` and `if_neg`).
uses
Multiset.map_cons,Multiset.sum_cons,Multiset.filter_cons_of_pos,Multiset.card_cons,if_pos,Nat.add_comm,Multiset.filter_cons_of_neg,if_neg,Nat.add_zerorw [Multiset.map_cons, Multiset.sum_cons] have hterm : ∀ x : Fin 3, (Multiset.filter (fun T => x ∈ T) (S ::ₘ M)).card = (Multiset.filter (fun T => x ∈ T) M).card + (if x ∈ S then 1 else 0) := by intro x by_cases hx : x ∈ S · rw [Multiset.filter_cons_of_pos (p := fun T => x ∈ T) (a := S) M hx, Multiset.card_cons, if_pos hx, Nat.add_comm] · rw [Multiset.filter_cons_of_neg (p := fun T => x ∈ T) (a := S) M hx, if_neg hx, Nat.add_zero] simp only [hterm]
For every multiset M of subsets of Fin 3, the sum of degrees of all elements equals the sum of block sizes in M.
Distributing the sum over addition using `Finset.sum_add_distrib` and applying the inductive hypothesis leaves the sum of indicators (if x ∈ S then 1 else 0) over all x : Fin 3. By `Finset.card_filter`, this sum equals the cardinality |S|. Adding this to the sum over M and using commutativity of addition (`Nat.add_comm`) completes the inductive step.
uses
Finset.sum_add_distrib,Finset.card_filter,Nat.add_commrw [Finset.sum_add_distrib, ← ih] have hif : (∑ x : Fin 3, (if x ∈ S then 1 else 0)) = S.card := by rw [← Finset.card_filter (s := Finset.univ) (p := fun x => x ∈ S)] congr 1 ext x; simp rw [hif] exact Nat.add_comm _ _
If every block in M has size 2, then the sum of block sizes is 2 * M.card.
Since every block S ∈ M satisfies |S| = 2, mapping `Finset.card` over M is identical to mapping the constant function 2 by `Multiset.map_congr`. This produces a multiset of M.card copies of 2 via `Multiset.map_const`. By `Multiset.sum_replicate` and commutativity of multiplication (`Nat.mul_comm`), its sum is 2 * M.card.
uses
Multiset.map_congr,Multiset.map_const,Multiset.sum_replicate,Nat.mul_commhave h1 : M.map Finset.card = M.map (Function.const (Finset (Fin 3)) 2) := Multiset.map_congr rfl (fun S hS => hcard S hS) rw [h1, Multiset.map_const, Multiset.sum_replicate] simp [Nat.mul_comm]
Every feasible packing M for parameters (3, 2, 1, 3) has cardinality at most 4.
By definition of feasibility, each element x : Fin 3 is contained in at most 3 blocks (since singleton {x} has cardinality 1). Summing these degree bounds over all 3 elements using `Finset.sum_le_sum` gives a total degree of at most 3 * 3 = 9. Combining this with `op_1627_sum_filter_card` and `op_1627_map_card_sum` yields 2 * M.card ≤ 9. Since M.card is an integer, this forces M.card ≤ 4 (`omega`).
uses
op_1627_sum_filter_card,Finset.sum_le_sum,op_1627_map_card_sumobtain ⟨hcard, hdeg⟩ := h have key := op_1627_sum_filter_card M have hb : ∀ x : Fin 3, (M.filter (fun T => x ∈ T)).card ≤ 3 := by intro x have := hdeg {x} (by simp) simpa using this have hle : (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ 9 := by calc (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ ∑ _x : Fin 3, 3 := Finset.sum_le_sum (fun x _ => hb x) _ = 9 := by norm_num rw [key, op_1627_map_card_sum M hcard] at hle omega
If every block in M has even multiplicity, then every element x : Fin 3 has an even degree in M.
By `Multiset.sum_count_eq_card`, the degree of x (the cardinality of blocks containing x) equals the sum over all subsets S of their counts in the filtered multiset. By `Multiset.count_filter`, each count is M.count S if x ∈ S (which is even by hypothesis) and 0 if x ∉ S (which is even). By `Finset.even_sum`, the sum of even numbers is even.
uses
Multiset.sum_count_eq_card,Finset.even_sum,Multiset.count_filterrw [← Multiset.sum_count_eq_card (s := Finset.univ) (m := M.filter (fun T => x ∈ T)) (by simp)] apply Finset.even_sum intro S _ rw [Multiset.count_filter] split_ifs with hx · exact h S · exact ⟨0, rfl⟩
No feasible packing M for (3, 2, 1, 3) of cardinality 4 can have all block multiplicities even.
Assume for contradiction that all block multiplicities are even. By `op_1627_filter_even`, each element's degree is even, and feasibility restricts each degree to be at most 3. The only even integers at most 3 are 0 and 2, so every degree is at most 2. Summing over all 3 elements using `Finset.sum_le_sum` gives a total degree of at most 3 * 2 = 6. On the other hand, by `op_1627_sum_filter_card` and `op_1627_map_card_sum`, the total degree is 2 * M.card = 2 * 4 = 8. This implies 8 ≤ 6, a contradiction closed by `omega`.
uses
op_1627_sum_filter_card,op_1627_filter_even,Finset.sum_le_sum,op_1627_map_card_sumintro hall obtain ⟨hcard, hdeg⟩ := h have key := op_1627_sum_filter_card M have hb : ∀ x : Fin 3, (M.filter (fun T => x ∈ T)).card ≤ 2 := by intro x have hle3 : (M.filter (fun T => x ∈ T)).card ≤ 3 := by have := hdeg {x} (by simp); simpa using this obtain ⟨k, hk⟩ := op_1627_filter_even M hall x omega have hle : (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ 6 := by calc (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ ∑ _x : Fin 3, 2 := Finset.sum_le_sum (fun x _ => hb x) _ = 6 := by norm_num rw [key, op_1627_map_card_sum M hcard, hcard4] at hle omega
The multiset packing number for parameters (3, 2, 1, 3) equals 4.
The packing number is defined as the supremum of achievable packing sizes S. The witness multiset op_1627_witness = {{0, 1}, {0, 1}, {0, 2}, {1, 2}} has size 4 and is verified feasible by `decide`, so 4 ∈ S and S is nonempty. By `op_1627_packing_bound`, every element of S is at most 4, so 4 is an upper bound for S. By `le_antisymm`, using `csSup_le` and `le_csSup`, sSup S = 4.
uses
op_1627_packing_bound,le_antisymm,csSup_le,le_csSuplet S : Set ℕ := {n | ∃ M : Multiset (Finset (Fin 3)), is_feasible_packing 3 2 1 3 M ∧ M.card = n} have hmem4 : (4:ℕ) ∈ S := ⟨op_1627_witness, by unfold is_feasible_packing; decide, by decide⟩ have hbdd : BddAbove S := ⟨4, by rintro b ⟨M, hM, rfl⟩; exact op_1627_packing_bound M hM⟩ have hne : S.Nonempty := ⟨4, hmem4⟩ show sSup S = 4 apply le_antisymm · apply csSup_le hne rintro b ⟨M, hM, rfl⟩ exact op_1627_packing_bound M hM · exact le_csSup hbdd hmem4
There exists an edge coloring of K₅ by 2-element subsets of Fin 3 such that every vertex incident multiset is a feasible packing for (3, 2, 1, 3). automation
We provide the explicit symmetric edge labeling `op_1627_edge_label` lifted to edges of the complete graph K₅ via `Sym2.lift`. The condition that every edge receives a set of size 2 and every vertex incident multiset is feasible for parameters (3, 2, 1, 3) is verified by finite exhaustive check using `decide`.
uses
Sym2.lift⟨fun e => Sym2.lift ⟨op_1627_edge_label, by decide⟩ e.1, by unfold is_feasible_packing decide⟩
The existential statement holds with parameters r = 3, s = 2, t = 1, n = 4, D = 4.
We instantiate the witnesses with (r, s, t, n, D) = (3, 2, 1, 4, 4). The parameter bounds 1 ≤ 1 ≤ 2 ≤ 3, 2 ≤ 4, and Even 4 are verified by `norm_num`. The packing number identity 4 = multiset_packing_number 3 2 1 3 is supplied by `op_1627_packing_number_eq`. The non-existence of even maximum packings is supplied by `op_1627_no_even_max`. The required edge coloring on K₅ is supplied by `op_1627_edge_coloring`.
uses
op_1627_packing_number_eq,op_1627_no_even_max,op_1627_edge_coloringrefine ⟨3, 2, 1, 4, 4, by norm_num, by norm_num, by norm_num, by norm_num, ⟨2, rfl⟩, ?_, ?_, ?_⟩ · simpa using op_1627_packing_number_eq.symm · rintro M ⟨hM, hcard⟩ exact op_1627_no_even_max M hM hcard · simpa using op_1627_edge_coloring
Multiset.induction- To prove a property for all multisets, it suffices to prove it for the empty multiset and show that prepending any element preserves the property.
Multiset.map_cons- Mapping a function over a multiset with an element prepended yields the function value on that element prepended to the mapped tail.
Multiset.sum_cons- The sum of elements in a multiset with an element prepended is that element plus the sum of the tail.
Multiset.filter_cons_of_pos- Filtering a multiset by a predicate that holds for the prepended element retains that element at the head of the filtered multiset.
Multiset.card_cons- The cardinality of a multiset with an element prepended is one plus the cardinality of the tail.
if_pos- If a condition is true, the if-then-else expression evaluates to the then-branch.
Nat.add_comm- Addition of natural numbers is commutative: n + m = m + n.
Multiset.filter_cons_of_neg- Filtering a multiset by a predicate that fails for the prepended element removes that element from the filtered multiset.
if_neg- If a condition is false, the if-then-else expression evaluates to the else-branch.
Nat.add_zero- Adding zero to a natural number on the right leaves it unchanged: n + 0 = n.
Finset.sum_add_distrib- The sum of a pointwise sum of functions over a finite set equals the sum of their individual sums.
Finset.card_filter- The cardinality of the subset of elements satisfying a predicate equals the sum over the set of 1 if the predicate holds and 0 otherwise.
Multiset.map_congr- If two functions agree on every element of a multiset, mapping them over the multiset produces the same result.
Multiset.map_const- Mapping a constant function with value b over a multiset yields b replicated as many times as the multiset's cardinality.
Multiset.sum_replicate- The sum of a multiset consisting of n copies of an element a is n • a.
Nat.mul_comm- Multiplication of natural numbers is commutative: n * m = m * n.
op_1627_sum_filter_card- For any multiset M of subsets of Fin 3, the sum over all x : Fin 3 of the number of blocks in M containing x equals the sum of the sizes of all blocks in M.
Finset.sum_le_sum- If f(x) ≤ g(x) for all x in a finite set, then the sum of f over the set is at most the sum of g over the set.
op_1627_map_card_sum- If every block in a multiset M of subsets of Fin 3 has size 2, then the sum of the block sizes is 2 * M.card.
Multiset.sum_count_eq_card- The cardinality of a multiset whose elements all belong to a finite set s equals the sum of the multiplicities of the elements of s in the multiset.
Finset.even_sum- A finite sum of even integers is even.
Multiset.count_filter- The multiplicity of an element in a filtered multiset is its multiplicity in the original multiset if it satisfies the predicate, and 0 otherwise.
op_1627_filter_even- If every block in a multiset M has even multiplicity, then for each ground element x, the number of blocks containing x is even.
op_1627_packing_bound- Every feasible packing M for parameters (3, 2, 1, 3) has cardinality at most 4.
le_antisymm- In a partial order, if a ≤ b and b ≤ a, then a = b.
csSup_le- For a nonempty subset bounded above in a conditionally complete lattice, if every element is at most a, then the supremum is at most a.
le_csSup- In a conditionally complete lattice, any element of a set bounded above is at most the supremum of the set.
Sym2.lift- A symmetric binary function lifts to a well-defined function on unordered pairs (the symmetric square).
op_1627_packing_number_eq- The multiset packing number for parameters (3, 2, 1, 3) equals 4.
op_1627_no_even_max- No feasible packing for parameters (3, 2, 1, 3) of cardinality 4 can have all block multiplicities even.
op_1627_edge_coloring- There exists an edge coloring of the complete graph on 5 vertices by 2-element subsets of Fin 3 such that every vertex has an incident feasible packing for parameters (3, 2, 1, 3).
- The validity of the edge coloring on K₅ in lemma op_1627_edge_coloring, as well as the feasibility of the witness packing of size 4 in op_1627_packing_number_eq, are verified by exhaustive finite computation via Lean's `decide` tactic.
Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.
Lean source view module on GitHub
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
open Finsetprivate lemma op_1627_sum_filter_card (M : Multiset (Finset (Fin 3))) : (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) = (M.map Finset.card).sum := by induction M using Multiset.induction with | empty => simp | cons S M ih => rw [Multiset.map_cons, Multiset.sum_cons] have hterm : ∀ x : Fin 3, (Multiset.filter (fun T => x ∈ T) (S ::ₘ M)).card = (Multiset.filter (fun T => x ∈ T) M).card + (if x ∈ S then 1 else 0) := by intro x by_cases hx : x ∈ S · rw [Multiset.filter_cons_of_pos (p := fun T => x ∈ T) (a := S) M hx, Multiset.card_cons, if_pos hx, Nat.add_comm] · rw [Multiset.filter_cons_of_neg (p := fun T => x ∈ T) (a := S) M hx, if_neg hx, Nat.add_zero] simp only [hterm] rw [Finset.sum_add_distrib, ← ih] have hif : (∑ x : Fin 3, (if x ∈ S then 1 else 0)) = S.card := by rw [← Finset.card_filter (s := Finset.univ) (p := fun x => x ∈ S)] congr 1 ext x; simp rw [hif] exact Nat.add_comm _ _private lemma op_1627_map_card_sum (M : Multiset (Finset (Fin 3))) (hcard : ∀ S ∈ M, S.card = 2) : (M.map Finset.card).sum = 2 * M.card := by have h1 : M.map Finset.card = M.map (Function.const (Finset (Fin 3)) 2) := Multiset.map_congr rfl (fun S hS => hcard S hS) rw [h1, Multiset.map_const, Multiset.sum_replicate] simp [Nat.mul_comm]private lemma op_1627_packing_bound (M : Multiset (Finset (Fin 3))) (h : is_feasible_packing 3 2 1 3 M) : M.card ≤ 4 := by obtain ⟨hcard, hdeg⟩ := h have key := op_1627_sum_filter_card M have hb : ∀ x : Fin 3, (M.filter (fun T => x ∈ T)).card ≤ 3 := by intro x have := hdeg {x} (by simp) simpa using this have hle : (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ 9 := by calc (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ ∑ _x : Fin 3, 3 := Finset.sum_le_sum (fun x _ => hb x) _ = 9 := by norm_num rw [key, op_1627_map_card_sum M hcard] at hle omegaprivate lemma op_1627_filter_even (M : Multiset (Finset (Fin 3))) (h : ∀ S, Even (M.count S)) (x : Fin 3) : Even ((M.filter (fun T => x ∈ T)).card) := by rw [← Multiset.sum_count_eq_card (s := Finset.univ) (m := M.filter (fun T => x ∈ T)) (by simp)] apply Finset.even_sum intro S _ rw [Multiset.count_filter] split_ifs with hx · exact h S · exact ⟨0, rfl⟩private lemma op_1627_no_even_max (M : Multiset (Finset (Fin 3))) (h : is_feasible_packing 3 2 1 3 M) (hcard4 : M.card = 4) : ¬ (∀ S, Even (M.count S)) := by intro hall obtain ⟨hcard, hdeg⟩ := h have key := op_1627_sum_filter_card M have hb : ∀ x : Fin 3, (M.filter (fun T => x ∈ T)).card ≤ 2 := by intro x have hle3 : (M.filter (fun T => x ∈ T)).card ≤ 3 := by have := hdeg {x} (by simp); simpa using this obtain ⟨k, hk⟩ := op_1627_filter_even M hall x omega have hle : (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ 6 := by calc (∑ x : Fin 3, (M.filter (fun T => x ∈ T)).card) ≤ ∑ _x : Fin 3, 2 := Finset.sum_le_sum (fun x _ => hb x) _ = 6 := by norm_num rw [key, op_1627_map_card_sum M hcard, hcard4] at hle omegaprivate abbrev op_1627_witness : Multiset (Finset (Fin 3)) := {({0, 1} : Finset (Fin 3)), ({0, 1} : Finset (Fin 3)), ({0, 2} : Finset (Fin 3)), ({1, 2} : Finset (Fin 3))}private def op_1627_edge_label (u v : Fin 5) : Finset (Fin 3) := if (u = 0 ∧ v = 1) ∨ (u = 1 ∧ v = 0) then {1, 2} else if (u = 0 ∧ v = 2) ∨ (u = 2 ∧ v = 0) then {0, 2} else if (u = 0 ∧ v = 3) ∨ (u = 3 ∧ v = 0) then {0, 1} else if (u = 0 ∧ v = 4) ∨ (u = 4 ∧ v = 0) then {0, 1} else if (u = 1 ∧ v = 2) ∨ (u = 2 ∧ v = 1) then {0, 1} else if (u = 1 ∧ v = 3) ∨ (u = 3 ∧ v = 1) then {0, 2} else if (u = 1 ∧ v = 4) ∨ (u = 4 ∧ v = 1) then {0, 2} else if (u = 2 ∧ v = 3) ∨ (u = 3 ∧ v = 2) then {1, 2} else if (u = 2 ∧ v = 4) ∨ (u = 4 ∧ v = 2) then {0, 2} else {1, 2}private lemma op_1627_packing_number_eq : multiset_packing_number 3 2 1 3 = 4 := by let S : Set ℕ := {n | ∃ M : Multiset (Finset (Fin 3)), is_feasible_packing 3 2 1 3 M ∧ M.card = n} have hmem4 : (4:ℕ) ∈ S := ⟨op_1627_witness, by unfold is_feasible_packing; decide, by decide⟩ have hbdd : BddAbove S := ⟨4, by rintro b ⟨M, hM, rfl⟩; exact op_1627_packing_bound M hM⟩ have hne : S.Nonempty := ⟨4, hmem4⟩ show sSup S = 4 apply le_antisymm · apply csSup_le hne rintro b ⟨M, hM, rfl⟩ exact op_1627_packing_bound M hM · exact le_csSup hbdd hmem4private lemma op_1627_edge_coloring : ∃ ϕ : (⊤ : SimpleGraph (Fin (4 + 1))).edgeSet → Finset (Fin 3), (∀ e, (ϕ e).card = 2) ∧ ∀ v : Fin (4 + 1), is_feasible_packing 3 2 1 3 (incident_edge_multiset ϕ v) := ⟨fun e => Sym2.lift ⟨op_1627_edge_label, by decide⟩ e.1, by unfold is_feasible_packing decide⟩/-- Open Problem OP-1627: There exist parameters (r, s, t, n) where D = ν(r, s, t; n-1) is even, no maximum multiset has all even multiplicities, and K_{D+1} admits an (r, s)-set-coloring realizing maximum local packings at every vertex. -/theorem op_1627_maximum_local_packing_realizable : ∃ (r s t n D : ℕ), 1 ≤ t ∧ t ≤ s ∧ s ≤ r ∧ 2 ≤ n ∧ Even D ∧ D = multiset_packing_number r s t (n - 1) ∧ (∀ M : Multiset (Finset (Fin r)), is_feasible_packing r s t (n - 1) M ∧ M.card = D → ¬ (∀ S, Even (M.count S))) ∧ ∃ ϕ : (⊤ : SimpleGraph (Fin (D + 1))).edgeSet → Finset (Fin r), (∀ e, (ϕ e).card = s) ∧ ∀ v : Fin (D + 1), is_feasible_packing r s t (n - 1) (incident_edge_multiset ϕ v) := by refine ⟨3, 2, 1, 4, 4, by norm_num, by norm_num, by norm_num, by norm_num, ⟨2, rfl⟩, ?_, ?_, ?_⟩ · simpa using op_1627_packing_number_eq.symm · rintro M ⟨hM, hcard⟩ exact op_1627_no_even_max M hM hcard · simpa using op_1627_edge_coloring