AFTD Auto-Formalizing Theoretical Domains

cycle_power_dyadic_two_distance_periodic_defect_counterexample

theoremverified

There is a period-one exponent-four tight defective profile with exact lower dyadic ownership, the defective top-owner and active-count equations, corrected lower-count periodicity, and coverage at both distances one and eleven, yet with a defect. It fails coverage at distance two and so does not refute the full-coverage conjecture.

Statement

theorem cycle_power_dyadic_two_distance_periodic_defect_counterexample :
  ∃ (y : ℤ → ℕ → Bool) (e : ℤ → Bool),
    (∀ p, cycle_power_dyadic_class_weight 4 (y p) = (Finset.range 16).sum (fun a => (y p a).toNat)) ∧
    (∀ j < 3, ∀ v : ℤ, (Finset.range (2^j)).sum (fun a =>
      (y (v-(a:ℤ)) a && y (v-(a:ℤ)) (a+16-2^j)).toNat) = 1) ∧
    (∀ v : ℤ, (Finset.range 8).sum (fun a =>
      (y (v-(a:ℤ)) a && y (v-(a:ℤ)) (a+8)).toNat) + (e v).toNat = 1) ∧
    (∀ v : ℤ, (Finset.range 16).sum (fun a => (y (v-(a:ℤ)) a).toNat) + (e v).toNat = 5) ∧
    (∀ v : ℤ, (Finset.range 8).sum (fun a => (y (v-(a:ℤ)) a).toNat) + (e v).toNat =
      (Finset.range 8).sum (fun a => (y (v+8-(a:ℤ)) a).toNat) + (e (v+8)).toNat) ∧
    (∀ v : ℤ, ∃ a : ℕ, a < 15 ∧ y (v-(a:ℤ)) a = true ∧ y (v-(a:ℤ)) (a+1) = true) ∧
    (∀ v : ℤ, ∃ a : ℕ, a < 5 ∧ y (v-(a:ℤ)) a = true ∧ y (v-(a:ℤ)) (a+11) = true) ∧
    e 0 = true ∧ ¬ (∃ a : ℕ, a < 14 ∧ y (-(a:ℤ)) a = true ∧ y (-(a:ℤ)) (a+2) = true)
Source
Counterexample to a restricted-coverage shortcut in the defective-half route for RT-1 and OP-205.
Verified
12 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 1
  • cycle_power_dyadic_class_weightThe weighted number of pairs in a dyadic arc: the endpoint pair has weight two, and distances 2^m-2^j for 1≤j<m have weight one.

The proof, explained

The proof constructs an explicit counterexample by choosing a spatially constant profile y defined by the 16-bit integer 49161 = 2^15 + 2^14 + 2^3 + 2^0 and an identically true defect indicator e. Because the configuration is translation-invariant across ℤ, all nine conditions reduce to finite computations on the set bits {0, 3, 14, 15}. In particular, bits 14 and 15 provide coverage at distance 1, bits 3 and 14 provide coverage at distance 11, and the absence of any pair of set bits differing by 2 establishes the defect at distance 2.

  1. It suffices to verify the nine conditions for the candidate witnesses y = rt1_two_dist_x and e = rt1_two_dist_e.

    The existential quantifiers ∃ y, e are instantiated with the explicit candidate profile rt1_two_dist_x and defect indicator rt1_two_dist_e, splitting the goal into nine independent conjuncts.

    line 17

    uses rt1_two_dist_x, rt1_two_dist_e

      refine ⟨rt1_two_dist_x, rt1_two_dist_e, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩
  2. For all p ∈ ℤ, the dyadic class weight of y(p) equals the sum of its active bits over the range of 16 bits.

    After introducing p, the goal is restated using the definition of rt1_two_dist_x as the bit test of 49161. Since 49161 has set bits {0, 3, 14, 15}, both the dyadic class weight and the sum of active bits evaluate to 4, which is verified by direct boolean evaluation (`decide`).

    lines 18–21

      · intro p
        change cycle_power_dyadic_class_weight 4 (fun a => (49161 : ℕ).testBit a) =
          (Finset.range 16).sum (fun a => ((49161 : ℕ).testBit a).toNat)
        decide
  3. For every scale index j < 3 and every v ∈ ℤ, the dyadic overlap sum at scale 2^j equals 1.

    The index j < 3 can only be 0, 1, or 2 (`interval_cases j`). In each case, simplifying with `rt1_two_dist_x` reduces the sum to a concrete evaluation on the bits of 49161, which evaluates to 1 in each case via `decide`.

    lines 22–23

    uses rt1_two_dist_x

      · intro j hj v
        interval_cases j <;> simp only [rt1_two_dist_x] <;> decide
  4. For every v ∈ ℤ, the top-level dyadic overlap sum (at scale 8) plus e(v) equals 1.

    Unfolding the definitions of rt1_two_dist_x and rt1_two_dist_e, e(v) is 1, and no two set bits of 49161 differ by 8, so the overlap sum is 0. The equality 0 + 1 = 1 is confirmed by evaluation (`decide`).

    lines 24–26

    uses rt1_two_dist_x, rt1_two_dist_e

      · intro v
        simp only [rt1_two_dist_x, rt1_two_dist_e]
        decide
  5. For every v ∈ ℤ, the total active count across 16 bits plus e(v) equals 5.

    Unfolding definitions, 49161 has 4 active bits and e(v) is 1. The resulting sum 4 + 1 = 5 is verified by evaluation (`decide`).

    lines 27–29

    uses rt1_two_dist_x, rt1_two_dist_e

      · intro v
        simp only [rt1_two_dist_x, rt1_two_dist_e]
        decide
  6. For every v ∈ ℤ, the 8-bit sum plus e satisfies the corrected lower-count periodicity.

    Because both rt1_two_dist_x and rt1_two_dist_e are translation-invariant (independent of the position coordinate), the expressions at v and v + 8 are syntactically identical after unfolding definitions, which `simp` simplifies directly.

    lines 30–31

    uses rt1_two_dist_x, rt1_two_dist_e

      · intro v
        simp [rt1_two_dist_x, rt1_two_dist_e]
  7. For every v ∈ ℤ, coverage holds at distance 1: there is an index a < 15 such that y(v-a, a) and y(v-a, a+1) are both true.

    Choosing a = 14 provides the witness: 14 < 15 holds, and bits 14 and 15 of 49161 are both true, verified by `decide` after unfolding rt1_two_dist_x.

    lines 32–33

    uses rt1_two_dist_x

      · intro v
        refine ⟨14, by decide, ?_, ?_⟩ <;> simp only [rt1_two_dist_x] <;> decide
  8. For every v ∈ ℤ, coverage holds at distance 11: there is an index a < 5 such that y(v-a, a) and y(v-a, a+11) are both true.

    Choosing a = 3 provides the witness: 3 < 5 holds, and bits 3 and 3 + 11 = 14 of 49161 are both true, verified by `decide` after unfolding rt1_two_dist_x.

    lines 34–35

    uses rt1_two_dist_x

      · intro v
        refine ⟨3, by decide, ?_, ?_⟩ <;> simp only [rt1_two_dist_x] <;> decide
  9. The defect condition holds at the origin: e(0) = true.

    The indicator rt1_two_dist_e is identically true by definition, which is closed immediately by `decide`.

    line 36

      · decide
  10. Coverage fails at distance 2: there is no index a < 14 such that y(-a, a) and y(-a, a+2) are both true.

    The set bits of 49161 are {0, 3, 14, 15}, and no two set bits differ by exactly 2 (the differences are 1, 3, 11, 12, 14, 15). The `decide` tactic checks all 14 candidates a ∈ {0, ..., 13} by finite evaluation and confirms none satisfies the conjunction.

    line 37

      · decide
rt1_two_dist_x
the spatially constant bit profile whose bit at position a is the a-th bit of 49161 (having set bits at positions 0, 3, 14, and 15)
rt1_two_dist_e
the defect indicator function that is identically true for all integer positions

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

def rt1_two_dist_x (_ : ℤ) (a : ℕ) : Bool := (49161 : ℕ).testBit adef rt1_two_dist_e (_ : ℤ) : Bool := truetheorem cycle_power_dyadic_two_distance_periodic_defect_counterexample :  ∃ (y : ℤ → ℕ → Bool) (e : ℤ → Bool),    (∀ p, cycle_power_dyadic_class_weight 4 (y p) = (Finset.range 16).sum (fun a => (y p a).toNat)) ∧    (∀ j < 3, ∀ v : ℤ, (Finset.range (2^j)).sum (fun a =>      (y (v-(a:ℤ)) a && y (v-(a:ℤ)) (a+16-2^j)).toNat) = 1) ∧    (∀ v : ℤ, (Finset.range 8).sum (fun a =>      (y (v-(a:ℤ)) a && y (v-(a:ℤ)) (a+8)).toNat) + (e v).toNat = 1) ∧    (∀ v : ℤ, (Finset.range 16).sum (fun a => (y (v-(a:ℤ)) a).toNat) + (e v).toNat = 5) ∧    (∀ v : ℤ, (Finset.range 8).sum (fun a => (y (v-(a:ℤ)) a).toNat) + (e v).toNat =      (Finset.range 8).sum (fun a => (y (v+8-(a:ℤ)) a).toNat) + (e (v+8)).toNat) ∧    (∀ v : ℤ, ∃ a : ℕ, a < 15 ∧ y (v-(a:ℤ)) a = true ∧ y (v-(a:ℤ)) (a+1) = true) ∧    (∀ v : ℤ, ∃ a : ℕ, a < 5 ∧ y (v-(a:ℤ)) a = true ∧ y (v-(a:ℤ)) (a+11) = true) ∧    e 0 = true ∧ ¬ (∃ a : ℕ, a < 14 ∧ y (-(a:ℤ)) a = true ∧ y (-(a:ℤ)) (a+2) = true) := by  refine ⟨rt1_two_dist_x, rt1_two_dist_e, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_, ?_⟩  · intro p    change cycle_power_dyadic_class_weight 4 (fun a => (49161 : ℕ).testBit a) =      (Finset.range 16).sum (fun a => ((49161 : ℕ).testBit a).toNat)    decide  · intro j hj v    interval_cases j <;> simp only [rt1_two_dist_x] <;> decide  · intro v    simp only [rt1_two_dist_x, rt1_two_dist_e]    decide  · intro v    simp only [rt1_two_dist_x, rt1_two_dist_e]    decide  · intro v    simp [rt1_two_dist_x, rt1_two_dist_e]  · intro v    refine ⟨14, by decide, ?_, ?_⟩ <;> simp only [rt1_two_dist_x] <;> decide  · intro v    refine ⟨3, by decide, ?_, ?_⟩ <;> simp only [rt1_two_dist_x] <;> decide  · decide  · decide
See it in the graphDiscuss this resultChallenge it