l3lab/ntp-mathlib huggingface dataset:
theorem finset_sum_iSup_nat {α} {ι} [SemilatticeSup ι] {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ a, Monotone (f a)) : (∑ a in s, iSup (f a)) = ⨆ n, ∑ a in s, f a n := by
  refine' Finset.induction_on s _ _
  · 

Proof state:
case refine'_1
α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
α : Type u_4
ι : Type u_5
inst✝ : SemilatticeSup ι
s : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
⊢ ∑ a in ∅, iSup (f a) = ⨆ n, ∑ a in ∅, f a n

Next tactic:
simp
theorem finset_sum_iSup_nat {α} {ι} [SemilatticeSup ι] {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ a, Monotone (f a)) : (∑ a in s, iSup (f a)) = ⨆ n, ∑ a in s, f a n := by
  refine' Finset.induction_on s _ _
  · simp
  · 

Proof state:
case refine'_2
α✝ : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
α : Type u_4
ι : Type u_5
inst✝ : SemilatticeSup ι
s : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
⊢ ∀ ⦃a : α⦄ {s : Finset α},
    a ∉ s → ∑ a in s, iSup (f a) = ⨆ n, ∑ a in s, f a n → ∑ a in insert a s, iSup (f a) = ⨆ n, ∑ a in insert a s, f a n

Next tactic:
intro a s has ih
theorem finset_sum_iSup_nat {α} {ι} [SemilatticeSup ι] {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ a, Monotone (f a)) : (∑ a in s, iSup (f a)) = ⨆ n, ∑ a in s, f a n := by
  refine' Finset.induction_on s _ _
  · simp
  · intro a s has ih
    

Proof state:
case refine'_2
α✝ : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_4
ι : Type u_5
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : a ∉ s
ih : ∑ a in s, iSup (f a) = ⨆ n, ∑ a in s, f a n
⊢ ∑ a in insert a s, iSup (f a) = ⨆ n, ∑ a in insert a s, f a n

Next tactic:
simp only [Finset.sum_insert has]
theorem finset_sum_iSup_nat {α} {ι} [SemilatticeSup ι] {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ a, Monotone (f a)) : (∑ a in s, iSup (f a)) = ⨆ n, ∑ a in s, f a n := by
  refine' Finset.induction_on s _ _
  · simp
  · intro a s has ih
    simp only [Finset.sum_insert has]
    

Proof state:
case refine'_2
α✝ : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_4
ι : Type u_5
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : a ∉ s
ih : ∑ a in s, iSup (f a) = ⨆ n, ∑ a in s, f a n
⊢ iSup (f a) + ∑ a in s, iSup (f a) = ⨆ n, f a n + ∑ a in s, f a n

Next tactic:
rw [ih, iSup_add_iSup_of_monotone (hf a)]
theorem finset_sum_iSup_nat {α} {ι} [SemilatticeSup ι] {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ a, Monotone (f a)) : (∑ a in s, iSup (f a)) = ⨆ n, ∑ a in s, f a n := by
  refine' Finset.induction_on s _ _
  · simp
  · intro a s has ih
    simp only [Finset.sum_insert has]
    rw [ih, iSup_add_iSup_of_monotone (hf a)]
    

Proof state:
case refine'_2
α✝ : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_4
ι : Type u_5
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : a ∉ s
ih : ∑ a in s, iSup (f a) = ⨆ n, ∑ a in s, f a n
⊢ Monotone fun n => ∑ a in s, f a n

Next tactic:
intro i j h
theorem finset_sum_iSup_nat {α} {ι} [SemilatticeSup ι] {s : Finset α} {f : α → ι → ℝ≥0∞}
    (hf : ∀ a, Monotone (f a)) : (∑ a in s, iSup (f a)) = ⨆ n, ∑ a in s, f a n := by
  refine' Finset.induction_on s _ _
  · simp
  · intro a s has ih
    simp only [Finset.sum_insert has]
    rw [ih, iSup_add_iSup_of_monotone (hf a)]
    intro i j h
    

Proof state:
case refine'_2
α✝ : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝¹ : Set ℝ≥0∞
α : Type u_4
ι : Type u_5
inst✝ : SemilatticeSup ι
s✝ : Finset α
f : α → ι → ℝ≥0∞
hf : ∀ (a : α), Monotone (f a)
a : α
s : Finset α
has : a ∉ s
ih : ∑ a in s, iSup (f a) = ⨆ n, ∑ a in s, f a n
i j : ι
h : i ≤ j
⊢ (fun n => ∑ a in s, f a n) i ≤ (fun n => ∑ a in s, f a n) j

Next tactic:
exact Finset.sum_le_sum fun a _ => hf a h
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ a * iSup f = ⨆ i, a * f i

Next tactic:
by_cases hf : ∀ i, f i = 0
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  by_cases hf : ∀ i, f i = 0
  · 

Proof state:
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ∀ (i : ι), f i = 0
⊢ a * iSup f = ⨆ i, a * f i

Next tactic:
obtain rfl : f = fun _ => 0
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  by_cases hf : ∀ i, f i = 0
  · obtain rfl : f = fun _ => 0
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ∀ (i : ι), f i = 0
⊢ f = fun x => 0
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
a : ℝ≥0∞
hf : ∀ (i : ι), (fun x => 0) i = 0
⊢ a * ⨆ x, 0 = ⨆ i, a * (fun x => 0) i

Next tactic:
exact funext hf
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  by_cases hf : ∀ i, f i = 0
  · obtain rfl : f = fun _ => 0
    exact funext hf
    

Proof state:
case pos
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
a : ℝ≥0∞
hf : ∀ (i : ι), (fun x => 0) i = 0
⊢ a * ⨆ x, 0 = ⨆ i, a * (fun x => 0) i

Next tactic:
simp only [iSup_zero_eq_zero, mul_zero]
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  by_cases hf : ∀ i, f i = 0
  · obtain rfl : f = fun _ => 0
    exact funext hf
    simp only [iSup_zero_eq_zero, mul_zero]
  · 

Proof state:
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ a * iSup f = ⨆ i, a * f i

Next tactic:
refine' (monotone_id.const_mul' _).map_iSup_of_continuousAt _ (mul_zero a)
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  by_cases hf : ∀ i, f i = 0
  · obtain rfl : f = fun _ => 0
    exact funext hf
    simp only [iSup_zero_eq_zero, mul_zero]
  · refine' (monotone_id.const_mul' _).map_iSup_of_continuousAt _ (mul_zero a)
    

Proof state:
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ ContinuousAt (fun x => a * id x) (⨆ i, f i)

Next tactic:
refine' ENNReal.Tendsto.const_mul tendsto_id (Or.inl _)
theorem mul_iSup {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : a * iSup f = ⨆ i, a * f i := by
  by_cases hf : ∀ i, f i = 0
  · obtain rfl : f = fun _ => 0
    exact funext hf
    simp only [iSup_zero_eq_zero, mul_zero]
  · refine' (monotone_id.const_mul' _).map_iSup_of_continuousAt _ (mul_zero a)
    refine' ENNReal.Tendsto.const_mul tendsto_id (Or.inl _)
    

Proof state:
case neg
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
hf : ¬∀ (i : ι), f i = 0
⊢ id (⨆ i, f i) ≠ 0

Next tactic:
exact mt iSup_eq_zero.1 hf
theorem mul_sSup {s : Set ℝ≥0∞} {a : ℝ≥0∞} : a * sSup s = ⨆ i ∈ s, a * i := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
a : ℝ≥0∞
⊢ a * sSup s = ⨆ i ∈ s, a * i

Next tactic:
simp only [sSup_eq_iSup, mul_iSup]
theorem iSup_mul {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f * a = ⨆ i, f i * a := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ iSup f * a = ⨆ i, f i * a

Next tactic:
rw [mul_comm, mul_iSup]
theorem iSup_mul {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f * a = ⨆ i, f i * a := by
  rw [mul_comm, mul_iSup]; 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ ⨆ i, a * f i = ⨆ i, f i * a

Next tactic:
congr
theorem iSup_mul {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f * a = ⨆ i, f i * a := by
  rw [mul_comm, mul_iSup]; congr; 

Proof state:
case e_s
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ (fun i => a * f i) = fun i => f i * a

Next tactic:
funext
theorem iSup_mul {ι : Sort*} {f : ι → ℝ≥0∞} {a : ℝ≥0∞} : iSup f * a = ⨆ i, f i * a := by
  rw [mul_comm, mul_iSup]; congr; funext; 

Proof state:
case e_s.h
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
x✝ : ι
⊢ a * f x✝ = f x✝ * a

Next tactic:
rw [mul_comm]
theorem smul_iSup {ι : Sort*} {R} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (f : ι → ℝ≥0∞)
    (c : R) : (c • ⨆ i, f i) = ⨆ i, c • f i := by
  -- Porting note: replaced `iSup _` with `iSup f`
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
R : Type u_5
inst✝¹ : SMul R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
f : ι → ℝ≥0∞
c : R
⊢ c • ⨆ i, f i = ⨆ i, c • f i

Next tactic:
simp only [← smul_one_mul c (f _), ← smul_one_mul c (iSup f), ENNReal.mul_iSup]
theorem smul_sSup {R} [SMul R ℝ≥0∞] [IsScalarTower R ℝ≥0∞ ℝ≥0∞] (s : Set ℝ≥0∞) (c : R) :
    c • sSup s = ⨆ i ∈ s, c • i := by
  -- Porting note: replaced `_` with `s`
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c✝ d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
R : Type u_4
inst✝¹ : SMul R ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
s : Set ℝ≥0∞
c : R
⊢ c • sSup s = ⨆ i ∈ s, c • i

Next tactic:
simp_rw [← smul_one_mul c (sSup s), ENNReal.mul_sSup, smul_one_mul]
theorem exists_countable_dense_no_zero_top :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ∞ ∉ s := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
⊢ ∃ s, Set.Countable s ∧ Dense s ∧ 0 ∉ s ∧ ⊤ ∉ s

Next tactic:
obtain ⟨s, s_count, s_dense, hs⟩ :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s :=
    exists_countable_dense_no_bot_top ℝ≥0∞
theorem exists_countable_dense_no_zero_top :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ∞ ∉ s := by
  obtain ⟨s, s_count, s_dense, hs⟩ :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s :=
    exists_countable_dense_no_bot_top ℝ≥0∞
  

Proof state:
case intro.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
s_count : Set.Countable s
s_dense : Dense s
hs : (∀ (x : ℝ≥0∞), IsBot x → x ∉ s) ∧ ∀ (x : ℝ≥0∞), IsTop x → x ∉ s
⊢ ∃ s, Set.Countable s ∧ Dense s ∧ 0 ∉ s ∧ ⊤ ∉ s

Next tactic:
exact ⟨s, s_count, s_dense, fun h => hs.1 0 (by simp) h, fun h => hs.2 ∞ (by simp) h⟩
theorem exists_countable_dense_no_zero_top :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ∞ ∉ s := by
  obtain ⟨s, s_count, s_dense, hs⟩ :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s :=
    exists_countable_dense_no_bot_top ℝ≥0∞
  exact ⟨s, s_count, s_dense, fun h => hs.1 0 (by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
s_count : Set.Countable s
s_dense : Dense s
hs : (∀ (x : ℝ≥0∞), IsBot x → x ∉ s) ∧ ∀ (x : ℝ≥0∞), IsTop x → x ∉ s
h : 0 ∈ s
⊢ IsBot 0

Next tactic:
simp
theorem exists_countable_dense_no_zero_top :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ 0 ∉ s ∧ ∞ ∉ s := by
  obtain ⟨s, s_count, s_dense, hs⟩ :
    ∃ s : Set ℝ≥0∞, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s :=
    exists_countable_dense_no_bot_top ℝ≥0∞
  exact ⟨s, s_count, s_dense, fun h => hs.1 0 (by simp) h, fun h => hs.2 ∞ (by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ s : Set ℝ≥0∞
s_count : Set.Countable s
s_dense : Dense s
hs : (∀ (x : ℝ≥0∞), IsBot x → x ∉ s) ∧ ∀ (x : ℝ≥0∞), IsTop x → x ∉ s
h : ⊤ ∈ s
⊢ IsTop ⊤

Next tactic:
simp
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

Next tactic:
have : NeZero y := ⟨hy⟩
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this : NeZero y
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

Next tactic:
have : NeZero z := ⟨hz⟩
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  have : NeZero z := ⟨hz⟩
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

Next tactic:
have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
    apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
    rw [← nhds_prod_eq]
    exact tendsto_add
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  have : NeZero z := ⟨hz⟩
  have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ Tendsto (fun p => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z))

Next tactic:
apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  have : NeZero z := ⟨hz⟩
  have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
    apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ Tendsto (fun p => p.1 + p.2) (𝓝 y ×ˢ 𝓝 z) (𝓝 (y + z))

Next tactic:
rw [← nhds_prod_eq]
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  have : NeZero z := ⟨hz⟩
  have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
    apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
    rw [← nhds_prod_eq]
    

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
⊢ Tendsto (fun p => p.1 + p.2) (𝓝 (y, z)) (𝓝 (y + z))

Next tactic:
exact tendsto_add
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  have : NeZero z := ⟨hz⟩
  have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
    apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
    rw [← nhds_prod_eq]
    exact tendsto_add
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
A : Tendsto (fun p => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z))
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

Next tactic:
rcases ((A.eventually (lt_mem_nhds h)).and
      (Filter.prod_mem_prod self_mem_nhdsWithin self_mem_nhdsWithin)).exists with
    ⟨⟨y', z'⟩, hx, hy', hz'⟩
theorem exists_lt_add_of_lt_add {x y z : ℝ≥0∞} (h : x < y + z) (hy : y ≠ 0) (hz : z ≠ 0) :
    ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z' := by
  have : NeZero y := ⟨hy⟩
  have : NeZero z := ⟨hz⟩
  have A : Tendsto (fun p : ℝ≥0∞ × ℝ≥0∞ => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z)) := by
    apply Tendsto.mono_left _ (Filter.prod_mono nhdsWithin_le_nhds nhdsWithin_le_nhds)
    rw [← nhds_prod_eq]
    exact tendsto_add
  rcases ((A.eventually (lt_mem_nhds h)).and
      (Filter.prod_mem_prod self_mem_nhdsWithin self_mem_nhdsWithin)).exists with
    ⟨⟨y', z'⟩, hx, hy', hz'⟩
  

Proof state:
case intro.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y✝ z✝ ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
x y z : ℝ≥0∞
h : x < y + z
hy : y ≠ 0
hz : z ≠ 0
this✝ : NeZero y
this : NeZero z
A : Tendsto (fun p => p.1 + p.2) (𝓝[<] y ×ˢ 𝓝[<] z) (𝓝 (y + z))
y' z' : ℝ≥0∞
hx : x < (y', z').1 + (y', z').2
hy' : (y', z').1 ∈ Iio y
hz' : (y', z').2 ∈ Iio z
⊢ ∃ y' z', y' < y ∧ z' < z ∧ x < y' + z'

Next tactic:
exact ⟨y', z', hy', hz', hx⟩
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
⊢ ∃ R, ∃ᶠ (n : ι) in l, x n < R

Next tactic:
by_contra h
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R := by
  by_contra h
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ¬∃ R, ∃ᶠ (n : ι) in l, x n < R
⊢ False

Next tactic:
simp_rw [not_exists, not_frequently, not_lt] at h
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R := by
  by_contra h
  simp_rw [not_exists, not_frequently, not_lt] at h
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ∀ (x_1 : ℝ), ∀ᶠ (x_2 : ι) in l, x_1 ≤ x x_2
⊢ False

Next tactic:
refine hx (ENNReal.eq_top_of_forall_nnreal_le fun r => le_limsInf_of_le (by isBoundedDefault) ?_)
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R := by
  by_contra h
  simp_rw [not_exists, not_frequently, not_lt] at h
  refine hx (ENNReal.eq_top_of_forall_nnreal_le fun r => le_limsInf_of_le (by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ∀ (x_1 : ℝ), ∀ᶠ (x_2 : ι) in l, x_1 ≤ x x_2
r : ℝ≥0
⊢ IsCobounded (fun x x_1 => x ≥ x_1) (map (fun n => ↑(Real.nnabs (x n))) l)

Next tactic:
isBoundedDefault
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R := by
  by_contra h
  simp_rw [not_exists, not_frequently, not_lt] at h
  refine hx (ENNReal.eq_top_of_forall_nnreal_le fun r => le_limsInf_of_le (by isBoundedDefault) ?_)
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ∀ (x_1 : ℝ), ∀ᶠ (x_2 : ι) in l, x_1 ≤ x x_2
r : ℝ≥0
⊢ ∀ᶠ (n : ℝ≥0∞) in map (fun n => ↑(Real.nnabs (x n))) l, ↑r ≤ n

Next tactic:
simp only [eventually_map, ENNReal.coe_le_coe]
theorem exists_frequently_lt_of_liminf_ne_top {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, x n < R := by
  by_contra h
  simp_rw [not_exists, not_frequently, not_lt] at h
  refine hx (ENNReal.eq_top_of_forall_nnreal_le fun r => le_limsInf_of_le (by isBoundedDefault) ?_)
  simp only [eventually_map, ENNReal.coe_le_coe]
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ∀ (x_1 : ℝ), ∀ᶠ (x_2 : ι) in l, x_1 ≤ x x_2
r : ℝ≥0
⊢ ∀ᶠ (a : ι) in l, r ≤ Real.nnabs (x a)

Next tactic:
filter_upwards [h r] with i hi using hi.trans (le_abs_self (x i))
theorem exists_frequently_lt_of_liminf_ne_top' {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, R < x n := by
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
⊢ ∃ R, ∃ᶠ (n : ι) in l, R < x n

Next tactic:
by_contra h
theorem exists_frequently_lt_of_liminf_ne_top' {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, R < x n := by
  by_contra h
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ¬∃ R, ∃ᶠ (n : ι) in l, R < x n
⊢ False

Next tactic:
simp_rw [not_exists, not_frequently, not_lt] at h
theorem exists_frequently_lt_of_liminf_ne_top' {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, R < x n := by
  by_contra h
  simp_rw [not_exists, not_frequently, not_lt] at h
  

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ∀ (x_1 : ℝ), ∀ᶠ (x_2 : ι) in l, x x_2 ≤ x_1
⊢ False

Next tactic:
refine hx (ENNReal.eq_top_of_forall_nnreal_le fun r => le_limsInf_of_le (by isBoundedDefault) ?_)
theorem exists_frequently_lt_of_liminf_ne_top' {ι : Type*} {l : Filter ι} {x : ι → ℝ}
    (hx : liminf (fun n => (Real.nnabs (x n) : ℝ≥0∞)) l ≠ ∞) : ∃ R, ∃ᶠ n in l, R < x n := by
  by_contra h
  simp_rw [not_exists, not_frequently, not_lt] at h
  refine hx (ENNReal.eq_top_of_forall_nnreal_le fun r => le_limsInf_of_le (by 

Proof state:
α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x✝ y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Type u_4
l : Filter ι
x : ι → ℝ
hx : liminf (fun n => ↑(Real.nnabs (x n))) l ≠ ⊤
h : ∀ (x_1 : ℝ), ∀ᶠ (x_2 : ι) in l, x x_2 ≤ x_1
r : ℝ≥0
⊢ IsCobounded (fun x x_1 => x ≥ x_1) (map (fun n => ↑(Real.nnabs (x n))) l)

Next tactic:
isBoundedDefault