internlm/Lean-Github huggingface dataset:
Theorem: Weight.le_of_mem_S_ge
Proof state before:
d a b : ℕ
hd : ↑d ≠ 0
hcop : Nat.Coprime a b
left✝ : 0 < ↑a
i₁ i₂ : ℕ
hi₀ : i₁ + i₂ ≤ d
hi₁ : 2 * d < 3 * i₁ + 3 * i₂
hi₂ : 3 * i₂ ≤ d
hab : ↑a = ↑b
x₁ : ℕ
Hx₁ : ↑x₁ = 3 * ↑i₁ + 3 * ↑i₂ - 2 * ↑d
Hx₁' : 0 < x₁
x₂ : ℕ
Hx₂ : ↑x₂ = ↑d - 3 * ↑i₂
hSge : a * x₂ = b * x₁
m : ℕ
hx₂ : m * b ≤ d
hx₁ : m * a ≤ d
hm₁ : x₁ = m * a
hm₂ : x₂ = m * b
hm₀ : 0 < m
had : ↑a = -↑d
H : m < 2
⊢ m = 1
Tactic:
linarith
Proof state after:
no goals
Theorem: Weight.le_of_mem_S_ge
Proof state before:
d a b : ℕ
hd : ↑d ≠ 0
hcop : Nat.Coprime a b
left✝ : 0 < ↑a
i₁ i₂ : ℕ
hi₀ : i₁ + i₂ ≤ d
hi₁ : 2 * d < 3 * i₁ + 3 * i₂
hi₂ : 3 * i₂ ≤ d
hab : ↑a = ↑b
x₁ : ℕ
Hx₁ : ↑x₁ = 3 * ↑i₁ + 3 * ↑i₂ - 2 * ↑d
Hx₁' : 0 < x₁
x₂ : ℕ
Hx₂ : ↑x₂ = ↑d - 3 * ↑i₂
hSge : a * x₂ = b * x₁
had : ↑a = -↑d
hx₂ : 1 * b ≤ d
hx₁ : 1 * a ≤ d
hm₁ : x₁ = 1 * a
hm₂ : x₂ = 1 * b
hm₀ : 0 < 1
H : 1 < 2
⊢ ↑x₁ = ↑d
Tactic:
reduce_mod_3 Hx₁
Proof state after:
no goals
Theorem: Weight.le_of_mem_S_ge
Proof state before:
case Ha
d a b : ℕ
hd : ↑d ≠ 0
hcop : Nat.Coprime a b
left✝ : 0 < ↑a
i₁ i₂ : ℕ
hi₀ : i₁ + i₂ ≤ d
hi₁ : 2 * d < 3 * i₁ + 3 * i₂
hi₂ : 3 * i₂ ≤ d
hab : ↑a = ↑b
x₁ : ℕ
Hx₁ : ↑x₁ = 3 * ↑i₁ + 3 * ↑i₂ - 2 * ↑d
Hx₁' : 0 < x₁
x₂ : ℕ
Hx₂ : ↑x₂ = ↑d - 3 * ↑i₂
hSge : a * x₂ = b * x₁
m : ℕ
hx₂ : m * b ≤ d
hx₁ : m * a ≤ d
hm₁ : x₁ = m * a
hm₂ : x₂ = m * b
hm₀ : 0 < m
had : ↑a = -↑d
hm : 2 ≤ m
⊢ ↑a * 2 ≤ ↑d
Tactic:
exact_mod_cast mul_comm 2 a ▸ (Nat.mul_le_mul_right a hm).trans hx₁
Proof state after:
no goals
Theorem: Weight.le_of_mem_S_ge
Proof state before:
case Hb
d a b : ℕ
hd : ↑d ≠ 0
hcop : Nat.Coprime a b
left✝ : 0 < ↑a
i₁ i₂ : ℕ
hi₀ : i₁ + i₂ ≤ d
hi₁ : 2 * d < 3 * i₁ + 3 * i₂
hi₂ : 3 * i₂ ≤ d
hab : ↑a = ↑b
x₁ : ℕ
Hx₁ : ↑x₁ = 3 * ↑i₁ + 3 * ↑i₂ - 2 * ↑d
Hx₁' : 0 < x₁
x₂ : ℕ
Hx₂ : ↑x₂ = ↑d - 3 * ↑i₂
hSge : a * x₂ = b * x₁
m : ℕ
hx₂ : m * b ≤ d
hx₁ : m * a ≤ d
hm₁ : x₁ = m * a
hm₂ : x₂ = m * b
hm₀ : 0 < m
had : ↑a = -↑d
hm : 2 ≤ m
Ha : ↑a * 2 ≤ ↑d
⊢ ↑b * 2 ≤ ↑d
Tactic:
exact_mod_cast mul_comm 2 b ▸ (Nat.mul_le_mul_right b hm).trans hx₂
Proof state after:
no goals
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
⊢ of_fraction d I.a₁ I.b₁ ≤ of_fraction d a b
Tactic:
obtain ⟨k₁, k₂, hk₁, hk₂, h₁, h₂⟩ := exists_of_mem_interior hm
Proof state after:
case intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
⊢ of_fraction d I.a₁ I.b₁ ≤ of_fraction d a b
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
⊢ of_fraction d I.a₁ I.b₁ ≤ of_fraction d a b
Tactic:
apply dom_of_pair_le
Proof state after:
case intro.intro.intro.intro.intro.h
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
⊢ ∀ (a_1 : ↑(testvecs 2 d)),
    0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v a_1) →
      pair' (of_fraction d I.a₁ I.b₁) (v a_1) ≤ pair' (of_fraction d a b) (v a_1)
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case intro.intro.intro.intro.intro.h
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
⊢ ∀ (a_1 : ↑(testvecs 2 d)),
    0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v a_1) →
      pair' (of_fraction d I.a₁ I.b₁) (v a_1) ≤ pair' (of_fraction d a b) (v a_1)
Tactic:
intro i hi
Proof state after:
case intro.intro.intro.intro.intro.h
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v i)
⊢ pair' (of_fraction d I.a₁ I.b₁) (v i) ≤ pair' (of_fraction d a b) (v i)
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case intro.intro.intro.intro.intro.h
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v i)
⊢ pair' (of_fraction d I.a₁ I.b₁) (v i) ≤ pair' (of_fraction d a b) (v i)
Tactic:
have hi' : 0 ≤ pair' (of_fraction d I.a₂ I.b₂) (v i)
Proof state after:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v i)
⊢ 0 ≤ pair' (of_fraction d I.a₂ I.b₂) (v i)

case intro.intro.intro.intro.intro.h
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v i)
hi' : 0 ≤ pair' (of_fraction d I.a₂ I.b₂) (v i)
⊢ pair' (of_fraction d I.a₁ I.b₁) (v i) ≤ pair' (of_fraction d a b) (v i)
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case intro.intro.intro.intro.intro.h
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v i)
hi' : 0 ≤ pair' (of_fraction d I.a₂ I.b₂) (v i)
⊢ pair' (of_fraction d I.a₁ I.b₁) (v i) ≤ pair' (of_fraction d a b) (v i)
Tactic:
calc
  _ = 1 * pair' (of_fraction d I.a₁ I.b₁) (v i) + 0 * pair' (of_fraction d I.a₂ I.b₂) (v i) := by
      rw [one_mul, zero_mul, add_zero]
  _ ≤ k₁ * pair' (of_fraction d I.a₁ I.b₁) (v i) + k₂ * pair' (of_fraction d I.a₂ I.b₂) (v i) :=
      add_le_add (Int.mul_le_mul_of_nonneg_right (by exact_mod_cast hk₁) hi)
                 (Int.mul_le_mul_of_nonneg_right (by exact_mod_cast hk₂.le) hi')
  _ = _ := by
      rw [h₁, h₂, pair'_of_fraction_add, Pi.add_apply, pair'_of_fraction_mul,
          pair'_of_fraction_mul]
Proof state after:
no goals
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ pair' (of_fraction d I.a₁ I.b₁) (v i)
⊢ 0 ≤ pair' (of_fraction d I.a₂ I.b₂) (v i)
Tactic:
simp only [v, Nat.cast_ofNat, pair'_of_fraction] at hi ⊢
Proof state after:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ ↑I.a₁ * (↑d - (2 + 1) * ↑(↑i 2)) + ↑I.b₁ * (↑d - (2 + 1) * ↑(↑i 1) + (↑d - (2 + 1) * ↑(↑i 2)))
⊢ 0 ≤ ↑I.a₂ * (↑d - (2 + 1) * ↑(↑i 2)) + ↑I.b₂ * (↑d - (2 + 1) * ↑(↑i 1) + (↑d - (2 + 1) * ↑(↑i 2)))
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ ↑I.a₁ * (↑d - (2 + 1) * ↑(↑i 2)) + ↑I.b₁ * (↑d - (2 + 1) * ↑(↑i 1) + (↑d - (2 + 1) * ↑(↑i 2)))
⊢ 0 ≤ ↑I.a₂ * (↑d - (2 + 1) * ↑(↑i 2)) + ↑I.b₂ * (↑d - (2 + 1) * ↑(↑i 1) + (↑d - (2 + 1) * ↑(↑i 2)))
Tactic:
norm_num at hi ⊢
Proof state after:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ ↑I.a₁ * (↑d - 3 * ↑(↑i 2)) + ↑I.b₁ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2)))
⊢ 0 ≤ ↑I.a₂ * (↑d - 3 * ↑(↑i 2)) + ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2)))
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
hi : 0 ≤ ↑I.a₁ * (↑d - 3 * ↑(↑i 2)) + ↑I.b₁ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2)))
⊢ 0 ≤ ↑I.a₂ * (↑d - 3 * ↑(↑i 2)) + ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2)))
Tactic:
set bi : ℤ := d - 3 * (i.val 2) with hbi_def
Proof state after:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * (↑d - 3 * ↑(↑i 1) + bi)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + bi)
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * (↑d - 3 * ↑(↑i 1) + bi)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + bi)
Tactic:
set ai : ℤ := d - 3 * (i.val 1) + (d - 3 * (i.val 2)) with hai_def
Proof state after:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai
Tactic:
cases' le_or_lt 0 bi with hbi hbi
Proof state after:
case hi'.inl
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai

case hi'.inr
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : bi < 0
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'.inl
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai
Tactic:
refine (mul_nonneg_iff_of_pos_right (Int.ofNat_pos.mpr I.b₁_pos)).mp ?_
Proof state after:
case hi'.inl
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ 0 ≤ (↑I.a₂ * bi + ↑I.b₂ * ai) * ↑I.b₁
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'.inl
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ 0 ≤ (↑I.a₂ * bi + ↑I.b₂ * ai) * ↑I.b₁
Tactic:
calc
  (0 : ℤ)
    ≤ (I.a₁ * bi + I.b₁ * ai) * I.b₂           := Int.mul_nonneg hi (Int.ofNat_nonneg I.b₂)
  _ = I.a₁ * I.b₂ * bi + I.b₁ * I.b₂ * ai      := by ring
  _ = I.a₂ * I.b₁ * bi + I.b₁ * I.b₂ * ai - bi := by norm_cast; rw [I.rel]; push_cast; ring
  _ = (I.a₂ * bi + I.b₂ * ai) * I.b₁ - bi      := by ring
  _ ≤ _                                        := Int.sub_le_self _ hbi
Proof state after:
no goals
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ (↑I.a₁ * bi + ↑I.b₁ * ai) * ↑I.b₂ = ↑I.a₁ * ↑I.b₂ * bi + ↑I.b₁ * ↑I.b₂ * ai
Tactic:
ring
Proof state after:
no goals
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑I.a₁ * ↑I.b₂ * bi + ↑I.b₁ * ↑I.b₂ * ai = ↑I.a₂ * ↑I.b₁ * bi + ↑I.b₁ * ↑I.b₂ * ai - bi
Tactic:
norm_cast
Proof state after:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑(I.a₁ * I.b₂) * bi + ↑(I.b₁ * I.b₂) * ai = ↑(I.a₂ * I.b₁) * bi + ↑(I.b₁ * I.b₂) * ai - bi
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑(I.a₁ * I.b₂) * bi + ↑(I.b₁ * I.b₂) * ai = ↑(I.a₂ * I.b₁) * bi + ↑(I.b₁ * I.b₂) * ai - bi
Tactic:
rw [I.rel]
Proof state after:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑(I.a₁ * I.b₂) * bi + ↑(I.b₁ * I.b₂) * ai = ↑(I.a₁ * I.b₂ + 1) * bi + ↑(I.b₁ * I.b₂) * ai - bi
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑(I.a₁ * I.b₂) * bi + ↑(I.b₁ * I.b₂) * ai = ↑(I.a₁ * I.b₂ + 1) * bi + ↑(I.b₁ * I.b₂) * ai - bi
Tactic:
push_cast
Proof state after:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑I.a₁ * ↑I.b₂ * (↑d - 3 * ↑(↑i 2)) + ↑I.b₁ * ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))) =
    (↑I.a₁ * ↑I.b₂ + 1) * (↑d - 3 * ↑(↑i 2)) + ↑I.b₁ * ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))) -
      (↑d - 3 * ↑(↑i 2))
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑I.a₁ * ↑I.b₂ * (↑d - 3 * ↑(↑i 2)) + ↑I.b₁ * ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))) =
    (↑I.a₁ * ↑I.b₂ + 1) * (↑d - 3 * ↑(↑i 2)) + ↑I.b₁ * ↑I.b₂ * (↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))) -
      (↑d - 3 * ↑(↑i 2))
Tactic:
ring
Proof state after:
no goals
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : 0 ≤ bi
⊢ ↑I.a₂ * ↑I.b₁ * bi + ↑I.b₁ * ↑I.b₂ * ai - bi = (↑I.a₂ * bi + ↑I.b₂ * ai) * ↑I.b₁ - bi
Tactic:
ring
Proof state after:
no goals
Theorem: Weight.dom_of_mem_interior_left
Proof state before:
case hi'.inr
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : bi < 0
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai
Tactic:
have hai : 0 ≤ ai
Proof state after:
case hai
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : bi < 0
⊢ 0 ≤ ai

case hi'.inr
d : ℕ
inst✝ : NeZero d
a b : ℕ
I : BasicInterval
hm : BasicInterval.mem_interior a b I
h : ∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂
k₁ k₂ : ℕ
hk₁ : 0 < k₁
hk₂ : 0 < k₂
h₁ : a = k₁ * I.a₁ + k₂ * I.a₂
h₂ : b = k₁ * I.b₁ + k₂ * I.b₂
i : ↑(testvecs 2 d)
bi : ℤ := ↑d - 3 * ↑(↑i 2)
hbi_def : bi = ↑d - 3 * ↑(↑i 2)
ai : ℤ := ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hi : 0 ≤ ↑I.a₁ * bi + ↑I.b₁ * ai
hai_def : ai = ↑d - 3 * ↑(↑i 1) + (↑d - 3 * ↑(↑i 2))
hbi : bi < 0
hai : 0 ≤ ai
⊢ 0 ≤ ↑I.a₂ * bi + ↑I.b₂ * ai