Theorem: MeasureTheory.Lp.completeSpace_lp_of_cauchy_complete_ℒp
File: Mathlib/MeasureTheory/Function/LpSpace.lean

tactic: let B := fun n : ℕ => ((1 : ℝ) / 2) ^ n
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
⊢ CompleteSpace { x // x ∈ Lp E p }

tactic: have hB_pos : ∀ n, 0 < B n := fun n => pow_pos (div_pos zero_lt_one zero_lt_two) n
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
⊢ CompleteSpace { x // x ∈ Lp E p }

tactic: refine' Metric.complete_of_convergent_controlled_sequences B hB_pos fun f hf => _
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
⊢ CompleteSpace { x // x ∈ Lp E p }

tactic: rsuffices ⟨f_lim, hf_lim_meas, h_tendsto⟩ :
  ∃ (f_lim : α → E), Memℒp f_lim p μ ∧
    atTop.Tendsto (fun n => snorm (⇑(f n) - f_lim) p μ) (𝓝 0)
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
⊢ ∃ x, Tendsto f atTop (𝓝 x)

tactic: have hB : Summable B := summable_geometric_two
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: cases' hB with M hB
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
hB : Summable B
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: let B1 n := ENNReal.ofReal (B n)
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: have hB1_has : HasSum B1 (ENNReal.ofReal M) := by
  have h_tsum_B1 : (∑' i, B1 i) = ENNReal.ofReal M := by
    change (∑' n : ℕ, ENNReal.ofReal (B n)) = ENNReal.ofReal M
    rw [← hB.tsum_eq]
    exact (ENNReal.ofReal_tsum_of_nonneg (fun n => le_of_lt (hB_pos n)) hB.summable).symm
  have h_sum := (@ENNReal.summable _ B1).hasSum
  rwa [h_tsum_B1] at h_sum
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: have hB1 : (∑' i, B1 i) < ∞ := by
  rw [hB1_has.tsum_eq]
  exact ENNReal.ofReal_lt_top
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: let f1 : ℕ → α → E := fun n => f n
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: refine' H f1 (fun n => Lp.memℒp (f n)) B1 hB1 fun N n m hn hm => _
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
⊢ ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)

tactic: specialize hf N n m hn hm
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m✝ m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
N n m : ℕ
hn : N ≤ n
hm : N ≤ m
⊢ snorm (f1 n - f1 m) p μ < B1 N

tactic: rw [dist_def] at hf
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m✝ m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
N n m : ℕ
hn : N ≤ n
hm : N ≤ m
hf : dist (f n) (f m) < B N
⊢ snorm (f1 n - f1 m) p μ < B1 N

tactic: dsimp only
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m✝ m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
N n m : ℕ
hn : N ≤ n
hm : N ≤ m
hf : ENNReal.toReal (snorm (↑↑(f n) - ↑↑(f m)) p μ) < B N
⊢ snorm (f1 n - f1 m) p μ < B1 N

tactic: rwa [ENNReal.lt_ofReal_iff_toReal_lt]
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m✝ m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
N n m : ℕ
hn : N ≤ n
hm : N ≤ m
hf : ENNReal.toReal (snorm (↑↑(f n) - ↑↑(f m)) p μ) < B N
⊢ snorm (↑↑(f n) - ↑↑(f m)) p μ < ENNReal.ofReal ((1 / 2) ^ N)

tactic: rw [snorm_congr_ae (Lp.coeFn_sub _ _).symm]
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m✝ m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
N n m : ℕ
hn : N ≤ n
hm : N ≤ m
hf : ENNReal.toReal (snorm (↑↑(f n) - ↑↑(f m)) p μ) < B N
⊢ snorm (↑↑(f n) - ↑↑(f m)) p μ ≠ ⊤

tactic: exact Lp.snorm_ne_top _
state_before: case intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m✝ m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
hB1 : (∑' (i : ℕ), B1 i) < ⊤
f1 : ℕ → α → E := fun n => ↑↑(f n)
N n m : ℕ
hn : N ≤ n
hm : N ≤ m
hf : ENNReal.toReal (snorm (↑↑(f n) - ↑↑(f m)) p μ) < B N
⊢ snorm (↑↑(f n - f m)) p μ ≠ ⊤

tactic: exact ⟨hf_lim_meas.toLp f_lim, tendsto_Lp_of_tendsto_ℒp f_lim hf_lim_meas h_tendsto⟩
state_before: case intro.intro
α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
f_lim : α → E
hf_lim_meas : Memℒp f_lim p
h_tendsto : Tendsto (fun n => snorm (↑↑(f n) - f_lim) p μ) atTop (𝓝 0)
⊢ ∃ x, Tendsto f atTop (𝓝 x)

tactic: have h_tsum_B1 : (∑' i, B1 i) = ENNReal.ofReal M := by
  change (∑' n : ℕ, ENNReal.ofReal (B n)) = ENNReal.ofReal M
  rw [← hB.tsum_eq]
  exact (ENNReal.ofReal_tsum_of_nonneg (fun n => le_of_lt (hB_pos n)) hB.summable).symm
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
⊢ HasSum B1 (ENNReal.ofReal M)

tactic: have h_sum := (@ENNReal.summable _ B1).hasSum
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
h_tsum_B1 : (∑' (i : ℕ), B1 i) = ENNReal.ofReal M
⊢ HasSum B1 (ENNReal.ofReal M)

tactic: rwa [h_tsum_B1] at h_sum
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
h_tsum_B1 : (∑' (i : ℕ), B1 i) = ENNReal.ofReal M
h_sum : HasSum B1 (∑' (b : ℕ), B1 b)
⊢ HasSum B1 (ENNReal.ofReal M)

tactic: change (∑' n : ℕ, ENNReal.ofReal (B n)) = ENNReal.ofReal M
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
⊢ (∑' (i : ℕ), B1 i) = ENNReal.ofReal M

tactic: rw [← hB.tsum_eq]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
⊢ (∑' (n : ℕ), ENNReal.ofReal (B n)) = ENNReal.ofReal M

tactic: exact (ENNReal.ofReal_tsum_of_nonneg (fun n => le_of_lt (hB_pos n)) hB.summable).symm
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
⊢ (∑' (n : ℕ), ENNReal.ofReal (B n)) = ENNReal.ofReal (∑' (b : ℕ), B b)

tactic: rw [hB1_has.tsum_eq]
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
⊢ (∑' (i : ℕ), B1 i) < ⊤

tactic: exact ENNReal.ofReal_lt_top
state_before: α : Type u_2
E : Type u_1
F : Type ?u.8136831
G : Type ?u.8136834
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hp : Fact (1 ≤ p)
H :
  ∀ (f : ℕ → α → E),
    (∀ (n : ℕ), Memℒp (f n) p) →
      ∀ (B : ℕ → ℝ≥0∞),
        (∑' (i : ℕ), B i) < ⊤ →
          (∀ (N n m : ℕ), N ≤ n → N ≤ m → snorm (f n - f m) p μ < B N) →
            ∃ f_lim, Memℒp f_lim p ∧ Tendsto (fun n => snorm (f n - f_lim) p μ) atTop (𝓝 0)
B : ℕ → ℝ := fun n => (1 / 2) ^ n
hB_pos : ∀ (n : ℕ), 0 < B n
f : ℕ → { x // x ∈ Lp E p }
hf : ∀ (N n m : ℕ), N ≤ n → N ≤ m → dist (f n) (f m) < B N
M : ℝ
hB : HasSum B M
B1 : ℕ → ℝ≥0∞ := fun n => ENNReal.ofReal (B n)
hB1_has : HasSum B1 (ENNReal.ofReal M)
⊢ ENNReal.ofReal M < ⊤