Theorem: lp.norm_eq_zero_iff
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: refine' ⟨fun h => _, by rintro rfl; exact norm_zero⟩
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
⊢ ‖f‖ = 0 ↔ f = 0

tactic: rcases p.trichotomy with (rfl | rfl | hp)
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
⊢ f = 0

tactic: rintro rfl
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
⊢ f = 0 → ‖f‖ = 0

tactic: exact norm_zero
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
⊢ ‖0‖ = 0

tactic: ext i
state_before: case inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E 0 }
h : ‖f‖ = 0
⊢ f = 0

tactic: have : { i : α | ¬f i = 0 } = ∅ := by simpa [lp.norm_eq_card_dsupport f] using h
state_before: case inl.h.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E 0 }
h : ‖f‖ = 0
i : α
⊢ ↑f i = ↑0 i

tactic: have : (¬f i = 0) = False := congr_fun this i
state_before: case inl.h.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E 0 }
h : ‖f‖ = 0
i : α
this : {i | ¬↑f i = 0} = ∅
⊢ ↑f i = ↑0 i

tactic: tauto
state_before: case inl.h.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E 0 }
h : ‖f‖ = 0
i : α
this✝ : {i | ¬↑f i = 0} = ∅
this : (¬↑f i = 0) = False
⊢ ↑f i = ↑0 i

tactic: simpa [lp.norm_eq_card_dsupport f] using h
state_before: α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E 0 }
h : ‖f‖ = 0
i : α
⊢ {i | ¬↑f i = 0} = ∅

tactic: cases' isEmpty_or_nonempty α with _i _i
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
⊢ f = 0

tactic: have H : IsLUB (Set.range fun i => ‖f i‖) 0 := by simpa [h] using lp.isLUB_norm f
state_before: case inr.inl.inr
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
_i : Nonempty α
⊢ f = 0

tactic: ext i
state_before: case inr.inl.inr
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
_i : Nonempty α
H : IsLUB (Set.range fun i => ‖↑f i‖) 0
⊢ f = 0

tactic: have : ‖f i‖ = 0 := le_antisymm (H.1 ⟨i, rfl⟩) (norm_nonneg _)
state_before: case inr.inl.inr.h.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
_i : Nonempty α
H : IsLUB (Set.range fun i => ‖↑f i‖) 0
i : α
⊢ ↑f i = ↑0 i

tactic: simpa using this
state_before: case inr.inl.inr.h.h
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
_i : Nonempty α
H : IsLUB (Set.range fun i => ‖↑f i‖) 0
i : α
this : ‖↑f i‖ = 0
⊢ ↑f i = ↑0 i

tactic: simp
state_before: case inr.inl.inl
α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
_i : IsEmpty α
⊢ f = 0

tactic: simpa [h] using lp.isLUB_norm f
state_before: α : Type u_1
E : α → Type u_2
q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E ⊤ }
h : ‖f‖ = 0
_i : Nonempty α
⊢ IsLUB (Set.range fun i => ‖↑f i‖) 0

tactic: have hf : HasSum (fun i : α => ‖f i‖ ^ p.toReal) 0 := by
  have := lp.hasSum_norm hp f
  rwa [h, Real.zero_rpow hp.ne'] at this
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
⊢ f = 0

tactic: have : ∀ i, 0 ≤ ‖f i‖ ^ p.toReal := fun i => Real.rpow_nonneg_of_nonneg (norm_nonneg _) _
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
hf : HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) 0
⊢ f = 0

tactic: rw [hasSum_zero_iff_of_nonneg this] at hf
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
hf : HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) 0
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
⊢ f = 0

tactic: ext i
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
hf : (fun i => ‖↑f i‖ ^ ENNReal.toReal p) = 0
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
⊢ f = 0

tactic: have : f i = 0 ∧ p.toReal ≠ 0 := by
  simpa [Real.rpow_eq_zero_iff_of_nonneg (norm_nonneg (f i))] using congr_fun hf i
state_before: case inr.inr.h.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
hf : (fun i => ‖↑f i‖ ^ ENNReal.toReal p) = 0
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
i : α
⊢ ↑f i = ↑0 i

tactic: exact this.1
state_before: case inr.inr.h.h
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
hf : (fun i => ‖↑f i‖ ^ ENNReal.toReal p) = 0
this✝ : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
i : α
this : ↑f i = 0 ∧ ENNReal.toReal p ≠ 0
⊢ ↑f i = ↑0 i

tactic: have := lp.hasSum_norm hp f
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
⊢ HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) 0

tactic: rwa [h, Real.zero_rpow hp.ne'] at this
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
this : HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) (‖f‖ ^ ENNReal.toReal p)
⊢ HasSum (fun i => ‖↑f i‖ ^ ENNReal.toReal p) 0

tactic: simpa [Real.rpow_eq_zero_iff_of_nonneg (norm_nonneg (f i))] using congr_fun hf i
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝ : (i : α) → NormedAddCommGroup (E i)
f : { x // x ∈ lp E p }
h : ‖f‖ = 0
hp : 0 < ENNReal.toReal p
hf : (fun i => ‖↑f i‖ ^ ENNReal.toReal p) = 0
this : ∀ (i : α), 0 ≤ ‖↑f i‖ ^ ENNReal.toReal p
i : α
⊢ ↑f i = 0 ∧ ENNReal.toReal p ≠ 0