Theorem: ZMod.natAbs_min_of_le_div_two
File: Mathlib/Data/ZMod/Basic.lean

tactic: rw [intCast_eq_intCast_iff_dvd_sub] at he
state_before: n✝ a n : ℕ
x y : ℤ
he : ↑x = ↑y
hl : x.natAbs ≤ n / 2
⊢ x.natAbs ≤ y.natAbs
state_after: n✝ a n : ℕ
x y : ℤ
he : ↑n ∣ y - x
hl : x.natAbs ≤ n / 2
⊢ x.natAbs ≤ y.natAbs

tactic: obtain ⟨m, he⟩ := he
state_before: n✝ a n : ℕ
x y : ℤ
he : ↑n ∣ y - x
hl : x.natAbs ≤ n / 2
⊢ x.natAbs ≤ y.natAbs
state_after: case intro
n✝ a n : ℕ
x y : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
he : y - x = ↑n * m
⊢ x.natAbs ≤ y.natAbs

tactic: rw [sub_eq_iff_eq_add] at he
state_before: case intro
n✝ a n : ℕ
x y : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
he : y - x = ↑n * m
⊢ x.natAbs ≤ y.natAbs
state_after: case intro
n✝ a n : ℕ
x y : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
he : y = ↑n * m + x
⊢ x.natAbs ≤ y.natAbs

tactic: subst he
state_before: case intro
n✝ a n : ℕ
x y : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
he : y = ↑n * m + x
⊢ x.natAbs ≤ y.natAbs
state_after: case intro
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
⊢ x.natAbs ≤ (↑n * m + x).natAbs

tactic: obtain rfl | hm := eq_or_ne m 0
state_before: case intro
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
⊢ x.natAbs ≤ (↑n * m + x).natAbs
state_after: case intro.inl
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
⊢ x.natAbs ≤ (↑n * 0 + x).natAbs

case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ x.natAbs ≤ (↑n * m + x).natAbs

tactic: apply hl.trans
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ x.natAbs ≤ (↑n * m + x).natAbs
state_after: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 ≤ (↑n * m + x).natAbs

tactic: rw [← add_le_add_iff_right x.natAbs]
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 ≤ (↑n * m + x).natAbs
state_after: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + x.natAbs ≤ (↑n * m + x).natAbs + x.natAbs

tactic: refine le_trans (le_trans ((add_le_add_iff_left _).2 hl) ?_) (Int.natAbs_sub_le _ _)
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + x.natAbs ≤ (↑n * m + x).natAbs + x.natAbs
state_after: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + n / 2 ≤ (↑n * m + x - x).natAbs

tactic: rw [add_sub_cancel_right, Int.natAbs_mul, Int.natAbs_ofNat]
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + n / 2 ≤ (↑n * m + x - x).natAbs
state_after: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + n / 2 ≤ n * m.natAbs

tactic: refine le_trans ?_ (Nat.le_mul_of_pos_right _ <| Int.natAbs_pos.2 hm)
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + n / 2 ≤ n * m.natAbs
state_after: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + n / 2 ≤ n

tactic: rw [← mul_two]
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 + n / 2 ≤ n
state_after: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 * 2 ≤ n

tactic: apply Nat.div_mul_le_self
state_before: case intro.inr
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
m : ℤ
hm : m ≠ 0
⊢ n / 2 * 2 ≤ n
state_after: no goals

tactic: rw [mul_zero, zero_add]
state_before: case intro.inl
n✝ a n : ℕ
x : ℤ
hl : x.natAbs ≤ n / 2
⊢ x.natAbs ≤ (↑n * 0 + x).natAbs
state_after: no goals