Theorem: Nat.ArithmeticFunction.LSeriesSummable_of_bounded_of_one_lt_real
File: Mathlib/NumberTheory/LSeries.lean

tactic: by_cases h0 : m = 0
state_before: f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
⊢ LSeriesSummable f ↑z

tactic: refine' summable_of_norm_bounded (fun n : ℕ => m / n ^ z) _ _
state_before: case neg
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
⊢ LSeriesSummable f ↑z

tactic: subst h0
state_before: case pos
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : m = 0
⊢ LSeriesSummable f ↑z

tactic: have hf : f = 0 := ArithmeticFunction.ext fun n =>
  Complex.abs.eq_zero.1 (le_antisymm (h n) (Complex.abs.nonneg _))
state_before: case pos
f : ArithmeticFunction ℂ
z : ℝ
hz : 1 < z
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ 0
⊢ LSeriesSummable f ↑z

tactic: simp [hf]
state_before: case pos
f : ArithmeticFunction ℂ
z : ℝ
hz : 1 < z
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ 0
hf : f = 0
⊢ LSeriesSummable f ↑z

tactic: simp_rw [div_eq_mul_inv]
state_before: case neg.refine'_1
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
⊢ Summable fun n => m / ↑n ^ z

tactic: exact (summable_mul_left_iff h0).2 (Real.summable_nat_rpow_inv.2 hz)
state_before: case neg.refine'_1
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
⊢ Summable fun n => m * (↑n ^ z)⁻¹

tactic: intro n
state_before: case neg.refine'_2
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
⊢ ∀ (i : ℕ), ‖↑f i / ↑i ^ ↑z‖ ≤ (fun n => m / ↑n ^ z) i

tactic: have hm : 0 ≤ m := le_trans (Complex.abs.nonneg _) (h 0)
state_before: case neg.refine'_2
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
n : ℕ
⊢ ‖↑f n / ↑n ^ ↑z‖ ≤ (fun n => m / ↑n ^ z) n

tactic: cases' n with n
state_before: case neg.refine'_2
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
n : ℕ
hm : 0 ≤ m
⊢ ‖↑f n / ↑n ^ ↑z‖ ≤ (fun n => m / ↑n ^ z) n

tactic: simp only [map_div₀, Complex.norm_eq_abs]
state_before: case neg.refine'_2.succ
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
hm : 0 ≤ m
n : ℕ
⊢ ‖↑f (succ n) / ↑(succ n) ^ ↑z‖ ≤ (fun n => m / ↑n ^ z) (succ n)

tactic: apply div_le_div hm (h _) (Real.rpow_pos_of_pos (Nat.cast_pos.2 n.succ_pos) _) (le_of_eq _)
state_before: case neg.refine'_2.succ
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
hm : 0 ≤ m
n : ℕ
⊢ ↑Complex.abs (↑f (succ n)) / ↑Complex.abs (↑(succ n) ^ ↑z) ≤ m / ↑(succ n) ^ z

tactic: rw [Complex.abs_cpow_real, Complex.abs_cast_nat]
state_before: f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
hm : 0 ≤ m
n : ℕ
⊢ ↑(succ n) ^ z = ↑Complex.abs (↑(succ n) ^ ↑z)

tactic: simp [hm, Real.zero_rpow (_root_.ne_of_gt (lt_trans Real.zero_lt_one hz))]
state_before: case neg.refine'_2.zero
f : ArithmeticFunction ℂ
m : ℝ
h : ∀ (n : ℕ), ↑Complex.abs (↑f n) ≤ m
z : ℝ
hz : 1 < z
h0 : ¬m = 0
hm : 0 ≤ m
⊢ ‖↑f Nat.zero / ↑Nat.zero ^ ↑z‖ ≤ (fun n => m / ↑n ^ z) Nat.zero