cycle_power_sixteen_block_four_distance_barrier
There exists a period64 rooted Boolean profile table on32 offsets with selected endpoints, parent matchings at distances16/24/28, monotone first/last four positions, exact pair ownership at distances16/24/28/30, and coverage of the four ordinary distances9/17/23/26. It selects offset7 and misses3 at root0, an upper-half vertical defect. It also fails coverage at distance10 at residue54. Thus this four-distance relaxation does not suffice. The predicate cp4_valid explicitly contains only those four ordinary distances; this is not a model of full ordinary coverage or a refutation of OP-205.
Statement
theorem cycle_power_sixteen_block_four_distance_barrier :
∃ B : Fin 64 → ℕ → Bool, cp4_valid B ∧ B 0 7 = true ∧ B 0 3 = false ∧ ¬cp4_cover B 54 10- Source
- Route barrier for OP-205 / RT-1. Experiment8071 found global periodic countermodels to a proposed four-distance shortcut. Experiment8075 exported the64 profile masks and independently checked all retained conditions. The Lean proof checks the entire finite certificate by kernel reduction. No main conjecture or research advance is claimed.
- Verified
- 29 Oct 2026
- Axioms
Classical.choiceQuot.soundpropext
The proof, explained
The theorem demonstrates that the four-distance profile relaxation `cp4_valid` is insufficient to guarantee full ordinary coverage, by exhibiting an explicit counterexample `cp4_model` defined by 64 32-bit masks. Using kernel computation (`decide +kernel`), Lean verifies that `cp4_model` satisfies all validity constraints of `cp4_valid` (endpoints, parent matchings, monotonicity, exact ownerships, and coverage of distances 9, 17, 23, 26), while displaying an upper-half vertical defect at root 0 (selecting offset 7 but missing offset 3) and failing to cover distance 10 at residue 54. Providing this witness directly establishes the existential claim.
The remainder modulo 64 is strictly less than 64, making `cp4_root` well-defined. automation
To construct `cp4_root v a` as an element of `Fin 64`, Lean requires a proof that `(v.val + 64 - a) % 64 < 64`. Applying `Nat.mod_lt` reduces this to the positivity of the divisor, `0 < 64`, which is discharged by `decide`.
uses
Nat.mod_ltdef cp4_root (v : Fin 64) (a : ℕ) : Fin 64 := ⟨(v.val+64-a)%64, Nat.mod_lt _ (by decide)⟩
Coverage of any distance d from residue v is a decidable property.
Unfolding `cp4_cover` reveals an existential quantifier over the finite type `Fin 32` of a boolean conjunction. Lean's typeclass inference synthesizes the `Decidable` instance for this finite search via `infer_instance`.
instance cp4_cover_decidable (B : Fin 64 → ℕ → Bool) (v : Fin 64) (d : ℕ) : Decidable (cp4_cover B v d) := by unfold cp4_cover; infer_instance
The validity predicate `cp4_valid B` is decidable for any Boolean table B.
Unfolding `cp4_valid` expands the specification into a finite conjunction of universal quantifications over finite types (`Fin 64`, `Fin 16`, `Fin 8`, `Fin 4`), finite sums over ranges, and decidable coverage checks. Typeclass inference automatically synthesizes a decision procedure for the entire condition via `infer_instance`.
instance cp4_valid_decidable (B : Fin 64 → ℕ → Bool) : Decidable (cp4_valid B) := by unfold cp4_valid; infer_instance
The explicit profile table `cp4_model` satisfies `cp4_valid`. automation
Lean's kernel evaluates `cp4_valid cp4_model` by checking all conditions over the 64 bitmasks: endpoint selections, parent matchings at distances 16, 24, 28, monotonicity on the first and last four offsets, exact pair ownership sums equal to 1 at distances 16, 24, 28, 30, and coverage of the four distances 9, 17, 23, 26.
lemma cp4_checked : cp4_valid cp4_model := by decide +kernel
At root 0, `cp4_model` selects offset 7 but misses offset 3. automation
Evaluating the bit test on the 0-th mask (2164261251) in the kernel confirms that bit 7 is 1 (`true`) and bit 3 is 0 (`false`).
lemma cp4_defect : cp4_model 0 7 = true ∧ cp4_model 0 3 = false := by decide +kernel
`cp4_model` does not cover distance 10 at residue 54. automation
The kernel verifies `¬cp4_cover cp4_model 54 10` by exhaustively checking that no offset a in `Fin 32` with a < 22 satisfies both endpoints in `cp4_model`.
lemma cp4_missing : ¬cp4_cover cp4_model 54 10 := by decide +kernel
There exists a profile table satisfying `cp4_valid` with an upper-half vertical defect at root 0 and missing coverage at distance 10.
The existential theorem is proved by providing `cp4_model` as the witness, together with the proofs `cp4_checked`, `cp4_defect.1`, `cp4_defect.2`, and `cp4_missing`.
uses
cp4_checked,cp4_defect.1,cp4_defect.2,cp4_missingtheorem cycle_power_sixteen_block_four_distance_barrier : ∃ B : Fin 64 → ℕ → Bool, cp4_valid B ∧ B 0 7 = true ∧ B 0 3 = false ∧ ¬cp4_cover B 54 10 := by exact ⟨cp4_model,cp4_checked,cp4_defect.1,cp4_defect.2,cp4_missing⟩
Nat.mod_lt- For any natural numbers x and y with y > 0, the remainder x % y is strictly less than y.
cp4_checked- The explicit 64-profile table cp4_model satisfies all conditions of cp4_valid.
cp4_defect.1- In cp4_model, offset 7 at root 0 is set to true.
cp4_defect.2- In cp4_model, offset 3 at root 0 is set to false.
cp4_missing- The profile table cp4_model fails to cover distance 10 at residue 54.
- The validity of `cp4_model` (including parent matchings, exact pair ownerships, and coverage of the four distances {9, 17, 23, 26}), the defect at root 0, and the failure of coverage at distance 10 are all established entirely by kernel computation (`decide +kernel`).
- The predicate `cp4_valid` explicitly checks coverage for only four specific distances (9, 17, 23, 26); therefore, this counterexample is a barrier to this particular four-distance relaxation, not a refutation of full ordinary coverage or OP-205.
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 Finsetset_option maxHeartbeats 2000000set_option maxRecDepth 100000def cp4_masks : Fin 64 → ℕ := ![2164261251,2147483649,3221225473,4026531847,2147483649,3221225473,4256825599,2147483649,3221225473,3221225473,4026793999,2147483651,2147483649,3221225473,4294967295,2147483649,3221225479,2147483649,3221225473,4160749583,2147483649,3221225475,2147483649,4286579199,2147483649,3221225479,2147483651,2147483649,4160765967,2147483649,3221225475,2147483649,4294966271,2147483651,2147483649,3758096387,2147483649,4160749599,2147483649,3221241857,3758096387,2147483649,4286584831,2147483649,3221225473,3221225473,4026531847,2147614723,2147483649,4261412927,2147483649,3221225487,2147483651,2147483651,2147483649,4294967295,2147483651,2147483651,2147483649,4026531855,2147483651,2147483649,3221225601,4244635711]def cp4_model (p : Fin 64) (a : ℕ) : Bool := (cp4_masks p).testBit adef cp4_root (v : Fin 64) (a : ℕ) : Fin 64 := ⟨(v.val+64-a)%64, Nat.mod_lt _ (by decide)⟩def cp4_distances : Fin 4 → ℕ := ![9,17,23,26]def cp4_cover (B : Fin 64 → ℕ → Bool) (v : Fin 64) (d : ℕ) : Prop := ∃ a : Fin 32, a.val < 32-d ∧ B (cp4_root v a.val) a.val = true ∧ B (cp4_root v a.val) (a.val+d) = trueinstance cp4_cover_decidable (B : Fin 64 → ℕ → Bool) (v : Fin 64) (d : ℕ) : Decidable (cp4_cover B v d) := by unfold cp4_cover; infer_instancedef cp4_valid (B : Fin 64 → ℕ → Bool) : Prop := (∀ p : Fin 64, B p 0 = true ∧ B p 31 = true) ∧ (∀ (p : Fin 64) (a : Fin 16), (a.val < 8 → B p (a.val+16) = true → B p a.val = true) ∧ (8 ≤ a.val → B p a.val = true → B p (a.val+16) = true)) ∧ (∀ (p : Fin 64) (a : Fin 8), (a.val < 4 → B p (a.val+24) = true → B p a.val = true) ∧ (4 ≤ a.val → B p a.val = true → B p (a.val+24) = true)) ∧ (∀ (p : Fin 64) (a : Fin 4), (a.val < 2 → B p (a.val+28) = true → B p a.val = true) ∧ (2 ≤ a.val → B p a.val = true → B p (a.val+28) = true)) ∧ (∀ (p : Fin 64) (a b : Fin 4), a.val ≤ b.val → B p b.val = true → B p a.val = true) ∧ (∀ (p : Fin 64) (a b : Fin 4), a.val ≤ b.val → B p (28+a.val) = true → B p (28+b.val) = true) ∧ (∀ v : Fin 64, (range 16).sum (fun a => (B (cp4_root v a) a && B (cp4_root v a) (a+16)).toNat) = 1) ∧ (∀ v : Fin 64, (range 8).sum (fun a => (B (cp4_root v a) a && B (cp4_root v a) (a+24)).toNat) = 1) ∧ (∀ v : Fin 64, (range 4).sum (fun a => (B (cp4_root v a) a && B (cp4_root v a) (a+28)).toNat) = 1) ∧ (∀ v : Fin 64, (range 2).sum (fun a => (B (cp4_root v a) a && B (cp4_root v a) (a+30)).toNat) = 1) ∧ (∀ (i : Fin 4) (v : Fin 64), cp4_cover B v (cp4_distances i))instance cp4_valid_decidable (B : Fin 64 → ℕ → Bool) : Decidable (cp4_valid B) := by unfold cp4_valid; infer_instancelemma cp4_checked : cp4_valid cp4_model := by decide +kernellemma cp4_defect : cp4_model 0 7 = true ∧ cp4_model 0 3 = false := by decide +kernellemma cp4_missing : ¬cp4_cover cp4_model 54 10 := by decide +kerneltheorem cycle_power_sixteen_block_four_distance_barrier : ∃ B : Fin 64 → ℕ → Bool, cp4_valid B ∧ B 0 7 = true ∧ B 0 3 = false ∧ ¬cp4_cover B 54 10 := by exact ⟨cp4_model,cp4_checked,cp4_defect.1,cp4_defect.2,cp4_missing⟩