AFTD Auto-Formalizing Theoretical Domains

wild_partition_two_block_deficit_obstruction

theoremverified

For the same explicit15 array, every way of choosing two distinct original triple blocks and a three-element subset of their six local positions, then replacing those blocks by that subset and its complement, preserves all block sizes3 and has component deficit at least1. The starting deficit is1, and the displayed three-block repair has deficit0. This exhausts the two-block repartition neighborhood and refutes strict two-block deficit descent, not plateau search or the main wild-number conjecture.

Statement

theorem wild_partition_two_block_deficit_obstruction :
    in385_trap_deficit in385_trap_block=1 ∧
    (∀ (b d : Fin 5) (U : Finset (Fin 6)),b≠d → U.card=3 →
      (∀ j : Fin 5,(univ.filter fun v => in385_two_block_repartition b d U v=j).card=3) ∧
      1 ≤ in385_trap_deficit (in385_two_block_repartition b d U)) ∧
    in385_trap_deficit in385_trap_repair_block=0
Source
IN-385 / OP-306 campaign10,2026-10-30. Internal structural-route diagnostic for https://arxiv.org/html/2610.22142v1 Sections3.3/6. Targeted SAT experiment9745 and independent NetworkX audit9751 found and checked this explicit array; the proof uses kernel-checked finite cut/path certificates and ordinary connected-component cardinal arguments. This is not a published-paper erratum, a main conjecture refutation, a new wild-number case, or a research advance.
Verified
30 Oct 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 4

The proof, explained

The theorem proves that every repartition of two triple blocks into two new triples preserves all block sizes and has component deficit at least 1, while the base partition has deficit 1 and an explicit three-block repair has deficit 0. The central move is reducing two-block repartitions to single-element swaps: combinatorially, partitioning six elements into two triples admits only 10 partitions, which are the original partition and the 9 single transpositions. Kernel evaluation confirms that every two-block repartition is identical to a single swap composed with an optional block-label permutation. Because every single swap admits a bad relation and bad relations are invariant under block relabeling, every two-block repartition also has a bad relation and hence deficit at least 1, refuting strict deficit descent by two-block moves.

  1. The index 3 * b + ((c - 1) % 9) / 3 is strictly less than 15, defining a valid element of Fin 15.

    Since b < 5 and (c - 1) % 9 < 9 by Nat.mod_lt, integer division by 3 gives ((c - 1) % 9) / 3 ≤ 2. The total index is at most 3 * 4 + 2 = 14 < 15, which linear integer arithmetic (omega) verifies.

    lines 12–14

    uses Nat.mod_lt

        have := b.isLt
        have := Nat.mod_lt (in385_two_block_code U-1) (by omega : 0<9)
        omega⟩
  2. The index 3 * d + (c - 1) % 3 is strictly less than 15, defining a valid element of Fin 15.

    Since d < 5 and (c - 1) % 3 < 3 by Nat.mod_lt, the index is at most 3 * 4 + 2 = 14 < 15, verified by linear integer arithmetic (omega).

    lines 19–21

    uses Nat.mod_lt

        have := d.isLt
        have := Nat.mod_lt (in385_two_block_code U-1) (by omega : 0<3)
        omega⟩
  3. The slot index v % 3 + (if trap_block v = b then 0 else 3) is strictly less than 6, defining a valid element of Fin 6.

    For any v, v % 3 < 3 by Nat.mod_lt. Case analysis on whether v belongs to block b (split_ifs) adds either 0 or 3, yielding at most 2 + 3 = 5 < 6, verified in both cases by omega.

    lines 29–30

    uses Nat.mod_lt

        have := Nat.mod_lt v.val (by omega : 0<3)
        split_ifs <;> omega⟩
  4. Every two-block repartition is identical to a single element swap followed by an optional swap of block labels. automation

    The equivalence between in385_two_block_repartition and the relabeled single swap is verified by exhaustive computation in the Lean kernel (decide +kernel) over all pairs of blocks, 3-element subsets, and elements of Fin 15.

    line 42

      decide +kernel
  5. Every two-block repartition preserves block sizes: each block contains exactly 3 elements. automation

    Exhaustive kernel evaluation (decide +kernel) verifies that for all distinct b, d and each 3-element subset U, the preimage size of each block label under the repartition is exactly 3.

    line 47

      decide +kernel
  6. The goal decomposes into the base deficit, the two-block repartition claims, and the repair deficit.

    We apply the constructor for the conjunction, supplying in385_trap_base_deficit for the starting deficit of 1 and wild_partition_single_swap_deficit_obstruction.2.2 for the three-block repair deficit of 0, leaving the universal statement about two-block repartitions.

    line 55

    uses in385_trap_base_deficit, wild_partition_single_swap_deficit_obstruction.2.2

      refine ⟨in385_trap_base_deficit,?_,wild_partition_single_swap_deficit_obstruction.2.2⟩
  7. Fix distinct blocks b ≠ d and a 3-element subset U; all block sizes are 3, reducing the goal to bounding the deficit below by 1.

    We introduce the two blocks b, d and the subset U with their hypotheses, then discharge the block size statement using the kernel-verified lemma in385_two_block_card, leaving the deficit lower bound 1 ≤ deficit.

    lines 56–57

    uses in385_two_block_card

      intro b d U hbd hU
      refine ⟨in385_two_block_card b d U hbd hU,?_⟩
  8. Obtain a bad relation witness i from the single-swap obstruction, reducing the deficit bound to showing that the repartition admits this bad relation.

    By wild_partition_single_swap_obstruction.2.2.2.2.2, the single swap between the left and right positions admits a bad relation with respect to some symbol i. By in385_trap_deficit_pos_of_bad, establishing this bad relation for the repartition suffices to prove its deficit is at least 1.

    lines 58–60

    uses wild_partition_single_swap_obstruction.2.2.2.2.2, in385_trap_deficit_pos_of_bad

      obtain ⟨i,hi⟩ := wild_partition_single_swap_obstruction.2.2.2.2.2
        (in385_two_block_left b U) (in385_two_block_right b d U)
      apply in385_trap_deficit_pos_of_bad (in385_two_block_repartition b d U) i
  9. The two-block repartition is rewritten as the single swap composed with the block label swap.

    Using functional extensionality (funext) on in385_two_block_representation, we establish that the repartition function is identically equal to the relabeled single swap, and rewrite the goal using this equality.

    lines 61–65

    uses funext, in385_two_block_representation

      have hp : in385_two_block_repartition b d U =
          fun v => in385_two_block_label_swap b d U
            (in385_trap_swap_block (in385_two_block_left b U) (in385_two_block_right b d U) v) :=
        funext (in385_two_block_representation b d U hbd hU)
      rw [hp]
  10. The bad relation holds for the repartition, completing the proof.

    By wild_joint_bad_relation_block_relabel, permuting block labels preserves the bad relation property. Since the underlying single swap satisfies the bad relation for symbol i (hypothesis hi), the relabeled swap does as well, closing the goal.

    lines 66–69

    uses wild_joint_bad_relation_block_relabel

      exact (wild_joint_bad_relation_block_relabel 5
        (in385_trap_swap_block (in385_two_block_left b U) (in385_two_block_right b d U))
        (fun x y => x≠y ∧ in385_trap_array x y=i)
        (in385_two_block_label_swap b d U)).mpr hi
Nat.mod_lt
For any natural number x and positive modulus y, the remainder x % y is strictly less than y.
in385_trap_base_deficit
The starting trap partition has deficit equal to 1.
wild_partition_single_swap_deficit_obstruction.2.2
The displayed three-block repair partition has deficit equal to 0.
in385_two_block_card
Every two-block repartition preserves block sizes: each of the 5 blocks contains exactly 3 elements.
wild_partition_single_swap_obstruction.2.2.2.2.2
For every single swap of two elements between blocks, there exists an element i witnessing a bad relation.
in385_trap_deficit_pos_of_bad
If a partition has a bad relation with respect to some symbol i, then its deficit is at least 1.
funext
Two functions that produce equal values on all inputs are equal (functional extensionality).
in385_two_block_representation
Every two-block repartition is point-wise equal to a single swap of two elements followed by an optional swap of the two block labels.
wild_joint_bad_relation_block_relabel
Permuting the block labels of a partition preserves whether the partition admits a bad relation.

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 Finsetopen scoped BigOperatorsset_option maxHeartbeats 10000000set_option maxRecDepth 20000set_option linter.unusedSimpArgs falsedef in385_two_block_code (U : Finset (Fin 6)) : ℕ :=  ([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 4, 1, 0, 0, 0, 0, 8, 0, 5, 2, 0, 0, 12, 15, 0, 18, 0, 0, 0, 0, 0, 0, 9, 0, 6, 3, 0, 0, 11, 14, 0, 17, 0, 0, 0, 0, 10, 13, 0, 16, 0, 0, 0, 19, 0, 0, 0, 0, 0, 0, 0] : List ℕ).getD (∑ j∈U,2^j.val) 0def in385_two_block_left (b : Fin 5) (U : Finset (Fin 6)) : Fin 15 :=  ⟨3*b.val+(in385_two_block_code U-1)%9/3,by    have := b.isLt    have := Nat.mod_lt (in385_two_block_code U-1) (by omega : 0<9)    omega⟩def in385_two_block_right (b d : Fin 5) (U : Finset (Fin 6)) : Fin 15 :=  if in385_two_block_code U=0 ∨ in385_two_block_code U=19 then in385_two_block_left b U  else ⟨3*d.val+(in385_two_block_code U-1)%3,by    have := d.isLt    have := Nat.mod_lt (in385_two_block_code U-1) (by omega : 0<3)    omega⟩def in385_two_block_label_swap (b d : Fin 5) (U : Finset (Fin 6)) :    Equiv.Perm (Fin 5) :=  if 10 ≤ in385_two_block_code U then Equiv.swap b d else Equiv.refl _def in385_two_block_slot (b : Fin 5) (v : Fin 15) : Fin 6 :=  ⟨v.val%3+(if in385_trap_block v=b then 0 else 3),by    have := Nat.mod_lt v.val (by omega : 0<3)    split_ifs <;> omega⟩def in385_two_block_repartition (b d : Fin 5) (U : Finset (Fin 6)) (v : Fin 15) : Fin 5 :=  if in385_trap_block v=b ∨ in385_trap_block v=d then    if in385_two_block_slot b v∈U then b else d  else in385_trap_block vtheorem in385_two_block_representation : ∀ (b d : Fin 5) (U : Finset (Fin 6)),    b≠d → U.card=3 → ∀ v : Fin 15,      in385_two_block_repartition b d U v =        in385_two_block_label_swap b d U          (in385_trap_swap_block (in385_two_block_left b U) (in385_two_block_right b d U) v) := by  decide +kerneltheorem in385_two_block_card : ∀ (b d : Fin 5) (U : Finset (Fin 6)),    b≠d → U.card=3 → ∀ j : Fin 5,      (univ.filter fun v => in385_two_block_repartition b d U v=j).card=3 := by  decide +kerneltheorem wild_partition_two_block_deficit_obstruction :    in385_trap_deficit in385_trap_block=1 ∧    (∀ (b d : Fin 5) (U : Finset (Fin 6)),b≠d → U.card=3 →      (∀ j : Fin 5,(univ.filter fun v => in385_two_block_repartition b d U v=j).card=3) ∧      1 ≤ in385_trap_deficit (in385_two_block_repartition b d U)) ∧    in385_trap_deficit in385_trap_repair_block=0 := by  refine ⟨in385_trap_base_deficit,?_,wild_partition_single_swap_deficit_obstruction.2.2⟩  intro b d U hbd hU  refine ⟨in385_two_block_card b d U hbd hU,?_⟩  obtain ⟨i,hi⟩ := wild_partition_single_swap_obstruction.2.2.2.2.2    (in385_two_block_left b U) (in385_two_block_right b d U)  apply in385_trap_deficit_pos_of_bad (in385_two_block_repartition b d U) i  have hp : in385_two_block_repartition b d U =      fun v => in385_two_block_label_swap b d U        (in385_trap_swap_block (in385_two_block_left b U) (in385_two_block_right b d U) v) :=    funext (in385_two_block_representation b d U hbd hU)  rw [hp]  exact (wild_joint_bad_relation_block_relabel 5    (in385_trap_swap_block (in385_two_block_left b U) (in385_two_block_right b d U))    (fun x y => x≠y ∧ in385_trap_array x y=i)    (in385_two_block_label_swap b d U)).mpr hi
See it in the graphDiscuss this resultChallenge it