Theorem: AddCircle.coe_real_preimage_closedBall_inter_eq
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: cases' le_or_lt (|p| / 2) ε with hε hε
state_before: p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs p / 2 then closedBall x ε ∩ s else s

tactic: rcases eq_or_ne p 0 with (rfl | hp)
state_before: case inl
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : abs p / 2 ≤ ε
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs p / 2 then closedBall x ε ∩ s else s

tactic: simp only [not_lt.mpr hε, ite_false, inter_eq_right_iff_subset]
state_before: case inl.inr
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : abs p / 2 ≤ ε
hp : p ≠ 0
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs p / 2 then closedBall x ε ∩ s else s

tactic: rw [closedBall_eq_univ_of_half_period_le p hp (↑x : ℝ ⧸ zmultiples p) hε, preimage_univ]
state_before: case inl.inr
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : abs p / 2 ≤ ε
hp : p ≠ 0
⊢ s ⊆ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε

tactic: apply subset_univ
state_before: case inl.inr
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : abs p / 2 ≤ ε
hp : p ≠ 0
⊢ s ⊆ univ

tactic: simp only [abs_zero, zero_div] at hε
state_before: case inl.inl
x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs 0 / 2)
hε : abs 0 / 2 ≤ ε
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs 0 / 2 then closedBall x ε ∩ s else s

tactic: simp only [not_lt.mpr hε, coe_real_preimage_closedBall_period_zero, abs_zero, zero_div,
  if_false, inter_eq_right_iff_subset]
state_before: case inl.inl
x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs 0 / 2)
hε : 0 ≤ ε
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs 0 / 2 then closedBall x ε ∩ s else s

tactic: exact hs.trans (closedBall_subset_closedBall <| by simp [hε])
state_before: case inl.inl
x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs 0 / 2)
hε : 0 ≤ ε
⊢ s ⊆ closedBall x ε

tactic: simp [hε]
state_before: x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs 0 / 2)
hε : 0 ≤ ε
⊢ abs 0 / 2 ≤ ε

tactic: suffices ∀ z : ℤ, closedBall (x + z • p) ε ∩ s = if z = 0 then closedBall x ε ∩ s else ∅ by
  simp [-zsmul_eq_mul, ← QuotientAddGroup.mk_zero, coe_real_preimage_closedBall_eq_iUnion,
    iUnion_inter, iUnion_ite, this, hε]
state_before: case inr
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : ε < abs p / 2
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs p / 2 then closedBall x ε ∩ s else s

tactic: intro z
state_before: case inr
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : ε < abs p / 2
⊢ ∀ (z : ℤ), closedBall (x + z • p) ε ∩ s = if z = 0 then closedBall x ε ∩ s else ∅

tactic: simp only [Real.closedBall_eq_Icc, zero_sub, zero_add] at hs⊢
state_before: case inr
p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : ε < abs p / 2
z : ℤ
⊢ closedBall (x + z • p) ε ∩ s = if z = 0 then closedBall x ε ∩ s else ∅

tactic: rcases eq_or_ne z 0 with (rfl | hz)
state_before: case inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
⊢ Icc (x + z • p - ε) (x + z • p + ε) ∩ s = if z = 0 then Icc (x - ε) (x + ε) ∩ s else ∅

tactic: simp only [hz, zsmul_eq_mul, if_false, eq_empty_iff_forall_not_mem]
state_before: case inr.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
⊢ Icc (x + z • p - ε) (x + z • p + ε) ∩ s = if z = 0 then Icc (x - ε) (x + ε) ∩ s else ∅

tactic: rintro y ⟨⟨hy₁, hy₂⟩, hy₀⟩
state_before: case inr.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
⊢ ∀ (x_1 : ℝ), ¬x_1 ∈ Icc (x + ↑z * p - ε) (x + ↑z * p + ε) ∩ s

tactic: obtain ⟨hy₃, hy₄⟩ := hs hy₀
state_before: case inr.inr.intro.intro
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
⊢ False

tactic: rcases lt_trichotomy 0 p with (hp | (rfl : 0 = p) | hp)
state_before: case inr.inr.intro.intro.intro
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
⊢ False

tactic: simp [-zsmul_eq_mul, ← QuotientAddGroup.mk_zero, coe_real_preimage_closedBall_eq_iUnion,
  iUnion_inter, iUnion_ite, this, hε]
state_before: p x ε : ℝ
s : Set ℝ
hs : s ⊆ closedBall x (abs p / 2)
hε : ε < abs p / 2
this : ∀ (z : ℤ), closedBall (x + z • p) ε ∩ s = if z = 0 then closedBall x ε ∩ s else ∅
⊢ QuotientAddGroup.mk ⁻¹' closedBall (↑x) ε ∩ s = if ε < abs p / 2 then closedBall x ε ∩ s else s

tactic: simp
state_before: case inr.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
⊢ Icc (x + 0 • p - ε) (x + 0 • p + ε) ∩ s = if 0 = 0 then Icc (x - ε) (x + ε) ∩ s else ∅

tactic: cases' Int.cast_le_neg_one_or_one_le_cast_of_ne_zero ℝ hz with hz' hz'
state_before: case inr.inr.intro.intro.intro.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
⊢ False

tactic: have : ↑z * p ≤ -p
state_before: case inr.inr.intro.intro.intro.inl.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : ↑z ≤ -1
⊢ False

tactic: nlinarith
state_before: case this
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : ↑z ≤ -1
⊢ ↑z * p ≤ -p

case inr.inr.intro.intro.intro.inl.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : ↑z ≤ -1
this : ↑z * p ≤ -p
⊢ False

tactic: linarith [abs_eq_self.mpr hp.le]
state_before: case inr.inr.intro.intro.intro.inl.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : ↑z ≤ -1
this : ↑z * p ≤ -p
⊢ False

tactic: have : p ≤ ↑z * p
state_before: case inr.inr.intro.intro.intro.inl.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : 1 ≤ ↑z
⊢ False

tactic: nlinarith
state_before: case this
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : 1 ≤ ↑z
⊢ p ≤ ↑z * p

case inr.inr.intro.intro.intro.inl.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : 1 ≤ ↑z
this : p ≤ ↑z * p
⊢ False

tactic: linarith [abs_eq_self.mpr hp.le]
state_before: case inr.inr.intro.intro.intro.inl.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : 0 < p
hz' : 1 ≤ ↑z
this : p ≤ ↑z * p
⊢ False

tactic: simp only [MulZeroClass.mul_zero, add_zero, abs_zero, zero_div] at hy₁ hy₂ hε
state_before: case inr.inr.intro.intro.intro.inr.inl
x ε : ℝ
s : Set ℝ
z : ℤ
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hε : ε < abs 0 / 2
hs : s ⊆ Icc (x - abs 0 / 2) (x + abs 0 / 2)
hy₁ : x + ↑z * 0 - ε ≤ y
hy₂ : y ≤ x + ↑z * 0 + ε
hy₃ : x - abs 0 / 2 ≤ y
hy₄ : y ≤ x + abs 0 / 2
⊢ False

tactic: linarith
state_before: case inr.inr.intro.intro.intro.inr.inl
x ε : ℝ
s : Set ℝ
z : ℤ
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hs : s ⊆ Icc (x - abs 0 / 2) (x + abs 0 / 2)
hy₃ : x - abs 0 / 2 ≤ y
hy₄ : y ≤ x + abs 0 / 2
hy₁ : x - ε ≤ y
hy₂ : y ≤ x + ε
hε : ε < 0
⊢ False

tactic: cases' Int.cast_le_neg_one_or_one_le_cast_of_ne_zero ℝ hz with hz' hz'
state_before: case inr.inr.intro.intro.intro.inr.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
⊢ False

tactic: have : -p ≤ ↑z * p
state_before: case inr.inr.intro.intro.intro.inr.inr.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : ↑z ≤ -1
⊢ False

tactic: nlinarith
state_before: case this
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : ↑z ≤ -1
⊢ -p ≤ ↑z * p

case inr.inr.intro.intro.intro.inr.inr.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : ↑z ≤ -1
this : -p ≤ ↑z * p
⊢ False

tactic: linarith [abs_eq_neg_self.mpr hp.le]
state_before: case inr.inr.intro.intro.intro.inr.inr.inl
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : ↑z ≤ -1
this : -p ≤ ↑z * p
⊢ False

tactic: have : ↑z * p ≤ p
state_before: case inr.inr.intro.intro.intro.inr.inr.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : 1 ≤ ↑z
⊢ False

tactic: nlinarith
state_before: case this
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : 1 ≤ ↑z
⊢ ↑z * p ≤ p

case inr.inr.intro.intro.intro.inr.inr.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : 1 ≤ ↑z
this : ↑z * p ≤ p
⊢ False

tactic: linarith [abs_eq_neg_self.mpr hp.le]
state_before: case inr.inr.intro.intro.intro.inr.inr.inr
p x ε : ℝ
s : Set ℝ
hε : ε < abs p / 2
z : ℤ
hs : s ⊆ Icc (x - abs p / 2) (x + abs p / 2)
hz : z ≠ 0
y : ℝ
hy₀ : y ∈ s
hy₁ : x + ↑z * p - ε ≤ y
hy₂ : y ≤ x + ↑z * p + ε
hy₃ : x - abs p / 2 ≤ y
hy₄ : y ≤ x + abs p / 2
hp : p < 0
hz' : 1 ≤ ↑z
this : ↑z * p ≤ p
⊢ False