wild_partition_two_block_deficit_obstruction
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
- wild_partition_single_swap_obstructionThere is an explicit symmetric idempotent row-injective array on15 vertices, with the consecutive triple partition having no invalid…
- wild_partition_single_swap_deficit_obstructionFor the explicit normalized15 array and valid consecutive triple partition of wild_partition_single_swap_obstruction, the sum over colors…
- wild_joint_first_block_mixed_reductionFor q>=3 and a normalized array, summing I times the whole-bad count D over all permutations equals q times the sum of first-block witness…
- wild_joint_bad_relationA symmetric relation R is whole-bad for the block map p if some nonempty proper union of blocks (a nonempty proper set of block indices B,…
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.
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.
uses
Nat.mod_lthave := b.isLt have := Nat.mod_lt (in385_two_block_code U-1) (by omega : 0<9) omega⟩
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).
uses
Nat.mod_lthave := d.isLt have := Nat.mod_lt (in385_two_block_code U-1) (by omega : 0<3) omega⟩
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.
uses
Nat.mod_lthave := Nat.mod_lt v.val (by omega : 0<3) split_ifs <;> omega⟩
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.
decide +kernelEvery 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.
decide +kernelThe 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.
uses
in385_trap_base_deficit,wild_partition_single_swap_deficit_obstruction.2.2refine ⟨in385_trap_base_deficit,?_,wild_partition_single_swap_deficit_obstruction.2.2⟩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.
uses
in385_two_block_cardintro b d U hbd hU refine ⟨in385_two_block_card b d U hbd hU,?_⟩
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.
uses
wild_partition_single_swap_obstruction.2.2.2.2.2,in385_trap_deficit_pos_of_badobtain ⟨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
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.
uses
funext,in385_two_block_representationhave 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]
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.
uses
wild_joint_bad_relation_block_relabelexact (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.
- Lines 42 and 47 are proved entirely by kernel evaluation (`decide +kernel`), which exhausts all combinations of blocks and subsets in the Lean kernel.
- Bounds for finite index calculations in helper definitions (lines 12–14, 19–21, 29–30) are discharged by the linear arithmetic tactic `omega`.
- Combinatorially, partitioning six elements into two triples allows only 10 partitions: the original partition and 9 single swaps; Lean verifies this reduction via kernel evaluation in `in385_two_block_representation`.
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 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