AFTD Auto-Formalizing Theoretical Domains

op_1627_maximum_local_packing_realizable

theoremverifiedformalization

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.

  1. 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.

    lines 5–7

    uses Multiset.induction

      induction M using Multiset.induction with
      | empty => simp
      | cons S M ih =>
  2. 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`).

    lines 8–18

    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_zero

        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]
  3. 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.

    lines 19–25

    uses Finset.sum_add_distrib, Finset.card_filter, Nat.add_comm

        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 _ _
  4. 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.

    lines 29–32

    uses Multiset.map_congr, Multiset.map_const, Multiset.sum_replicate, Nat.mul_comm

      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]
  5. 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`).

    lines 36–47

    uses op_1627_sum_filter_card, Finset.sum_le_sum, op_1627_map_card_sum

      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
      omega
  6. 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.

    lines 52–58

    uses Multiset.sum_count_eq_card, Finset.even_sum, Multiset.count_filter

      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⟩
  7. 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`.

    lines 63–77

    uses op_1627_sum_filter_card, op_1627_filter_even, Finset.sum_le_sum, op_1627_map_card_sum

      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
      omega
  8. 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.

    lines 95–106

    uses op_1627_packing_bound, le_antisymm, csSup_le, le_csSup

      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 hmem4
  9. 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`.

    lines 112–114

    uses Sym2.lift

      ⟨fun e => Sym2.lift ⟨op_1627_edge_label, by decide⟩ e.1, by
        unfold is_feasible_packing
        decide⟩
  10. 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`.

    lines 127–132

    uses op_1627_packing_number_eq, op_1627_no_even_max, op_1627_edge_coloring

      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
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).

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

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
See it in the graphDiscuss this resultChallenge it