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

tactic: have aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b) := fun {a b c} h => by
  simp only [mem_zmultiples_iff] at h⊢
  obtain ⟨n, rfl⟩ := h
  exact ⟨n, (mul_smul_comm n c b).symm⟩
state_before: p x t : ℝ
⊢ ‖↑(t * x)‖ = abs t * ‖↑x‖

tactic: rcases eq_or_ne t 0 with (rfl | ht)
state_before: p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
⊢ ‖↑(t * x)‖ = abs t * ‖↑x‖

tactic: have ht' : |t| ≠ 0 := (not_congr abs_eq_zero).mpr ht
state_before: case inr
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
⊢ ‖↑(t * x)‖ = abs t * ‖↑x‖

tactic: simp only [quotient_norm_eq, Real.norm_eq_abs]
state_before: case inr
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
⊢ ‖↑(t * x)‖ = abs t * ‖↑x‖

tactic: conv_rhs => rw [← smul_eq_mul, ← Real.sInf_smul_of_nonneg (abs_nonneg t)]
state_before: case inr
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
⊢ sInf ((fun a => abs a) '' {m | ↑m = ↑(t * x)}) = abs t * sInf ((fun a => abs a) '' {m | ↑m = ↑x})

tactic: simp only [QuotientAddGroup.mk'_apply, QuotientAddGroup.eq_iff_sub_mem]
state_before: case inr
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
⊢ sInf ((fun a => abs a) '' {m | ↑m = ↑(t * x)}) = sInf (abs t • (fun a => abs a) '' {m | ↑m = ↑x})

tactic: congr 1
state_before: case inr
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
⊢ sInf ((fun a => abs a) '' {m | m - t * x ∈ zmultiples (t * p)}) =
    sInf (abs t • (fun a => abs a) '' {m | m - x ∈ zmultiples p})

tactic: ext z
state_before: case inr.e_a
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
⊢ (fun a => abs a) '' {m | m - t * x ∈ zmultiples (t * p)} = abs t • (fun a => abs a) '' {m | m - x ∈ zmultiples p}

tactic: rw [mem_smul_set_iff_inv_smul_mem₀ ht']
state_before: case inr.e_a.h
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z : ℝ
⊢ z ∈ (fun a => abs a) '' {m | m - t * x ∈ zmultiples (t * p)} ↔
    z ∈ abs t • (fun a => abs a) '' {m | m - x ∈ zmultiples p}

tactic: show
  (∃ y, y - t * x ∈ zmultiples (t * p) ∧ |y| = z) ↔ ∃ w, w - x ∈ zmultiples p ∧ |w| = (|t|)⁻¹ * z
state_before: case inr.e_a.h
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z : ℝ
⊢ z ∈ (fun a => abs a) '' {m | m - t * x ∈ zmultiples (t * p)} ↔
    (abs t)⁻¹ • z ∈ (fun a => abs a) '' {m | m - x ∈ zmultiples p}

tactic: constructor
state_before: case inr.e_a.h
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z : ℝ
⊢ (∃ y, y - t * x ∈ zmultiples (t * p) ∧ abs y = z) ↔ ∃ w, w - x ∈ zmultiples p ∧ abs w = (abs t)⁻¹ * z

tactic: simp only [mem_zmultiples_iff] at h⊢
state_before: p x t a b c : ℝ
h : a ∈ zmultiples b
⊢ c * a ∈ zmultiples (c * b)

tactic: obtain ⟨n, rfl⟩ := h
state_before: p x t a b c : ℝ
h : ∃ k, k • b = a
⊢ ∃ k, k • (c * b) = c * a

tactic: exact ⟨n, (mul_smul_comm n c b).symm⟩
state_before: case intro
p x t b c : ℝ
n : ℤ
⊢ ∃ k, k • (c * b) = c * n • b

tactic: simp
state_before: case inl
p x : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
⊢ ‖↑(0 * x)‖ = abs 0 * ‖↑x‖

tactic: rintro ⟨y, hy, rfl⟩
state_before: case inr.e_a.h.mp
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z : ℝ
⊢ (∃ y, y - t * x ∈ zmultiples (t * p) ∧ abs y = z) → ∃ w, w - x ∈ zmultiples p ∧ abs w = (abs t)⁻¹ * z

tactic: refine' ⟨t⁻¹ * y, _, by rw [abs_mul, abs_inv]⟩
state_before: case inr.e_a.h.mp.intro.intro
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
y : ℝ
hy : y - t * x ∈ zmultiples (t * p)
⊢ ∃ w, w - x ∈ zmultiples p ∧ abs w = (abs t)⁻¹ * abs y

tactic: rw [← inv_mul_cancel_left₀ ht x, ← inv_mul_cancel_left₀ ht p, ← mul_sub]
state_before: case inr.e_a.h.mp.intro.intro
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
y : ℝ
hy : y - t * x ∈ zmultiples (t * p)
⊢ t⁻¹ * y - x ∈ zmultiples p

tactic: exact aux hy
state_before: case inr.e_a.h.mp.intro.intro
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
y : ℝ
hy : y - t * x ∈ zmultiples (t * p)
⊢ t⁻¹ * (y - t * x) ∈ zmultiples (t⁻¹ * (t * p))

tactic: rw [abs_mul, abs_inv]
state_before: p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
y : ℝ
hy : y - t * x ∈ zmultiples (t * p)
⊢ abs (t⁻¹ * y) = (abs t)⁻¹ * abs y

tactic: rintro ⟨w, hw, hw'⟩
state_before: case inr.e_a.h.mpr
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z : ℝ
⊢ (∃ w, w - x ∈ zmultiples p ∧ abs w = (abs t)⁻¹ * z) → ∃ y, y - t * x ∈ zmultiples (t * p) ∧ abs y = z

tactic: refine' ⟨t * w, _, by rw [← (eq_inv_mul_iff_mul_eq₀ ht').mp hw', abs_mul]⟩
state_before: case inr.e_a.h.mpr.intro.intro
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z w : ℝ
hw : w - x ∈ zmultiples p
hw' : abs w = (abs t)⁻¹ * z
⊢ ∃ y, y - t * x ∈ zmultiples (t * p) ∧ abs y = z

tactic: rw [← mul_sub]
state_before: case inr.e_a.h.mpr.intro.intro
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z w : ℝ
hw : w - x ∈ zmultiples p
hw' : abs w = (abs t)⁻¹ * z
⊢ t * w - t * x ∈ zmultiples (t * p)

tactic: exact aux hw
state_before: case inr.e_a.h.mpr.intro.intro
p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z w : ℝ
hw : w - x ∈ zmultiples p
hw' : abs w = (abs t)⁻¹ * z
⊢ t * (w - x) ∈ zmultiples (t * p)

tactic: rw [← (eq_inv_mul_iff_mul_eq₀ ht').mp hw', abs_mul]
state_before: p x t : ℝ
aux : ∀ {a b c : ℝ}, a ∈ zmultiples b → c * a ∈ zmultiples (c * b)
ht : t ≠ 0
ht' : abs t ≠ 0
z w : ℝ
hw : w - x ∈ zmultiples p
hw' : abs w = (abs t)⁻¹ * z
⊢ abs (t * w) = z