internlm/Lean-Github huggingface dataset:
Theorem: Weight.condition_iff_weaker_ge
Proof state before:
case inl
d : ℕ
inst✝ : NeZero d
I : BasicInterval
H : ∀ (a b : ℕ), Nat.Coprime a b → mem_S_ge d ↑a ↑b → mem a b I → a * I.b₁ = b * I.a₁
a b : ℕ
h₁ : mem_S_ge d ↑a ↑b
h₂ : mem a b I
h₀ : Nat.gcd a b = 0
⊢ a * I.b₁ = b * I.a₁
Tactic:
obtain ⟨rfl, rfl⟩ := Nat.gcd_eq_zero_iff.mp h₀
Proof state after:
case inl.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
H : ∀ (a b : ℕ), Nat.Coprime a b → mem_S_ge d ↑a ↑b → mem a b I → a * I.b₁ = b * I.a₁
h₁ : mem_S_ge d ↑0 ↑0
h₂ : mem 0 0 I
h₀ : Nat.gcd 0 0 = 0
⊢ 0 * I.b₁ = 0 * I.a₁
Theorem: Weight.condition_iff_weaker_ge
Proof state before:
case inl.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
H : ∀ (a b : ℕ), Nat.Coprime a b → mem_S_ge d ↑a ↑b → mem a b I → a * I.b₁ = b * I.a₁
h₁ : mem_S_ge d ↑0 ↑0
h₂ : mem 0 0 I
h₀ : Nat.gcd 0 0 = 0
⊢ 0 * I.b₁ = 0 * I.a₁
Tactic:
simp only [zero_mul]
Proof state after:
no goals
Theorem: Weight.eq_left_of_add_le
Proof state before:
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
⊢ a = I.a₁ ∧ b = I.b₁
Tactic:
refine Nat.eq_and_eq_of_coprime_coprime_mul_eq_mul hcop I.coprime₁ ?_
Proof state after:
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
⊢ a * I.b₁ = b * I.a₁
Theorem: Weight.eq_left_of_add_le
Proof state before:
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
⊢ a * I.b₁ = b * I.a₁
Tactic:
rcases eq_or_eq_or_mem_interior_of_mem hmem with left | right | interior
Proof state after:
case inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
left : a * I.b₁ = b * I.a₁
⊢ a * I.b₁ = b * I.a₁

case inr.inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
right : a * I.b₂ = b * I.a₂
⊢ a * I.b₁ = b * I.a₁

case inr.inr
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
interior : BasicInterval.mem_interior a b I
⊢ a * I.b₁ = b * I.a₁
Theorem: Weight.eq_left_of_add_le
Proof state before:
case inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
left : a * I.b₁ = b * I.a₁
⊢ a * I.b₁ = b * I.a₁
Tactic:
exact left
Proof state after:
no goals
Theorem: Weight.eq_left_of_add_le
Proof state before:
case inr.inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
right : a * I.b₂ = b * I.a₂
⊢ a * I.b₁ = b * I.a₁
Tactic:
contradiction
Proof state after:
no goals
Theorem: Weight.eq_left_of_add_le
Proof state before:
case inr.inr
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₂ ≠ b * I.a₂
interior : BasicInterval.mem_interior a b I
⊢ a * I.b₁ = b * I.a₁
Tactic:
linarith only [gt_of_mem_interior_feasible hI interior, hbd]
Proof state after:
no goals
Theorem: Weight.eq_right_of_add_le
Proof state before:
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
⊢ a = I.a₂ ∧ b = I.b₂
Tactic:
refine Nat.eq_and_eq_of_coprime_coprime_mul_eq_mul hcop I.coprime₂ ?_
Proof state after:
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
⊢ a * I.b₂ = b * I.a₂
Theorem: Weight.eq_right_of_add_le
Proof state before:
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
⊢ a * I.b₂ = b * I.a₂
Tactic:
rcases eq_or_eq_or_mem_interior_of_mem hmem with left | right | interior
Proof state after:
case inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
left : a * I.b₁ = b * I.a₁
⊢ a * I.b₂ = b * I.a₂

case inr.inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
right : a * I.b₂ = b * I.a₂
⊢ a * I.b₂ = b * I.a₂

case inr.inr
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
interior : BasicInterval.mem_interior a b I
⊢ a * I.b₂ = b * I.a₂
Theorem: Weight.eq_right_of_add_le
Proof state before:
case inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
left : a * I.b₁ = b * I.a₁
⊢ a * I.b₂ = b * I.a₂
Tactic:
contradiction
Proof state after:
no goals
Theorem: Weight.eq_right_of_add_le
Proof state before:
case inr.inl
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
right : a * I.b₂ = b * I.a₂
⊢ a * I.b₂ = b * I.a₂
Tactic:
exact right
Proof state after:
no goals
Theorem: Weight.eq_right_of_add_le
Proof state before:
case inr.inr
d a b : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
hcop : Nat.Coprime a b
hmem : mem a b I
hbd : a + b ≤ d
hne : a * I.b₁ ≠ b * I.a₁
interior : BasicInterval.mem_interior a b I
⊢ a * I.b₂ = b * I.a₂
Tactic:
linarith only [gt_of_mem_interior_feasible hI interior, hbd]
Proof state after:
no goals
Theorem: Weight.condition_of_feasible
Proof state before:
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
⊢ (∀ (a' b' : ℕ), mem_S_le d ↑a' ↑b' → mem a' b' I → a' * I.b₂ = b' * I.a₂) ∨
    ∀ (a' b' : ℕ), mem_S_ge d ↑a' ↑b' → mem a' b' I → a' * I.b₁ = b' * I.a₁
Tactic:
rw [← condition_iff_weaker_le, ← condition_iff_weaker_ge]
Proof state after:
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
⊢ (∀ (a b : ℕ), Nat.Coprime a b → mem_S_le d ↑a ↑b → mem a b I → a * I.b₂ = b * I.a₂) ∨
    ∀ (a b : ℕ), Nat.Coprime a b → mem_S_ge d ↑a ↑b → mem a b I → a * I.b₁ = b * I.a₁
Theorem: Weight.condition_of_feasible
Proof state before:
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
⊢ (∀ (a b : ℕ), Nat.Coprime a b → mem_S_le d ↑a ↑b → mem a b I → a * I.b₂ = b * I.a₂) ∨
    ∀ (a b : ℕ), Nat.Coprime a b → mem_S_ge d ↑a ↑b → mem a b I → a * I.b₁ = b * I.a₁
Tactic:
by_contra! H
Proof state after:
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
H :
  (∃ a b, Nat.Coprime a b ∧ mem_S_le d ↑a ↑b ∧ mem a b I ∧ a * I.b₂ ≠ b * I.a₂) ∧
    ∃ a b, Nat.Coprime a b ∧ mem_S_ge d ↑a ↑b ∧ mem a b I ∧ a * I.b₁ ≠ b * I.a₁
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
H :
  (∃ a b, Nat.Coprime a b ∧ mem_S_le d ↑a ↑b ∧ mem a b I ∧ a * I.b₂ ≠ b * I.a₂) ∧
    ∃ a b, Nat.Coprime a b ∧ mem_S_ge d ↑a ↑b ∧ mem a b I ∧ a * I.b₁ ≠ b * I.a₁
⊢ False
Tactic:
obtain ⟨⟨s₁, t₁, hcop₁, hSle, hmem₁, hne₁⟩, ⟨s₂, t₂, hcop₂, hSge, hmem₂, hne₂⟩⟩ := H
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
⊢ False
Tactic:
cases' eq_or_ne (d : ZMod 3) 0 with hd hd
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inl
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d = 0
⊢ False

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
⊢ False
Tactic:
obtain ⟨hs₁t₁mod3, hyp₁⟩ := add_le_of_mem_S_le hd hcop₁ hSle
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
⊢ False
Tactic:
have h' : s₁+ t₁ ≤ d :=
  hyp₁.elim (fun ⟨_, hyp⟩ ↦ hyp) (fun ⟨_, hyp⟩ ↦ hyp.trans <| Nat.div_le_self d 2)
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
⊢ False
Tactic:
obtain ⟨hs₁a₁, ht₁b₁⟩ := eq_left_of_add_le hI hcop₁ hmem₁ (by linarith) hne₁
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
⊢ False
Tactic:
obtain ⟨hs₂t₂mod3, hyp₂⟩ := le_of_mem_S_ge hd hcop₂ hSge
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
⊢ False
Tactic:
obtain ⟨k₁, k₂, hks₂, hkt₂⟩ := exists_of_mem hmem₂
Proof state after:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
⊢ False
Tactic:
have hbd : s₂ + t₂ ≤ 2 * d
Proof state after:
case hbd
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
⊢ s₂ + t₂ ≤ 2 * d

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
⊢ False
Tactic:
have hk₂' : 3 ∣ k₂
Proof state after:
case hk₂'
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
⊢ 3 ∣ k₂

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
⊢ False
Tactic:
have hk₂ : 3 ≤ k₂
Proof state after:
case hk₂
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
⊢ 3 ≤ k₂

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
hk₂ : 3 ≤ k₂
⊢ False
Theorem: Weight.condition_of_feasible
Proof state before:
case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
hk₂ : 3 ≤ k₂
⊢ False
Tactic:
have hk₁ : 1 ≤ k₁
Proof state after:
case hk₁
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
hk₂ : 3 ≤ k₂
⊢ 1 ≤ k₁

case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.inr.intro.intro.intro.intro.intro.intro
d : ℕ
inst✝ : NeZero d
I : BasicInterval
hI : feasible d I
s₁ t₁ : ℕ
hcop₁ : Nat.Coprime s₁ t₁
hSle : mem_S_le d ↑s₁ ↑t₁
hmem₁ : mem s₁ t₁ I
hne₁ : s₁ * I.b₂ ≠ t₁ * I.a₂
s₂ t₂ : ℕ
hcop₂ : Nat.Coprime s₂ t₂
hSge : mem_S_ge d ↑s₂ ↑t₂
hmem₂ : mem s₂ t₂ I
hne₂ : s₂ * I.b₁ ≠ t₂ * I.a₁
hd : ↑d ≠ 0
hs₁t₁mod3 : ↑s₁ = ↑t₁
hyp₁ : ↑s₁ = -↑d ∧ s₁ + t₁ ≤ d ∨ ↑s₁ = ↑d ∧ s₁ + t₁ ≤ d / 2
h' : s₁ + t₁ ≤ d
hs₁a₁ : s₁ = I.a₁
ht₁b₁ : t₁ = I.b₁
hs₂t₂mod3 : ↑s₂ = ↑t₂
hyp₂ : ↑s₂ = ↑d ∧ s₂ ≤ d ∧ t₂ ≤ d ∨ ↑s₂ = -↑d ∧ s₂ ≤ d / 2 ∧ t₂ ≤ d / 2
k₁ k₂ : ℕ
hks₂ : s₂ = k₁ * I.a₁ + k₂ * I.a₂
hkt₂ : t₂ = k₁ * I.b₁ + k₂ * I.b₂
hbd : s₂ + t₂ ≤ 2 * d
hk₂' : 3 ∣ k₂
hk₂ : 3 ≤ k₂
hk₁ : 1 ≤ k₁
⊢ False