File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

full_name: Asymptotics.wrapped._@.Mathlib.Analysis.Asymptotics.Asymptotics._hyg.578
code: /-- This version of the Landau notation `IsBigOWith C l f g` where `f` and `g` are two functions on
a type `α` and `l` is a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by `C * ‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded by `C`, modulo division by zero issues that are
avoided by this definition. Probably you want to use `IsBigO` instead of this relation. -/
irreducible_def IsBigOWith (c : ℝ) (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Subtype (Eq @Asymptotics.definition✝)

full_name: Asymptotics.definition._@.Mathlib.Analysis.Asymptotics.Asymptotics._hyg.578
code: /-- This version of the Landau notation `IsBigOWith C l f g` where `f` and `g` are two functions on
a type `α` and `l` is a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by `C * ‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded by `C`, modulo division by zero issues that are
avoided by this definition. Probably you want to use `IsBigO` instead of this relation. -/
irreducible_def IsBigOWith (c : ℝ) (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Prop

full_name: Asymptotics.IsBigOWith
code: /-- This version of the Landau notation `IsBigOWith C l f g` where `f` and `g` are two functions on
a type `α` and `l` is a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by `C * ‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded by `C`, modulo division by zero issues that are
avoided by this definition. Probably you want to use `IsBigO` instead of this relation. -/
irreducible_def IsBigOWith (c : ℝ) (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Prop

full_name: Asymptotics.IsBigOWith_def
code: /-- This version of the Landau notation `IsBigOWith C l f g` where `f` and `g` are two functions on
a type `α` and `l` is a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by `C * ‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded by `C`, modulo division by zero issues that are
avoided by this definition. Probably you want to use `IsBigO` instead of this relation. -/
irreducible_def IsBigOWith (c : ℝ) (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Asymptotics.IsBigOWith c l f g = ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.isBigOWith_iff
code: /-- Definition of `IsBigOWith`. We record it in a lemma as `IsBigOWith` is irreducible. -/
theorem isBigOWith_iff : IsBigOWith c l f g ↔ ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖ 
goal: Asymptotics.IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.wrapped._@.Mathlib.Analysis.Asymptotics.Asymptotics._hyg.1306
code: /-- The Landau notation `f =O[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by a constant multiple of `‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded, modulo division by zero issues that are avoided
by this definition. -/
irreducible_def IsBigO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Subtype (Eq @Asymptotics.definition✝)

full_name: Asymptotics.definition._@.Mathlib.Analysis.Asymptotics.Asymptotics._hyg.1306
code: /-- The Landau notation `f =O[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by a constant multiple of `‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded, modulo division by zero issues that are avoided
by this definition. -/
irreducible_def IsBigO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Prop

full_name: Asymptotics.IsBigO
code: /-- The Landau notation `f =O[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by a constant multiple of `‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded, modulo division by zero issues that are avoided
by this definition. -/
irreducible_def IsBigO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Prop

full_name: Asymptotics.IsBigO_def
code: /-- The Landau notation `f =O[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by a constant multiple of `‖g‖`.
In other words, `‖f‖ / ‖g‖` is eventually bounded, modulo division by zero issues that are avoided
by this definition. -/
irreducible_def IsBigO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: f =O[l] g = ∃ c, Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.«_aux_Mathlib_Analysis_Asymptotics_Asymptotics___macroRules_Asymptotics_term_=O[_]__1»
code: @[inherit_doc]
notation:100 f " =O[" l "] " g:100 => IsBigO l f g
goal: Lean.Macro

full_name: Asymptotics._aux_Mathlib_Analysis_Asymptotics_Asymptotics___unexpand_Asymptotics_IsBigO_1
code: @[inherit_doc]
notation:100 f " =O[" l "] " g:100 => IsBigO l f g
goal: Lean.PrettyPrinter.Unexpander

full_name: Asymptotics.isBigO_iff_isBigOWith
code: /-- Definition of `IsBigO` in terms of `IsBigOWith`. We record it in a lemma as `IsBigO` is
irreducible. -/
theorem isBigO_iff_isBigOWith : f =O[l] g ↔ ∃ c : ℝ, IsBigOWith c l f g 
goal: f =O[l] g ↔ ∃ c, Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.isBigO_iff
code: /-- Definition of `IsBigO` in terms of filters. -/
theorem isBigO_iff : f =O[l] g ↔ ∃ c : ℝ, ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖ 
goal: f =O[l] g ↔ ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.isBigO_iff'
code: /-- Definition of `IsBigO` in terms of filters, with a positive constant. -/
theorem isBigO_iff' {g : α → E'''} :
    f =O[l] g ↔ ∃ c > 0, ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖ 
goal: f =O[l] g ↔ ∃ c > 0, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.isBigO_iff''
code: /-- Definition of `IsBigO` in terms of filters, with the constant in the lower bound. -/
theorem isBigO_iff'' {g : α → E'''} :
    f =O[l] g ↔ ∃ c > 0, ∀ᶠ x in l, c * ‖f x‖ ≤ ‖g x‖ 
goal: f =O[l] g ↔ ∃ c > 0, ∀ᶠ (x : α) in l, c * ‖f x‖ ≤ ‖g x‖

full_name: Asymptotics.IsBigO.of_bound
code: theorem IsBigO.of_bound (c : ℝ) (h : ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsBigO.of_bound'
code: theorem IsBigO.of_bound' (h : ∀ᶠ x in l, ‖f x‖ ≤ ‖g x‖) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsBigO.bound
code: theorem IsBigO.bound : f =O[l] g → ∃ c : ℝ, ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖ 
goal: f =O[l] g → ∃ c, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.wrapped._@.Mathlib.Analysis.Asymptotics.Asymptotics._hyg.4192
code: /-- The Landau notation `f =o[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by an arbitrarily small constant
multiple of `‖g‖`. In other words, `‖f‖ / ‖g‖` tends to `0` along `l`, modulo division by zero
issues that are avoided by this definition. -/
irreducible_def IsLittleO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Subtype (Eq @Asymptotics.definition✝)

full_name: Asymptotics.IsLittleO
code: /-- The Landau notation `f =o[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by an arbitrarily small constant
multiple of `‖g‖`. In other words, `‖f‖ / ‖g‖` tends to `0` along `l`, modulo division by zero
issues that are avoided by this definition. -/
irreducible_def IsLittleO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Prop

full_name: Asymptotics.definition._@.Mathlib.Analysis.Asymptotics.Asymptotics._hyg.4192
code: /-- The Landau notation `f =o[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by an arbitrarily small constant
multiple of `‖g‖`. In other words, `‖f‖ / ‖g‖` tends to `0` along `l`, modulo division by zero
issues that are avoided by this definition. -/
irreducible_def IsLittleO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: Prop

full_name: Asymptotics.IsLittleO_def
code: /-- The Landau notation `f =o[l] g` where `f` and `g` are two functions on a type `α` and `l` is
a filter on `α`, means that eventually for `l`, `‖f‖` is bounded by an arbitrarily small constant
multiple of `‖g‖`. In other words, `‖f‖ / ‖g‖` tends to `0` along `l`, modulo division by zero
issues that are avoided by this definition. -/
irreducible_def IsLittleO (l : Filter α) (f : α → E) (g : α → F) : Prop 
goal: f =o[l] g = ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g

full_name: Asymptotics._aux_Mathlib_Analysis_Asymptotics_Asymptotics___unexpand_Asymptotics_IsLittleO_1
code: @[inherit_doc]
notation:100 f " =o[" l "] " g:100 => IsLittleO l f g
goal: Lean.PrettyPrinter.Unexpander

full_name: Asymptotics.«_aux_Mathlib_Analysis_Asymptotics_Asymptotics___macroRules_Asymptotics_term_=o[_]__1»
code: @[inherit_doc]
notation:100 f " =o[" l "] " g:100 => IsLittleO l f g
goal: Lean.Macro

full_name: Asymptotics.isLittleO_iff_forall_isBigOWith
code: /-- Definition of `IsLittleO` in terms of `IsBigOWith`. -/
theorem isLittleO_iff_forall_isBigOWith : f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f g 
goal: f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.isLittleO_iff
code: /-- Definition of `IsLittleO` in terms of filters. -/
theorem isLittleO_iff : f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖ 
goal: f =o[l] g ↔ ∀ ⦃c : ℝ⦄, 0 < c → ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.IsLittleO.def
code: theorem IsLittleO.def (h : f =o[l] g) (hc : 0 < c) : ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖ 
goal: ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.IsLittleO.def'
code: theorem IsLittleO.def' (h : f =o[l] g) (hc : 0 < c) : IsBigOWith c l f g 
goal: Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.IsLittleO.eventuallyLE
code: theorem IsLittleO.eventuallyLE (h : f =o[l] g) : ∀ᶠ x in l, ‖f x‖ ≤ ‖g x‖ 
goal: ∀ᶠ (x : α) in l, ‖f x‖ ≤ ‖g x‖

full_name: Asymptotics.IsBigOWith.isBigO
code: theorem IsBigOWith.isBigO (h : IsBigOWith c l f g) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsLittleO.isBigOWith
code: theorem IsLittleO.isBigOWith (hgf : f =o[l] g) : IsBigOWith 1 l f g 
goal: Asymptotics.IsBigOWith 1 l f g

full_name: Asymptotics.IsLittleO.isBigO
code: theorem IsLittleO.isBigO (hgf : f =o[l] g) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsBigO.isBigOWith
code: theorem IsBigO.isBigOWith : f =O[l] g → ∃ c : ℝ, IsBigOWith c l f g 
goal: f =O[l] g → ∃ c, Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.IsBigOWith.weaken
code: theorem IsBigOWith.weaken (h : IsBigOWith c l f g') (hc : c ≤ c') : IsBigOWith c' l f g' 
goal: Asymptotics.IsBigOWith c' l f g'

full_name: Asymptotics.IsBigOWith.exists_pos
code: theorem IsBigOWith.exists_pos (h : IsBigOWith c l f g') :
    ∃ c' > 0, IsBigOWith c' l f g' 
goal: ∃ c' > 0, Asymptotics.IsBigOWith c' l f g'

full_name: Asymptotics.IsBigO.exists_pos
code: theorem IsBigO.exists_pos (h : f =O[l] g') : ∃ c > 0, IsBigOWith c l f g' 
goal: ∃ c > 0, Asymptotics.IsBigOWith c l f g'

full_name: Asymptotics.IsBigOWith.exists_nonneg
code: theorem IsBigOWith.exists_nonneg (h : IsBigOWith c l f g') :
    ∃ c' ≥ 0, IsBigOWith c' l f g' 
goal: ∃ c' ≥ 0, Asymptotics.IsBigOWith c' l f g'

full_name: Asymptotics.IsBigO.exists_nonneg
code: theorem IsBigO.exists_nonneg (h : f =O[l] g') : ∃ c ≥ 0, IsBigOWith c l f g' 
goal: ∃ c ≥ 0, Asymptotics.IsBigOWith c l f g'

full_name: Asymptotics.isBigO_iff_eventually_isBigOWith
code: /-- `f = O(g)` if and only if `IsBigOWith c f g` for all sufficiently large `c`. -/
theorem isBigO_iff_eventually_isBigOWith : f =O[l] g' ↔ ∀ᶠ c in atTop, IsBigOWith c l f g' 
goal: f =O[l] g' ↔ ∀ᶠ (c : ℝ) in Filter.atTop, Asymptotics.IsBigOWith c l f g'

full_name: Asymptotics.isBigO_iff_eventually
code: /-- `f = O(g)` if and only if `∀ᶠ x in l, ‖f x‖ ≤ c * ‖g x‖` for all sufficiently large `c`. -/
theorem isBigO_iff_eventually : f =O[l] g' ↔ ∀ᶠ c in atTop, ∀ᶠ x in l, ‖f x‖ ≤ c * ‖g' x‖ 
goal: f =O[l] g' ↔ ∀ᶠ (c : ℝ) in Filter.atTop, ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g' x‖

full_name: Asymptotics.IsBigO.exists_mem_basis
code: theorem IsBigO.exists_mem_basis {ι} {p : ι → Prop} {s : ι → Set α} (h : f =O[l] g')
    (hb : l.HasBasis p s) :
    ∃ c > 0, ∃ i : ι, p i ∧ ∀ x ∈ s i, ‖f x‖ ≤ c * ‖g' x‖ 
goal: ∃ c > 0, ∃ i, p i ∧ ∀ x ∈ s i, ‖f x‖ ≤ c * ‖g' x‖

full_name: Asymptotics.isBigOWith_inv
code: theorem isBigOWith_inv (hc : 0 < c) : IsBigOWith c⁻¹ l f g ↔ ∀ᶠ x in l, c * ‖f x‖ ≤ ‖g x‖ 
goal: Asymptotics.IsBigOWith c⁻¹ l f g ↔ ∀ᶠ (x : α) in l, c * ‖f x‖ ≤ ‖g x‖

full_name: Asymptotics.isLittleO_iff_nat_mul_le_aux
code: theorem isLittleO_iff_nat_mul_le_aux (h₀ : (∀ x, 0 ≤ ‖f x‖) ∨ ∀ x, 0 ≤ ‖g x‖) :
    f =o[l] g ↔ ∀ n : ℕ, ∀ᶠ x in l, ↑n * ‖f x‖ ≤ ‖g x‖ 
goal: f =o[l] g ↔ ∀ (n : ℕ), ∀ᶠ (x : α) in l, ↑n * ‖f x‖ ≤ ‖g x‖

full_name: Asymptotics.isLittleO_iff_nat_mul_le
code: theorem isLittleO_iff_nat_mul_le : f =o[l] g' ↔ ∀ n : ℕ, ∀ᶠ x in l, ↑n * ‖f x‖ ≤ ‖g' x‖ 
goal: f =o[l] g' ↔ ∀ (n : ℕ), ∀ᶠ (x : α) in l, ↑n * ‖f x‖ ≤ ‖g' x‖

full_name: Asymptotics.isLittleO_iff_nat_mul_le'
code: theorem isLittleO_iff_nat_mul_le' : f' =o[l] g ↔ ∀ n : ℕ, ∀ᶠ x in l, ↑n * ‖f' x‖ ≤ ‖g x‖ 
goal: f' =o[l] g ↔ ∀ (n : ℕ), ∀ᶠ (x : α) in l, ↑n * ‖f' x‖ ≤ ‖g x‖

full_name: Asymptotics.isLittleO_of_subsingleton
code: @[nontriviality]
theorem isLittleO_of_subsingleton [Subsingleton E'] : f' =o[l] g' 
goal: f' =o[l] g'

full_name: Asymptotics.isBigO_of_subsingleton
code: @[nontriviality]
theorem isBigO_of_subsingleton [Subsingleton E'] : f' =O[l] g' 
goal: f' =O[l] g'

full_name: Asymptotics.isBigOWith_congr
code: theorem isBigOWith_congr (hc : c₁ = c₂) (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) :
    IsBigOWith c₁ l f₁ g₁ ↔ IsBigOWith c₂ l f₂ g₂ 
goal: Asymptotics.IsBigOWith c₁ l f₁ g₁ ↔ Asymptotics.IsBigOWith c₂ l f₂ g₂

full_name: Asymptotics.IsBigOWith.congr'
code: theorem IsBigOWith.congr' (h : IsBigOWith c₁ l f₁ g₁) (hc : c₁ = c₂) (hf : f₁ =ᶠ[l] f₂)
    (hg : g₁ =ᶠ[l] g₂) : IsBigOWith c₂ l f₂ g₂ 
goal: Asymptotics.IsBigOWith c₂ l f₂ g₂

full_name: Asymptotics.IsBigOWith.congr
code: theorem IsBigOWith.congr (h : IsBigOWith c₁ l f₁ g₁) (hc : c₁ = c₂) (hf : ∀ x, f₁ x = f₂ x)
    (hg : ∀ x, g₁ x = g₂ x) : IsBigOWith c₂ l f₂ g₂ 
goal: Asymptotics.IsBigOWith c₂ l f₂ g₂

full_name: Asymptotics.IsBigOWith.congr_left
code: theorem IsBigOWith.congr_left (h : IsBigOWith c l f₁ g) (hf : ∀ x, f₁ x = f₂ x) :
    IsBigOWith c l f₂ g 
goal: Asymptotics.IsBigOWith c l f₂ g

full_name: Asymptotics.IsBigOWith.congr_right
code: theorem IsBigOWith.congr_right (h : IsBigOWith c l f g₁) (hg : ∀ x, g₁ x = g₂ x) :
    IsBigOWith c l f g₂ 
goal: Asymptotics.IsBigOWith c l f g₂

full_name: Asymptotics.IsBigOWith.congr_const
code: theorem IsBigOWith.congr_const (h : IsBigOWith c₁ l f g) (hc : c₁ = c₂) : IsBigOWith c₂ l f g 
goal: Asymptotics.IsBigOWith c₂ l f g

full_name: Asymptotics.isBigO_congr
code: theorem isBigO_congr (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) : f₁ =O[l] g₁ ↔ f₂ =O[l] g₂ 
goal: f₁ =O[l] g₁ ↔ f₂ =O[l] g₂

full_name: Asymptotics.IsBigO.congr'
code: theorem IsBigO.congr' (h : f₁ =O[l] g₁) (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) : f₂ =O[l] g₂ 
goal: f₂ =O[l] g₂

full_name: Asymptotics.IsBigO.congr
code: theorem IsBigO.congr (h : f₁ =O[l] g₁) (hf : ∀ x, f₁ x = f₂ x) (hg : ∀ x, g₁ x = g₂ x) :
    f₂ =O[l] g₂ 
goal: f₂ =O[l] g₂

full_name: Asymptotics.IsBigO.congr_left
code: theorem IsBigO.congr_left (h : f₁ =O[l] g) (hf : ∀ x, f₁ x = f₂ x) : f₂ =O[l] g 
goal: f₂ =O[l] g

full_name: Asymptotics.IsBigO.congr_right
code: theorem IsBigO.congr_right (h : f =O[l] g₁) (hg : ∀ x, g₁ x = g₂ x) : f =O[l] g₂ 
goal: f =O[l] g₂

full_name: Asymptotics.isLittleO_congr
code: theorem isLittleO_congr (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) : f₁ =o[l] g₁ ↔ f₂ =o[l] g₂ 
goal: f₁ =o[l] g₁ ↔ f₂ =o[l] g₂

full_name: Asymptotics.IsLittleO.congr'
code: theorem IsLittleO.congr' (h : f₁ =o[l] g₁) (hf : f₁ =ᶠ[l] f₂) (hg : g₁ =ᶠ[l] g₂) : f₂ =o[l] g₂ 
goal: f₂ =o[l] g₂

full_name: Asymptotics.IsLittleO.congr
code: theorem IsLittleO.congr (h : f₁ =o[l] g₁) (hf : ∀ x, f₁ x = f₂ x) (hg : ∀ x, g₁ x = g₂ x) :
    f₂ =o[l] g₂ 
goal: f₂ =o[l] g₂

full_name: Asymptotics.IsLittleO.congr_left
code: theorem IsLittleO.congr_left (h : f₁ =o[l] g) (hf : ∀ x, f₁ x = f₂ x) : f₂ =o[l] g 
goal: f₂ =o[l] g

full_name: Asymptotics.IsLittleO.congr_right
code: theorem IsLittleO.congr_right (h : f =o[l] g₁) (hg : ∀ x, g₁ x = g₂ x) : f =o[l] g₂ 
goal: f =o[l] g₂

full_name: Filter.EventuallyEq.trans_isBigO
code: @[trans]
theorem _root_.Filter.EventuallyEq.trans_isBigO {f₁ f₂ : α → E} {g : α → F} (hf : f₁ =ᶠ[l] f₂)
    (h : f₂ =O[l] g) : f₁ =O[l] g 
goal: f₁ =O[l] g

full_name: Asymptotics.transEventuallyEqIsBigO
code: instance transEventuallyEqIsBigO :
    @Trans (α → E) (α → E) (α → F) (· =ᶠ[l] ·) (· =O[l] ·) (· =O[l] ·) 
goal: Trans (fun x x_1 => x =ᶠ[l] x_1) (fun x x_1 => x =O[l] x_1) fun x x_1 => x =O[l] x_1

full_name: Filter.EventuallyEq.trans_isLittleO
code: @[trans]
theorem _root_.Filter.EventuallyEq.trans_isLittleO {f₁ f₂ : α → E} {g : α → F} (hf : f₁ =ᶠ[l] f₂)
    (h : f₂ =o[l] g) : f₁ =o[l] g 
goal: f₁ =o[l] g

full_name: Asymptotics.transEventuallyEqIsLittleO
code: instance transEventuallyEqIsLittleO :
    @Trans (α → E) (α → E) (α → F) (· =ᶠ[l] ·) (· =o[l] ·) (· =o[l] ·) 
goal: Trans (fun x x_1 => x =ᶠ[l] x_1) (fun x x_1 => x =o[l] x_1) fun x x_1 => x =o[l] x_1

full_name: Asymptotics.IsBigO.trans_eventuallyEq
code: @[trans]
theorem IsBigO.trans_eventuallyEq {f : α → E} {g₁ g₂ : α → F} (h : f =O[l] g₁) (hg : g₁ =ᶠ[l] g₂) :
    f =O[l] g₂ 
goal: f =O[l] g₂

full_name: Asymptotics.transIsBigOEventuallyEq
code: instance transIsBigOEventuallyEq :
    @Trans (α → E) (α → F) (α → F) (· =O[l] ·) (· =ᶠ[l] ·) (· =O[l] ·) 
goal: Trans (fun x x_1 => x =O[l] x_1) (fun x x_1 => x =ᶠ[l] x_1) fun x x_1 => x =O[l] x_1

full_name: Asymptotics.IsLittleO.trans_eventuallyEq
code: @[trans]
theorem IsLittleO.trans_eventuallyEq {f : α → E} {g₁ g₂ : α → F} (h : f =o[l] g₁)
    (hg : g₁ =ᶠ[l] g₂) : f =o[l] g₂ 
goal: f =o[l] g₂

full_name: Asymptotics.transIsLittleOEventuallyEq
code: instance transIsLittleOEventuallyEq :
    @Trans (α → E) (α → F) (α → F) (· =o[l] ·) (· =ᶠ[l] ·) (· =o[l] ·) 
goal: Trans (fun x x_1 => x =o[l] x_1) (fun x x_1 => x =ᶠ[l] x_1) fun x x_1 => x =o[l] x_1

full_name: Asymptotics.IsBigOWith.comp_tendsto
code: theorem IsBigOWith.comp_tendsto (hcfg : IsBigOWith c l f g) {k : β → α} {l' : Filter β}
    (hk : Tendsto k l' l) : IsBigOWith c l' (f ∘ k) (g ∘ k) 
goal: Asymptotics.IsBigOWith c l' (f ∘ k) (g ∘ k)

full_name: Asymptotics.IsBigO.comp_tendsto
code: theorem IsBigO.comp_tendsto (hfg : f =O[l] g) {k : β → α} {l' : Filter β} (hk : Tendsto k l' l) :
    (f ∘ k) =O[l'] (g ∘ k) 
goal: (f ∘ k) =O[l'] (g ∘ k)

full_name: Asymptotics.IsLittleO.comp_tendsto
code: theorem IsLittleO.comp_tendsto (hfg : f =o[l] g) {k : β → α} {l' : Filter β} (hk : Tendsto k l' l) :
    (f ∘ k) =o[l'] (g ∘ k) 
goal: (f ∘ k) =o[l'] (g ∘ k)

full_name: Asymptotics.isBigOWith_map
code: @[simp]
theorem isBigOWith_map {k : β → α} {l : Filter β} :
    IsBigOWith c (map k l) f g ↔ IsBigOWith c l (f ∘ k) (g ∘ k) 
goal: Asymptotics.IsBigOWith c (Filter.map k l) f g ↔ Asymptotics.IsBigOWith c l (f ∘ k) (g ∘ k)

full_name: Asymptotics.isBigO_map
code: @[simp]
theorem isBigO_map {k : β → α} {l : Filter β} : f =O[map k l] g ↔ (f ∘ k) =O[l] (g ∘ k) 
goal: f =O[Filter.map k l] g ↔ (f ∘ k) =O[l] (g ∘ k)

full_name: Asymptotics.isLittleO_map
code: @[simp]
theorem isLittleO_map {k : β → α} {l : Filter β} : f =o[map k l] g ↔ (f ∘ k) =o[l] (g ∘ k) 
goal: f =o[Filter.map k l] g ↔ (f ∘ k) =o[l] (g ∘ k)

full_name: Asymptotics.IsBigOWith.mono
code: theorem IsBigOWith.mono (h : IsBigOWith c l' f g) (hl : l ≤ l') : IsBigOWith c l f g 
goal: Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.IsBigO.mono
code: theorem IsBigO.mono (h : f =O[l'] g) (hl : l ≤ l') : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsLittleO.mono
code: theorem IsLittleO.mono (h : f =o[l'] g) (hl : l ≤ l') : f =o[l] g 
goal: f =o[l] g

full_name: Asymptotics.IsBigOWith.trans
code: theorem IsBigOWith.trans (hfg : IsBigOWith c l f g) (hgk : IsBigOWith c' l g k) (hc : 0 ≤ c) :
    IsBigOWith (c * c') l f k 
goal: Asymptotics.IsBigOWith (c * c') l f k

full_name: Asymptotics.IsBigO.trans
code: @[trans]
theorem IsBigO.trans {f : α → E} {g : α → F'} {k : α → G} (hfg : f =O[l] g) (hgk : g =O[l] k) :
    f =O[l] k 
goal: f =O[l] k

full_name: Asymptotics.transIsBigOIsBigO
code: instance transIsBigOIsBigO :
    @Trans (α → E) (α → F') (α → G) (· =O[l] ·) (· =O[l] ·) (· =O[l] ·) 
goal: Trans (fun x x_1 => x =O[l] x_1) (fun x x_1 => x =O[l] x_1) fun x x_1 => x =O[l] x_1

full_name: Asymptotics.IsLittleO.trans_isBigOWith
code: theorem IsLittleO.trans_isBigOWith (hfg : f =o[l] g) (hgk : IsBigOWith c l g k) (hc : 0 < c) :
    f =o[l] k 
goal: f =o[l] k

full_name: Asymptotics.IsLittleO.trans_isBigO
code: @[trans]
theorem IsLittleO.trans_isBigO {f : α → E} {g : α → F} {k : α → G'} (hfg : f =o[l] g)
    (hgk : g =O[l] k) : f =o[l] k 
goal: f =o[l] k

full_name: Asymptotics.transIsLittleOIsBigO
code: instance transIsLittleOIsBigO :
    @Trans (α → E) (α → F) (α → G') (· =o[l] ·) (· =O[l] ·) (· =o[l] ·) 
goal: Trans (fun x x_1 => x =o[l] x_1) (fun x x_1 => x =O[l] x_1) fun x x_1 => x =o[l] x_1

full_name: Asymptotics.IsBigOWith.trans_isLittleO
code: theorem IsBigOWith.trans_isLittleO (hfg : IsBigOWith c l f g) (hgk : g =o[l] k) (hc : 0 < c) :
    f =o[l] k 
goal: f =o[l] k

full_name: Asymptotics.IsBigO.trans_isLittleO
code: @[trans]
theorem IsBigO.trans_isLittleO {f : α → E} {g : α → F'} {k : α → G} (hfg : f =O[l] g)
    (hgk : g =o[l] k) : f =o[l] k 
goal: f =o[l] k

full_name: Asymptotics.transIsBigOIsLittleO
code: instance transIsBigOIsLittleO :
    @Trans (α → E) (α → F') (α → G) (· =O[l] ·) (· =o[l] ·) (· =o[l] ·) 
goal: Trans (fun x x_1 => x =O[l] x_1) (fun x x_1 => x =o[l] x_1) fun x x_1 => x =o[l] x_1

full_name: Asymptotics.IsLittleO.trans
code: @[trans]
theorem IsLittleO.trans {f : α → E} {g : α → F} {k : α → G} (hfg : f =o[l] g) (hgk : g =o[l] k) :
    f =o[l] k 
goal: f =o[l] k

full_name: Asymptotics.transIsLittleOIsLittleO
code: instance transIsLittleOIsLittleO :
    @Trans (α → E) (α → F) (α → G) (· =o[l] ·) (· =o[l] ·) (· =o[l] ·) 
goal: Trans (fun x x_1 => x =o[l] x_1) (fun x x_1 => x =o[l] x_1) fun x x_1 => x =o[l] x_1

full_name: Filter.Eventually.trans_isBigO
code: theorem _root_.Filter.Eventually.trans_isBigO {f : α → E} {g : α → F'} {k : α → G}
    (hfg : ∀ᶠ x in l, ‖f x‖ ≤ ‖g x‖) (hgk : g =O[l] k) : f =O[l] k 
goal: f =O[l] k

full_name: Filter.Eventually.isBigO
code: theorem _root_.Filter.Eventually.isBigO {f : α → E} {g : α → ℝ} {l : Filter α}
    (hfg : ∀ᶠ x in l, ‖f x‖ ≤ g x) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.isBigOWith_of_le'
code: theorem isBigOWith_of_le' (hfg : ∀ x, ‖f x‖ ≤ c * ‖g x‖) : IsBigOWith c l f g 
goal: Asymptotics.IsBigOWith c l f g

full_name: Asymptotics.isBigOWith_of_le
code: theorem isBigOWith_of_le (hfg : ∀ x, ‖f x‖ ≤ ‖g x‖) : IsBigOWith 1 l f g 
goal: Asymptotics.IsBigOWith 1 l f g

full_name: Asymptotics.isBigO_of_le'
code: theorem isBigO_of_le' (hfg : ∀ x, ‖f x‖ ≤ c * ‖g x‖) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.isBigO_of_le
code: theorem isBigO_of_le (hfg : ∀ x, ‖f x‖ ≤ ‖g x‖) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.isBigOWith_refl
code: theorem isBigOWith_refl (f : α → E) (l : Filter α) : IsBigOWith 1 l f f 
goal: Asymptotics.IsBigOWith 1 l f f

full_name: Asymptotics.isBigO_refl
code: theorem isBigO_refl (f : α → E) (l : Filter α) : f =O[l] f 
goal: f =O[l] f

full_name: Filter.EventuallyEq.isBigO
code: theorem _root_.Filter.EventuallyEq.isBigO {f₁ f₂ : α → E} (hf : f₁ =ᶠ[l] f₂) : f₁ =O[l] f₂ 
goal: f₁ =O[l] f₂

full_name: Asymptotics.IsBigOWith.trans_le
code: theorem IsBigOWith.trans_le (hfg : IsBigOWith c l f g) (hgk : ∀ x, ‖g x‖ ≤ ‖k x‖) (hc : 0 ≤ c) :
    IsBigOWith c l f k 
goal: Asymptotics.IsBigOWith c l f k

full_name: Asymptotics.IsBigO.trans_le
code: theorem IsBigO.trans_le (hfg : f =O[l] g') (hgk : ∀ x, ‖g' x‖ ≤ ‖k x‖) : f =O[l] k 
goal: f =O[l] k

full_name: Asymptotics.IsLittleO.trans_le
code: theorem IsLittleO.trans_le (hfg : f =o[l] g) (hgk : ∀ x, ‖g x‖ ≤ ‖k x‖) : f =o[l] k 
goal: f =o[l] k

full_name: Asymptotics.isLittleO_irrefl'
code: theorem isLittleO_irrefl' (h : ∃ᶠ x in l, ‖f' x‖ ≠ 0) : ¬f' =o[l] f' 
goal: ¬f' =o[l] f'

full_name: Asymptotics.isLittleO_irrefl
code: theorem isLittleO_irrefl (h : ∃ᶠ x in l, f'' x ≠ 0) : ¬f'' =o[l] f'' 
goal: ¬f'' =o[l] f''

full_name: Asymptotics.IsBigO.not_isLittleO
code: theorem IsBigO.not_isLittleO (h : f'' =O[l] g') (hf : ∃ᶠ x in l, f'' x ≠ 0) :
    ¬g' =o[l] f'' 
goal: ¬g' =o[l] f''

full_name: Asymptotics.IsLittleO.not_isBigO
code: theorem IsLittleO.not_isBigO (h : f'' =o[l] g') (hf : ∃ᶠ x in l, f'' x ≠ 0) :
    ¬g' =O[l] f'' 
goal: ¬g' =O[l] f''

full_name: Asymptotics.isBigOWith_bot
code: @[simp]
theorem isBigOWith_bot : IsBigOWith c ⊥ f g 
goal: Asymptotics.IsBigOWith c ⊥ f g

full_name: Asymptotics.isBigO_bot
code: @[simp]
theorem isBigO_bot : f =O[⊥] g 
goal: f =O[⊥] g

full_name: Asymptotics.isLittleO_bot
code: @[simp]
theorem isLittleO_bot : f =o[⊥] g 
goal: f =o[⊥] g

full_name: Asymptotics.isBigOWith_pure
code: @[simp]
theorem isBigOWith_pure {x} : IsBigOWith c (pure x) f g ↔ ‖f x‖ ≤ c * ‖g x‖ 
goal: Asymptotics.IsBigOWith c (pure x) f g ↔ ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.IsBigOWith.sup
code: theorem IsBigOWith.sup (h : IsBigOWith c l f g) (h' : IsBigOWith c l' f g) :
    IsBigOWith c (l ⊔ l') f g 
goal: Asymptotics.IsBigOWith c (l ⊔ l') f g

full_name: Asymptotics.IsBigOWith.sup'
code: theorem IsBigOWith.sup' (h : IsBigOWith c l f g') (h' : IsBigOWith c' l' f g') :
    IsBigOWith (max c c') (l ⊔ l') f g' 
goal: Asymptotics.IsBigOWith (max c c') (l ⊔ l') f g'

full_name: Asymptotics.IsBigO.sup
code: theorem IsBigO.sup (h : f =O[l] g') (h' : f =O[l'] g') : f =O[l ⊔ l'] g' 
goal: f =O[l ⊔ l'] g'

full_name: Asymptotics.IsLittleO.sup
code: theorem IsLittleO.sup (h : f =o[l] g) (h' : f =o[l'] g) : f =o[l ⊔ l'] g 
goal: f =o[l ⊔ l'] g

full_name: Asymptotics.isBigO_sup
code: @[simp]
theorem isBigO_sup : f =O[l ⊔ l'] g' ↔ f =O[l] g' ∧ f =O[l'] g' 
goal: f =O[l ⊔ l'] g' ↔ f =O[l] g' ∧ f =O[l'] g'

full_name: Asymptotics.isLittleO_sup
code: @[simp]
theorem isLittleO_sup : f =o[l ⊔ l'] g ↔ f =o[l] g ∧ f =o[l'] g 
goal: f =o[l ⊔ l'] g ↔ f =o[l] g ∧ f =o[l'] g

full_name: Asymptotics.isBigOWith_insert
code: theorem isBigOWith_insert [TopologicalSpace α] {x : α} {s : Set α} {C : ℝ} {g : α → E} {g' : α → F}
    (h : ‖g x‖ ≤ C * ‖g' x‖) : IsBigOWith C (𝓝[insert x s] x) g g' ↔
    IsBigOWith C (𝓝[s] x) g g' 
goal: Asymptotics.IsBigOWith C (𝓝[insert x s] x) g g' ↔ Asymptotics.IsBigOWith C (𝓝[s] x) g g'

full_name: Asymptotics.IsBigOWith.insert
code: protected theorem IsBigOWith.insert [TopologicalSpace α] {x : α} {s : Set α} {C : ℝ} {g : α → E}
    {g' : α → F} (h1 : IsBigOWith C (𝓝[s] x) g g') (h2 : ‖g x‖ ≤ C * ‖g' x‖) :
    IsBigOWith C (𝓝[insert x s] x) g g' 
goal: Asymptotics.IsBigOWith C (𝓝[insert x s] x) g g'

full_name: Asymptotics.isLittleO_insert
code: theorem isLittleO_insert [TopologicalSpace α] {x : α} {s : Set α} {g : α → E'} {g' : α → F'}
    (h : g x = 0) : g =o[𝓝[insert x s] x] g' ↔ g =o[𝓝[s] x] g' 
goal: g =o[𝓝[insert x s] x] g' ↔ g =o[𝓝[s] x] g'

full_name: Asymptotics.IsLittleO.insert
code: protected theorem IsLittleO.insert [TopologicalSpace α] {x : α} {s : Set α} {g : α → E'}
    {g' : α → F'} (h1 : g =o[𝓝[s] x] g') (h2 : g x = 0) : g =o[𝓝[insert x s] x] g' 
goal: g =o[𝓝[insert x s] x] g'

full_name: Asymptotics.isBigOWith_norm_right
code: @[simp]
theorem isBigOWith_norm_right : (IsBigOWith c l f fun x => ‖g' x‖) ↔ IsBigOWith c l f g' 
goal: (Asymptotics.IsBigOWith c l f fun x => ‖g' x‖) ↔ Asymptotics.IsBigOWith c l f g'

full_name: Asymptotics.isBigOWith_abs_right
code: @[simp]
theorem isBigOWith_abs_right : (IsBigOWith c l f fun x => |u x|) ↔ IsBigOWith c l f u 
goal: (Asymptotics.IsBigOWith c l f fun x => |u x|) ↔ Asymptotics.IsBigOWith c l f u

full_name: Asymptotics.isBigO_norm_right
code: @[simp]
theorem isBigO_norm_right : (f =O[l] fun x => ‖g' x‖) ↔ f =O[l] g' 
goal: (f =O[l] fun x => ‖g' x‖) ↔ f =O[l] g'

full_name: Asymptotics.isBigO_abs_right
code: @[simp]
theorem isBigO_abs_right : (f =O[l] fun x => |u x|) ↔ f =O[l] u 
goal: (f =O[l] fun x => |u x|) ↔ f =O[l] u

full_name: Asymptotics.isLittleO_norm_right
code: @[simp]
theorem isLittleO_norm_right : (f =o[l] fun x => ‖g' x‖) ↔ f =o[l] g' 
goal: (f =o[l] fun x => ‖g' x‖) ↔ f =o[l] g'

full_name: Asymptotics.isLittleO_abs_right
code: @[simp]
theorem isLittleO_abs_right : (f =o[l] fun x => |u x|) ↔ f =o[l] u 
goal: (f =o[l] fun x => |u x|) ↔ f =o[l] u

full_name: Asymptotics.isBigOWith_norm_left
code: @[simp]
theorem isBigOWith_norm_left : IsBigOWith c l (fun x => ‖f' x‖) g ↔ IsBigOWith c l f' g 
goal: Asymptotics.IsBigOWith c l (fun x => ‖f' x‖) g ↔ Asymptotics.IsBigOWith c l f' g

full_name: Asymptotics.isBigOWith_abs_left
code: @[simp]
theorem isBigOWith_abs_left : IsBigOWith c l (fun x => |u x|) g ↔ IsBigOWith c l u g 
goal: Asymptotics.IsBigOWith c l (fun x => |u x|) g ↔ Asymptotics.IsBigOWith c l u g

full_name: Asymptotics.isBigO_norm_left
code: @[simp]
theorem isBigO_norm_left : (fun x => ‖f' x‖) =O[l] g ↔ f' =O[l] g 
goal: (fun x => ‖f' x‖) =O[l] g ↔ f' =O[l] g

full_name: Asymptotics.isBigO_abs_left
code: @[simp]
theorem isBigO_abs_left : (fun x => |u x|) =O[l] g ↔ u =O[l] g 
goal: (fun x => |u x|) =O[l] g ↔ u =O[l] g

full_name: Asymptotics.isLittleO_norm_left
code: @[simp]
theorem isLittleO_norm_left : (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g 
goal: (fun x => ‖f' x‖) =o[l] g ↔ f' =o[l] g

full_name: Asymptotics.isLittleO_abs_left
code: @[simp]
theorem isLittleO_abs_left : (fun x => |u x|) =o[l] g ↔ u =o[l] g 
goal: (fun x => |u x|) =o[l] g ↔ u =o[l] g

full_name: Asymptotics.isBigOWith_norm_norm
code: theorem isBigOWith_norm_norm :
    (IsBigOWith c l (fun x => ‖f' x‖) fun x => ‖g' x‖) ↔ IsBigOWith c l f' g' 
goal: (Asymptotics.IsBigOWith c l (fun x => ‖f' x‖) fun x => ‖g' x‖) ↔ Asymptotics.IsBigOWith c l f' g'

full_name: Asymptotics.isBigOWith_abs_abs
code: theorem isBigOWith_abs_abs :
    (IsBigOWith c l (fun x => |u x|) fun x => |v x|) ↔ IsBigOWith c l u v 
goal: (Asymptotics.IsBigOWith c l (fun x => |u x|) fun x => |v x|) ↔ Asymptotics.IsBigOWith c l u v

full_name: Asymptotics.isBigO_norm_norm
code: theorem isBigO_norm_norm : ((fun x => ‖f' x‖) =O[l] fun x => ‖g' x‖) ↔ f' =O[l] g' 
goal: ((fun x => ‖f' x‖) =O[l] fun x => ‖g' x‖) ↔ f' =O[l] g'

full_name: Asymptotics.isBigO_abs_abs
code: theorem isBigO_abs_abs : ((fun x => |u x|) =O[l] fun x => |v x|) ↔ u =O[l] v 
goal: ((fun x => |u x|) =O[l] fun x => |v x|) ↔ u =O[l] v

full_name: Asymptotics.isLittleO_norm_norm
code: theorem isLittleO_norm_norm : ((fun x => ‖f' x‖) =o[l] fun x => ‖g' x‖) ↔ f' =o[l] g' 
goal: ((fun x => ‖f' x‖) =o[l] fun x => ‖g' x‖) ↔ f' =o[l] g'

full_name: Asymptotics.isLittleO_abs_abs
code: theorem isLittleO_abs_abs : ((fun x => |u x|) =o[l] fun x => |v x|) ↔ u =o[l] v 
goal: ((fun x => |u x|) =o[l] fun x => |v x|) ↔ u =o[l] v

full_name: Asymptotics.isBigOWith_neg_right
code: @[simp]
theorem isBigOWith_neg_right : (IsBigOWith c l f fun x => -g' x) ↔ IsBigOWith c l f g' 
goal: (Asymptotics.IsBigOWith c l f fun x => -g' x) ↔ Asymptotics.IsBigOWith c l f g'

full_name: Asymptotics.isBigO_neg_right
code: @[simp]
theorem isBigO_neg_right : (f =O[l] fun x => -g' x) ↔ f =O[l] g' 
goal: (f =O[l] fun x => -g' x) ↔ f =O[l] g'

full_name: Asymptotics.isLittleO_neg_right
code: @[simp]
theorem isLittleO_neg_right : (f =o[l] fun x => -g' x) ↔ f =o[l] g' 
goal: (f =o[l] fun x => -g' x) ↔ f =o[l] g'

full_name: Asymptotics.isBigOWith_neg_left
code: @[simp]
theorem isBigOWith_neg_left : IsBigOWith c l (fun x => -f' x) g ↔ IsBigOWith c l f' g 
goal: Asymptotics.IsBigOWith c l (fun x => -f' x) g ↔ Asymptotics.IsBigOWith c l f' g

full_name: Asymptotics.isBigO_neg_left
code: @[simp]
theorem isBigO_neg_left : (fun x => -f' x) =O[l] g ↔ f' =O[l] g 
goal: (fun x => -f' x) =O[l] g ↔ f' =O[l] g

full_name: Asymptotics.isLittleO_neg_left
code: @[simp]
theorem isLittleO_neg_left : (fun x => -f' x) =o[l] g ↔ f' =o[l] g 
goal: (fun x => -f' x) =o[l] g ↔ f' =o[l] g

full_name: Asymptotics.isBigOWith_fst_prod
code: theorem isBigOWith_fst_prod : IsBigOWith 1 l f' fun x => (f' x, g' x) 
goal: Asymptotics.IsBigOWith 1 l f' fun x => (f' x, g' x)

full_name: Asymptotics.isBigOWith_snd_prod
code: theorem isBigOWith_snd_prod : IsBigOWith 1 l g' fun x => (f' x, g' x) 
goal: Asymptotics.IsBigOWith 1 l g' fun x => (f' x, g' x)

full_name: Asymptotics.isBigO_fst_prod
code: theorem isBigO_fst_prod : f' =O[l] fun x => (f' x, g' x) 
goal: f' =O[l] fun x => (f' x, g' x)

full_name: Asymptotics.isBigO_snd_prod
code: theorem isBigO_snd_prod : g' =O[l] fun x => (f' x, g' x) 
goal: g' =O[l] fun x => (f' x, g' x)

full_name: Asymptotics.isBigO_fst_prod'
code: theorem isBigO_fst_prod' {f' : α → E' × F'} : (fun x => (f' x).1) =O[l] f' 
goal: (fun x => (f' x).1) =O[l] f'

full_name: Asymptotics.isBigO_snd_prod'
code: theorem isBigO_snd_prod' {f' : α → E' × F'} : (fun x => (f' x).2) =O[l] f' 
goal: (fun x => (f' x).2) =O[l] f'

full_name: Asymptotics.IsBigOWith.prod_rightl
code: theorem IsBigOWith.prod_rightl (h : IsBigOWith c l f g') (hc : 0 ≤ c) :
    IsBigOWith c l f fun x => (g' x, k' x) 
goal: Asymptotics.IsBigOWith c l f fun x => (g' x, k' x)

full_name: Asymptotics.IsBigO.prod_rightl
code: theorem IsBigO.prod_rightl (h : f =O[l] g') : f =O[l] fun x => (g' x, k' x) 
goal: f =O[l] fun x => (g' x, k' x)

full_name: Asymptotics.IsLittleO.prod_rightl
code: theorem IsLittleO.prod_rightl (h : f =o[l] g') : f =o[l] fun x => (g' x, k' x) 
goal: f =o[l] fun x => (g' x, k' x)

full_name: Asymptotics.IsBigOWith.prod_rightr
code: theorem IsBigOWith.prod_rightr (h : IsBigOWith c l f g') (hc : 0 ≤ c) :
    IsBigOWith c l f fun x => (f' x, g' x) 
goal: Asymptotics.IsBigOWith c l f fun x => (f' x, g' x)

full_name: Asymptotics.IsBigO.prod_rightr
code: theorem IsBigO.prod_rightr (h : f =O[l] g') : f =O[l] fun x => (f' x, g' x) 
goal: f =O[l] fun x => (f' x, g' x)

full_name: Asymptotics.IsLittleO.prod_rightr
code: theorem IsLittleO.prod_rightr (h : f =o[l] g') : f =o[l] fun x => (f' x, g' x) 
goal: f =o[l] fun x => (f' x, g' x)

full_name: Asymptotics.IsBigOWith.prod_left_same
code: theorem IsBigOWith.prod_left_same (hf : IsBigOWith c l f' k') (hg : IsBigOWith c l g' k') :
    IsBigOWith c l (fun x => (f' x, g' x)) k' 
goal: Asymptotics.IsBigOWith c l (fun x => (f' x, g' x)) k'

full_name: Asymptotics.IsBigOWith.prod_left
code: theorem IsBigOWith.prod_left (hf : IsBigOWith c l f' k') (hg : IsBigOWith c' l g' k') :
    IsBigOWith (max c c') l (fun x => (f' x, g' x)) k' 
goal: Asymptotics.IsBigOWith (max c c') l (fun x => (f' x, g' x)) k'

full_name: Asymptotics.IsBigOWith.prod_left_fst
code: theorem IsBigOWith.prod_left_fst (h : IsBigOWith c l (fun x => (f' x, g' x)) k') :
    IsBigOWith c l f' k' 
goal: Asymptotics.IsBigOWith c l f' k'

full_name: Asymptotics.IsBigOWith.prod_left_snd
code: theorem IsBigOWith.prod_left_snd (h : IsBigOWith c l (fun x => (f' x, g' x)) k') :
    IsBigOWith c l g' k' 
goal: Asymptotics.IsBigOWith c l g' k'

full_name: Asymptotics.isBigOWith_prod_left
code: theorem isBigOWith_prod_left :
    IsBigOWith c l (fun x => (f' x, g' x)) k' ↔ IsBigOWith c l f' k' ∧ IsBigOWith c l g' k' 
goal: Asymptotics.IsBigOWith c l (fun x => (f' x, g' x)) k' ↔
  Asymptotics.IsBigOWith c l f' k' ∧ Asymptotics.IsBigOWith c l g' k'

full_name: Asymptotics.IsBigO.prod_left
code: theorem IsBigO.prod_left (hf : f' =O[l] k') (hg : g' =O[l] k') : (fun x => (f' x, g' x)) =O[l] k' 
goal: (fun x => (f' x, g' x)) =O[l] k'

full_name: Asymptotics.IsBigO.prod_left_fst
code: theorem IsBigO.prod_left_fst : (fun x => (f' x, g' x)) =O[l] k' → f' =O[l] k' 
goal: (fun x => (f' x, g' x)) =O[l] k' → f' =O[l] k'

full_name: Asymptotics.IsBigO.prod_left_snd
code: theorem IsBigO.prod_left_snd : (fun x => (f' x, g' x)) =O[l] k' → g' =O[l] k' 
goal: (fun x => (f' x, g' x)) =O[l] k' → g' =O[l] k'

full_name: Asymptotics.isBigO_prod_left
code: @[simp]
theorem isBigO_prod_left : (fun x => (f' x, g' x)) =O[l] k' ↔ f' =O[l] k' ∧ g' =O[l] k' 
goal: (fun x => (f' x, g' x)) =O[l] k' ↔ f' =O[l] k' ∧ g' =O[l] k'

full_name: Asymptotics.IsLittleO.prod_left
code: theorem IsLittleO.prod_left (hf : f' =o[l] k') (hg : g' =o[l] k') :
    (fun x => (f' x, g' x)) =o[l] k' 
goal: (fun x => (f' x, g' x)) =o[l] k'

full_name: Asymptotics.IsLittleO.prod_left_fst
code: theorem IsLittleO.prod_left_fst : (fun x => (f' x, g' x)) =o[l] k' → f' =o[l] k' 
goal: (fun x => (f' x, g' x)) =o[l] k' → f' =o[l] k'

full_name: Asymptotics.IsLittleO.prod_left_snd
code: theorem IsLittleO.prod_left_snd : (fun x => (f' x, g' x)) =o[l] k' → g' =o[l] k' 
goal: (fun x => (f' x, g' x)) =o[l] k' → g' =o[l] k'

full_name: Asymptotics.isLittleO_prod_left
code: @[simp]
theorem isLittleO_prod_left : (fun x => (f' x, g' x)) =o[l] k' ↔ f' =o[l] k' ∧ g' =o[l] k' 
goal: (fun x => (f' x, g' x)) =o[l] k' ↔ f' =o[l] k' ∧ g' =o[l] k'

full_name: Asymptotics.IsBigOWith.eq_zero_imp
code: theorem IsBigOWith.eq_zero_imp (h : IsBigOWith c l f'' g'') : ∀ᶠ x in l, g'' x = 0 → f'' x = 0 
goal: ∀ᶠ (x : α) in l, g'' x = 0 → f'' x = 0

full_name: Asymptotics.IsBigO.eq_zero_imp
code: theorem IsBigO.eq_zero_imp (h : f'' =O[l] g'') : ∀ᶠ x in l, g'' x = 0 → f'' x = 0 
goal: ∀ᶠ (x : α) in l, g'' x = 0 → f'' x = 0

full_name: Asymptotics.IsBigOWith.add
code: theorem IsBigOWith.add (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : IsBigOWith c₂ l f₂ g) :
    IsBigOWith (c₁ + c₂) l (fun x => f₁ x + f₂ x) g 
goal: Asymptotics.IsBigOWith (c₁ + c₂) l (fun x => f₁ x + f₂ x) g

full_name: Asymptotics.IsBigO.add
code: theorem IsBigO.add (h₁ : f₁ =O[l] g) (h₂ : f₂ =O[l] g) : (fun x => f₁ x + f₂ x) =O[l] g 
goal: (fun x => f₁ x + f₂ x) =O[l] g

full_name: Asymptotics.IsLittleO.add
code: theorem IsLittleO.add (h₁ : f₁ =o[l] g) (h₂ : f₂ =o[l] g) : (fun x => f₁ x + f₂ x) =o[l] g 
goal: (fun x => f₁ x + f₂ x) =o[l] g

full_name: Asymptotics.IsLittleO.add_add
code: theorem IsLittleO.add_add (h₁ : f₁ =o[l] g₁) (h₂ : f₂ =o[l] g₂) :
    (fun x => f₁ x + f₂ x) =o[l] fun x => ‖g₁ x‖ + ‖g₂ x‖ 
goal: (fun x => f₁ x + f₂ x) =o[l] fun x => ‖g₁ x‖ + ‖g₂ x‖

full_name: Asymptotics.IsBigO.add_isLittleO
code: theorem IsBigO.add_isLittleO (h₁ : f₁ =O[l] g) (h₂ : f₂ =o[l] g) : (fun x => f₁ x + f₂ x) =O[l] g 
goal: (fun x => f₁ x + f₂ x) =O[l] g

full_name: Asymptotics.IsLittleO.add_isBigO
code: theorem IsLittleO.add_isBigO (h₁ : f₁ =o[l] g) (h₂ : f₂ =O[l] g) : (fun x => f₁ x + f₂ x) =O[l] g 
goal: (fun x => f₁ x + f₂ x) =O[l] g

full_name: Asymptotics.IsBigOWith.add_isLittleO
code: theorem IsBigOWith.add_isLittleO (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : f₂ =o[l] g) (hc : c₁ < c₂) :
    IsBigOWith c₂ l (fun x => f₁ x + f₂ x) g 
goal: Asymptotics.IsBigOWith c₂ l (fun x => f₁ x + f₂ x) g

full_name: Asymptotics.IsLittleO.add_isBigOWith
code: theorem IsLittleO.add_isBigOWith (h₁ : f₁ =o[l] g) (h₂ : IsBigOWith c₁ l f₂ g) (hc : c₁ < c₂) :
    IsBigOWith c₂ l (fun x => f₁ x + f₂ x) g 
goal: Asymptotics.IsBigOWith c₂ l (fun x => f₁ x + f₂ x) g

full_name: Asymptotics.IsBigOWith.sub
code: theorem IsBigOWith.sub (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : IsBigOWith c₂ l f₂ g) :
    IsBigOWith (c₁ + c₂) l (fun x => f₁ x - f₂ x) g 
goal: Asymptotics.IsBigOWith (c₁ + c₂) l (fun x => f₁ x - f₂ x) g

full_name: Asymptotics.IsBigOWith.sub_isLittleO
code: theorem IsBigOWith.sub_isLittleO (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : f₂ =o[l] g) (hc : c₁ < c₂) :
    IsBigOWith c₂ l (fun x => f₁ x - f₂ x) g 
goal: Asymptotics.IsBigOWith c₂ l (fun x => f₁ x - f₂ x) g

full_name: Asymptotics.IsBigO.sub
code: theorem IsBigO.sub (h₁ : f₁ =O[l] g) (h₂ : f₂ =O[l] g) : (fun x => f₁ x - f₂ x) =O[l] g 
goal: (fun x => f₁ x - f₂ x) =O[l] g

full_name: Asymptotics.IsLittleO.sub
code: theorem IsLittleO.sub (h₁ : f₁ =o[l] g) (h₂ : f₂ =o[l] g) : (fun x => f₁ x - f₂ x) =o[l] g 
goal: (fun x => f₁ x - f₂ x) =o[l] g

full_name: Asymptotics.IsBigOWith.symm
code: theorem IsBigOWith.symm (h : IsBigOWith c l (fun x => f₁ x - f₂ x) g) :
    IsBigOWith c l (fun x => f₂ x - f₁ x) g 
goal: Asymptotics.IsBigOWith c l (fun x => f₂ x - f₁ x) g

full_name: Asymptotics.isBigOWith_comm
code: theorem isBigOWith_comm :
    IsBigOWith c l (fun x => f₁ x - f₂ x) g ↔ IsBigOWith c l (fun x => f₂ x - f₁ x) g 
goal: Asymptotics.IsBigOWith c l (fun x => f₁ x - f₂ x) g ↔ Asymptotics.IsBigOWith c l (fun x => f₂ x - f₁ x) g

full_name: Asymptotics.IsBigO.symm
code: theorem IsBigO.symm (h : (fun x => f₁ x - f₂ x) =O[l] g) : (fun x => f₂ x - f₁ x) =O[l] g 
goal: (fun x => f₂ x - f₁ x) =O[l] g

full_name: Asymptotics.isBigO_comm
code: theorem isBigO_comm : (fun x => f₁ x - f₂ x) =O[l] g ↔ (fun x => f₂ x - f₁ x) =O[l] g 
goal: (fun x => f₁ x - f₂ x) =O[l] g ↔ (fun x => f₂ x - f₁ x) =O[l] g

full_name: Asymptotics.IsLittleO.symm
code: theorem IsLittleO.symm (h : (fun x => f₁ x - f₂ x) =o[l] g) : (fun x => f₂ x - f₁ x) =o[l] g 
goal: (fun x => f₂ x - f₁ x) =o[l] g

full_name: Asymptotics.isLittleO_comm
code: theorem isLittleO_comm : (fun x => f₁ x - f₂ x) =o[l] g ↔ (fun x => f₂ x - f₁ x) =o[l] g 
goal: (fun x => f₁ x - f₂ x) =o[l] g ↔ (fun x => f₂ x - f₁ x) =o[l] g

full_name: Asymptotics.IsBigOWith.triangle
code: theorem IsBigOWith.triangle (h₁ : IsBigOWith c l (fun x => f₁ x - f₂ x) g)
    (h₂ : IsBigOWith c' l (fun x => f₂ x - f₃ x) g) :
    IsBigOWith (c + c') l (fun x => f₁ x - f₃ x) g 
goal: Asymptotics.IsBigOWith (c + c') l (fun x => f₁ x - f₃ x) g

full_name: Asymptotics.IsBigO.triangle
code: theorem IsBigO.triangle (h₁ : (fun x => f₁ x - f₂ x) =O[l] g)
    (h₂ : (fun x => f₂ x - f₃ x) =O[l] g) : (fun x => f₁ x - f₃ x) =O[l] g 
goal: (fun x => f₁ x - f₃ x) =O[l] g

full_name: Asymptotics.IsLittleO.triangle
code: theorem IsLittleO.triangle (h₁ : (fun x => f₁ x - f₂ x) =o[l] g)
    (h₂ : (fun x => f₂ x - f₃ x) =o[l] g) : (fun x => f₁ x - f₃ x) =o[l] g 
goal: (fun x => f₁ x - f₃ x) =o[l] g

full_name: Asymptotics.IsBigO.congr_of_sub
code: theorem IsBigO.congr_of_sub (h : (fun x => f₁ x - f₂ x) =O[l] g) : f₁ =O[l] g ↔ f₂ =O[l] g 
goal: f₁ =O[l] g ↔ f₂ =O[l] g

full_name: Asymptotics.IsLittleO.congr_of_sub
code: theorem IsLittleO.congr_of_sub (h : (fun x => f₁ x - f₂ x) =o[l] g) : f₁ =o[l] g ↔ f₂ =o[l] g 
goal: f₁ =o[l] g ↔ f₂ =o[l] g

full_name: Asymptotics.isLittleO_zero
code: theorem isLittleO_zero : (fun _x => (0 : E')) =o[l] g' 
goal: (fun _x => 0) =o[l] g'

full_name: Asymptotics.isBigOWith_zero
code: theorem isBigOWith_zero (hc : 0 ≤ c) : IsBigOWith c l (fun _x => (0 : E')) g' 
goal: Asymptotics.IsBigOWith c l (fun _x => 0) g'

full_name: Asymptotics.isBigOWith_zero'
code: theorem isBigOWith_zero' : IsBigOWith 0 l (fun _x => (0 : E')) g 
goal: Asymptotics.IsBigOWith 0 l (fun _x => 0) g

full_name: Asymptotics.isBigO_zero
code: theorem isBigO_zero : (fun _x => (0 : E')) =O[l] g 
goal: (fun _x => 0) =O[l] g

full_name: Asymptotics.isBigO_refl_left
code: theorem isBigO_refl_left : (fun x => f' x - f' x) =O[l] g' 
goal: (fun x => f' x - f' x) =O[l] g'

full_name: Asymptotics.isLittleO_refl_left
code: theorem isLittleO_refl_left : (fun x => f' x - f' x) =o[l] g' 
goal: (fun x => f' x - f' x) =o[l] g'

full_name: Asymptotics.isBigOWith_zero_right_iff
code: @[simp]
theorem isBigOWith_zero_right_iff : (IsBigOWith c l f'' fun _x => (0 : F')) ↔ f'' =ᶠ[l] 0 
goal: (Asymptotics.IsBigOWith c l f'' fun _x => 0) ↔ f'' =ᶠ[l] 0

full_name: Asymptotics.isBigO_zero_right_iff
code: @[simp]
theorem isBigO_zero_right_iff : (f'' =O[l] fun _x => (0 : F')) ↔ f'' =ᶠ[l] 0 
goal: (f'' =O[l] fun _x => 0) ↔ f'' =ᶠ[l] 0

full_name: Asymptotics.isLittleO_zero_right_iff
code: @[simp]
theorem isLittleO_zero_right_iff : (f'' =o[l] fun _x => (0 : F')) ↔ f'' =ᶠ[l] 0 
goal: (f'' =o[l] fun _x => 0) ↔ f'' =ᶠ[l] 0

full_name: Asymptotics.isBigOWith_const_const
code: theorem isBigOWith_const_const (c : E) {c' : F''} (hc' : c' ≠ 0) (l : Filter α) :
    IsBigOWith (‖c‖ / ‖c'‖) l (fun _x : α => c) fun _x => c' 
goal: Asymptotics.IsBigOWith (‖c‖ / ‖c'‖) l (fun _x => c) fun _x => c'

full_name: Asymptotics.isBigO_const_const
code: theorem isBigO_const_const (c : E) {c' : F''} (hc' : c' ≠ 0) (l : Filter α) :
    (fun _x : α => c) =O[l] fun _x => c' 
goal: (fun _x => c) =O[l] fun _x => c'

full_name: Asymptotics.isBigO_const_const_iff
code: @[simp]
theorem isBigO_const_const_iff {c : E''} {c' : F''} (l : Filter α) [l.NeBot] :
    ((fun _x : α => c) =O[l] fun _x => c') ↔ c' = 0 → c = 0 
goal: ((fun _x => c) =O[l] fun _x => c') ↔ c' = 0 → c = 0

full_name: Asymptotics.isBigO_pure
code: @[simp]
theorem isBigO_pure {x} : f'' =O[pure x] g'' ↔ g'' x = 0 → f'' x = 0 
goal: f'' =O[pure x] g'' ↔ g'' x = 0 → f'' x = 0

full_name: Asymptotics.isBigOWith_principal
code: @[simp]
theorem isBigOWith_principal {s : Set α} : IsBigOWith c (𝓟 s) f g ↔ ∀ x ∈ s, ‖f x‖ ≤ c * ‖g x‖ 
goal: Asymptotics.IsBigOWith c (𝓟 s) f g ↔ ∀ x ∈ s, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.isBigO_principal
code: theorem isBigO_principal {s : Set α} : f =O[𝓟 s] g ↔ ∃ c, ∀ x ∈ s, ‖f x‖ ≤ c * ‖g x‖ 
goal: f =O[𝓟 s] g ↔ ∃ c, ∀ x ∈ s, ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.isLittleO_principal
code: @[simp]
theorem isLittleO_principal {s : Set α} : f'' =o[𝓟 s] g' ↔ ∀ x ∈ s, f'' x = 0 
goal: f'' =o[𝓟 s] g' ↔ ∀ x ∈ s, f'' x = 0

full_name: Asymptotics.isBigOWith_top
code: @[simp]
theorem isBigOWith_top : IsBigOWith c ⊤ f g ↔ ∀ x, ‖f x‖ ≤ c * ‖g x‖ 
goal: Asymptotics.IsBigOWith c ⊤ f g ↔ ∀ (x : α), ‖f x‖ ≤ c * ‖g x‖

full_name: Asymptotics.isBigO_top
code: @[simp]
theorem isBigO_top : f =O[⊤] g ↔ ∃ C, ∀ x, ‖f x‖ ≤ C * ‖g x‖ 
goal: f =O[⊤] g ↔ ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖

full_name: Asymptotics.isLittleO_top
code: @[simp]
theorem isLittleO_top : f'' =o[⊤] g' ↔ ∀ x, f'' x = 0 
goal: f'' =o[⊤] g' ↔ ∀ (x : α), f'' x = 0

full_name: Asymptotics.isBigOWith_const_one
code: theorem isBigOWith_const_one (c : E) (l : Filter α) :
    IsBigOWith ‖c‖ l (fun _x : α => c) fun _x => (1 : F) 
goal: Asymptotics.IsBigOWith ‖c‖ l (fun _x => c) fun _x => 1

full_name: Asymptotics.isBigO_const_one
code: theorem isBigO_const_one (c : E) (l : Filter α) : (fun _x : α => c) =O[l] fun _x => (1 : F) 
goal: (fun _x => c) =O[l] fun _x => 1

full_name: Asymptotics.isLittleO_const_iff_isLittleO_one
code: theorem isLittleO_const_iff_isLittleO_one {c : F''} (hc : c ≠ 0) :
    (f =o[l] fun _x => c) ↔ f =o[l] fun _x => (1 : F) 
goal: (f =o[l] fun _x => c) ↔ f =o[l] fun _x => 1

full_name: Asymptotics.isLittleO_one_iff
code: @[simp]
theorem isLittleO_one_iff : f' =o[l] (fun _x => 1 : α → F) ↔ Tendsto f' l (𝓝 0) 
goal: (f' =o[l] fun _x => 1) ↔ Filter.Tendsto f' l (𝓝 0)

full_name: Asymptotics.isBigO_one_iff
code: @[simp]
theorem isBigO_one_iff : f =O[l] (fun _x => 1 : α → F) ↔
    IsBoundedUnder (· ≤ ·) l fun x => ‖f x‖ 
goal: (f =O[l] fun _x => 1) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖

full_name: Asymptotics.isLittleO_one_left_iff
code: @[simp]
theorem isLittleO_one_left_iff : (fun _x => 1 : α → F) =o[l] f ↔ Tendsto (fun x => ‖f x‖) l atTop 
goal: (fun _x => 1) =o[l] f ↔ Filter.Tendsto (fun x => ‖f x‖) l Filter.atTop

full_name: Filter.Tendsto.isBigO_one
code: theorem _root_.Filter.Tendsto.isBigO_one {c : E'} (h : Tendsto f' l (𝓝 c)) :
    f' =O[l] (fun _x => 1 : α → F) 
goal: f' =O[l] fun _x => 1

full_name: Asymptotics.IsBigO.trans_tendsto_nhds
code: theorem IsBigO.trans_tendsto_nhds (hfg : f =O[l] g') {y : F'} (hg : Tendsto g' l (𝓝 y)) :
    f =O[l] (fun _x => 1 : α → F) 
goal: f =O[l] fun _x => 1

full_name: Asymptotics.isBigO_one_nhds_ne_iff
code: /-- The condition `f = O[𝓝[≠] a] 1` is equivalent to `f = O[𝓝 a] 1`. -/
lemma isBigO_one_nhds_ne_iff [TopologicalSpace α] {a : α} :
    f =O[𝓝[≠] a] (fun _ ↦ 1 : α → F) ↔ f =O[𝓝 a] (fun _ ↦ 1 : α → F) 
goal: (f =O[𝓝[≠] a] fun x => 1) ↔ f =O[𝓝 a] fun x => 1

full_name: Asymptotics.isLittleO_const_iff
code: theorem isLittleO_const_iff {c : F''} (hc : c ≠ 0) :
    (f'' =o[l] fun _x => c) ↔ Tendsto f'' l (𝓝 0) 
goal: (f'' =o[l] fun _x => c) ↔ Filter.Tendsto f'' l (𝓝 0)

full_name: Asymptotics.isLittleO_id_const
code: theorem isLittleO_id_const {c : F''} (hc : c ≠ 0) : (fun x : E'' => x) =o[𝓝 0] fun _x => c 
goal: (fun x => x) =o[𝓝 0] fun _x => c

full_name: Filter.IsBoundedUnder.isBigO_const
code: theorem _root_.Filter.IsBoundedUnder.isBigO_const (h : IsBoundedUnder (· ≤ ·) l (norm ∘ f))
    {c : F''} (hc : c ≠ 0) : f =O[l] fun _x => c 
goal: f =O[l] fun _x => c

full_name: Asymptotics.isBigO_const_of_tendsto
code: theorem isBigO_const_of_tendsto {y : E''} (h : Tendsto f'' l (𝓝 y)) {c : F''} (hc : c ≠ 0) :
    f'' =O[l] fun _x => c 
goal: f'' =O[l] fun _x => c

full_name: Asymptotics.IsBigO.isBoundedUnder_le
code: theorem IsBigO.isBoundedUnder_le {c : F} (h : f =O[l] fun _x => c) :
    IsBoundedUnder (· ≤ ·) l (norm ∘ f) 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ f)

full_name: Asymptotics.isBigO_const_of_ne
code: theorem isBigO_const_of_ne {c : F''} (hc : c ≠ 0) :
    (f =O[l] fun _x => c) ↔ IsBoundedUnder (· ≤ ·) l (norm ∘ f) 
goal: (f =O[l] fun _x => c) ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ f)

full_name: Asymptotics.isBigO_const_iff
code: theorem isBigO_const_iff {c : F''} : (f'' =O[l] fun _x => c) ↔
    (c = 0 → f'' =ᶠ[l] 0) ∧ IsBoundedUnder (· ≤ ·) l fun x => ‖f'' x‖ 
goal: (f'' =O[l] fun _x => c) ↔ (c = 0 → f'' =ᶠ[l] 0) ∧ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f'' x‖

full_name: Asymptotics.isBigO_iff_isBoundedUnder_le_div
code: theorem isBigO_iff_isBoundedUnder_le_div (h : ∀ᶠ x in l, g'' x ≠ 0) :
    f =O[l] g'' ↔ IsBoundedUnder (· ≤ ·) l fun x => ‖f x‖ / ‖g'' x‖ 
goal: f =O[l] g'' ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x‖ / ‖g'' x‖

full_name: Asymptotics.isBigO_const_left_iff_pos_le_norm
code: /-- `(fun x ↦ c) =O[l] f` if and only if `f` is bounded away from zero. -/
theorem isBigO_const_left_iff_pos_le_norm {c : E''} (hc : c ≠ 0) :
    (fun _x => c) =O[l] f' ↔ ∃ b, 0 < b ∧ ∀ᶠ x in l, b ≤ ‖f' x‖ 
goal: (fun _x => c) =O[l] f' ↔ ∃ b, 0 < b ∧ ∀ᶠ (x : α) in l, b ≤ ‖f' x‖

full_name: Asymptotics.IsBigO.trans_tendsto
code: theorem IsBigO.trans_tendsto (hfg : f'' =O[l] g'') (hg : Tendsto g'' l (𝓝 0)) :
    Tendsto f'' l (𝓝 0) 
goal: Filter.Tendsto f'' l (𝓝 0)

full_name: Asymptotics.IsLittleO.trans_tendsto
code: theorem IsLittleO.trans_tendsto (hfg : f'' =o[l] g'') (hg : Tendsto g'' l (𝓝 0)) :
    Tendsto f'' l (𝓝 0) 
goal: Filter.Tendsto f'' l (𝓝 0)

full_name: Asymptotics.isBigOWith_const_mul_self
code: theorem isBigOWith_const_mul_self (c : R) (f : α → R) (l : Filter α) :
    IsBigOWith ‖c‖ l (fun x => c * f x) f 
goal: Asymptotics.IsBigOWith ‖c‖ l (fun x => c * f x) f

full_name: Asymptotics.isBigO_const_mul_self
code: theorem isBigO_const_mul_self (c : R) (f : α → R) (l : Filter α) : (fun x => c * f x) =O[l] f 
goal: (fun x => c * f x) =O[l] f

full_name: Asymptotics.IsBigOWith.const_mul_left
code: theorem IsBigOWith.const_mul_left {f : α → R} (h : IsBigOWith c l f g) (c' : R) :
    IsBigOWith (‖c'‖ * c) l (fun x => c' * f x) g 
goal: Asymptotics.IsBigOWith (‖c'‖ * c) l (fun x => c' * f x) g

full_name: Asymptotics.IsBigO.const_mul_left
code: theorem IsBigO.const_mul_left {f : α → R} (h : f =O[l] g) (c' : R) : (fun x => c' * f x) =O[l] g 
goal: (fun x => c' * f x) =O[l] g

full_name: Asymptotics.isBigOWith_self_const_mul'
code: theorem isBigOWith_self_const_mul' (u : Rˣ) (f : α → R) (l : Filter α) :
    IsBigOWith ‖(↑u⁻¹ : R)‖ l f fun x => ↑u * f x 
goal: Asymptotics.IsBigOWith ‖↑u⁻¹‖ l f fun x => ↑u * f x

full_name: Asymptotics.isBigOWith_self_const_mul
code: theorem isBigOWith_self_const_mul (c : 𝕜) (hc : c ≠ 0) (f : α → 𝕜) (l : Filter α) :
    IsBigOWith ‖c‖⁻¹ l f fun x => c * f x 
goal: Asymptotics.IsBigOWith ‖c‖⁻¹ l f fun x => c * f x

full_name: Asymptotics.isBigO_self_const_mul'
code: theorem isBigO_self_const_mul' {c : R} (hc : IsUnit c) (f : α → R) (l : Filter α) :
    f =O[l] fun x => c * f x 
goal: f =O[l] fun x => c * f x

full_name: Asymptotics.isBigO_self_const_mul
code: theorem isBigO_self_const_mul (c : 𝕜) (hc : c ≠ 0) (f : α → 𝕜) (l : Filter α) :
    f =O[l] fun x => c * f x 
goal: f =O[l] fun x => c * f x

full_name: Asymptotics.isBigO_const_mul_left_iff'
code: theorem isBigO_const_mul_left_iff' {f : α → R} {c : R} (hc : IsUnit c) :
    (fun x => c * f x) =O[l] g ↔ f =O[l] g 
goal: (fun x => c * f x) =O[l] g ↔ f =O[l] g

full_name: Asymptotics.isBigO_const_mul_left_iff
code: theorem isBigO_const_mul_left_iff {f : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) :
    (fun x => c * f x) =O[l] g ↔ f =O[l] g 
goal: (fun x => c * f x) =O[l] g ↔ f =O[l] g

full_name: Asymptotics.IsLittleO.const_mul_left
code: theorem IsLittleO.const_mul_left {f : α → R} (h : f =o[l] g) (c : R) : (fun x => c * f x) =o[l] g 
goal: (fun x => c * f x) =o[l] g

full_name: Asymptotics.isLittleO_const_mul_left_iff'
code: theorem isLittleO_const_mul_left_iff' {f : α → R} {c : R} (hc : IsUnit c) :
    (fun x => c * f x) =o[l] g ↔ f =o[l] g 
goal: (fun x => c * f x) =o[l] g ↔ f =o[l] g

full_name: Asymptotics.isLittleO_const_mul_left_iff
code: theorem isLittleO_const_mul_left_iff {f : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) :
    (fun x => c * f x) =o[l] g ↔ f =o[l] g 
goal: (fun x => c * f x) =o[l] g ↔ f =o[l] g

full_name: Asymptotics.IsBigOWith.of_const_mul_right
code: theorem IsBigOWith.of_const_mul_right {g : α → R} {c : R} (hc' : 0 ≤ c')
    (h : IsBigOWith c' l f fun x => c * g x) : IsBigOWith (c' * ‖c‖) l f g 
goal: Asymptotics.IsBigOWith (c' * ‖c‖) l f g

full_name: Asymptotics.IsBigO.of_const_mul_right
code: theorem IsBigO.of_const_mul_right {g : α → R} {c : R} (h : f =O[l] fun x => c * g x) : f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsBigOWith.const_mul_right'
code: theorem IsBigOWith.const_mul_right' {g : α → R} {u : Rˣ} {c' : ℝ} (hc' : 0 ≤ c')
    (h : IsBigOWith c' l f g) : IsBigOWith (c' * ‖(↑u⁻¹ : R)‖) l f fun x => ↑u * g x 
goal: Asymptotics.IsBigOWith (c' * ‖↑u⁻¹‖) l f fun x => ↑u * g x

full_name: Asymptotics.IsBigOWith.const_mul_right
code: theorem IsBigOWith.const_mul_right {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) {c' : ℝ} (hc' : 0 ≤ c')
    (h : IsBigOWith c' l f g) : IsBigOWith (c' * ‖c‖⁻¹) l f fun x => c * g x 
goal: Asymptotics.IsBigOWith (c' * ‖c‖⁻¹) l f fun x => c * g x

full_name: Asymptotics.IsBigO.const_mul_right'
code: theorem IsBigO.const_mul_right' {g : α → R} {c : R} (hc : IsUnit c) (h : f =O[l] g) :
    f =O[l] fun x => c * g x 
goal: f =O[l] fun x => c * g x

full_name: Asymptotics.IsBigO.const_mul_right
code: theorem IsBigO.const_mul_right {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) (h : f =O[l] g) :
    f =O[l] fun x => c * g x 
goal: f =O[l] fun x => c * g x

full_name: Asymptotics.isBigO_const_mul_right_iff'
code: theorem isBigO_const_mul_right_iff' {g : α → R} {c : R} (hc : IsUnit c) :
    (f =O[l] fun x => c * g x) ↔ f =O[l] g 
goal: (f =O[l] fun x => c * g x) ↔ f =O[l] g

full_name: Asymptotics.isBigO_const_mul_right_iff
code: theorem isBigO_const_mul_right_iff {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) :
    (f =O[l] fun x => c * g x) ↔ f =O[l] g 
goal: (f =O[l] fun x => c * g x) ↔ f =O[l] g

full_name: Asymptotics.IsLittleO.of_const_mul_right
code: theorem IsLittleO.of_const_mul_right {g : α → R} {c : R} (h : f =o[l] fun x => c * g x) :
    f =o[l] g 
goal: f =o[l] g

full_name: Asymptotics.IsLittleO.const_mul_right'
code: theorem IsLittleO.const_mul_right' {g : α → R} {c : R} (hc : IsUnit c) (h : f =o[l] g) :
    f =o[l] fun x => c * g x 
goal: f =o[l] fun x => c * g x

full_name: Asymptotics.IsLittleO.const_mul_right
code: theorem IsLittleO.const_mul_right {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) (h : f =o[l] g) :
    f =o[l] fun x => c * g x 
goal: f =o[l] fun x => c * g x

full_name: Asymptotics.isLittleO_const_mul_right_iff'
code: theorem isLittleO_const_mul_right_iff' {g : α → R} {c : R} (hc : IsUnit c) :
    (f =o[l] fun x => c * g x) ↔ f =o[l] g 
goal: (f =o[l] fun x => c * g x) ↔ f =o[l] g

full_name: Asymptotics.isLittleO_const_mul_right_iff
code: theorem isLittleO_const_mul_right_iff {g : α → 𝕜} {c : 𝕜} (hc : c ≠ 0) :
    (f =o[l] fun x => c * g x) ↔ f =o[l] g 
goal: (f =o[l] fun x => c * g x) ↔ f =o[l] g

full_name: Asymptotics.IsBigOWith.mul
code: theorem IsBigOWith.mul {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} {c₁ c₂ : ℝ} (h₁ : IsBigOWith c₁ l f₁ g₁)
    (h₂ : IsBigOWith c₂ l f₂ g₂) :
    IsBigOWith (c₁ * c₂) l (fun x => f₁ x * f₂ x) fun x => g₁ x * g₂ x 
goal: Asymptotics.IsBigOWith (c₁ * c₂) l (fun x => f₁ x * f₂ x) fun x => g₁ x * g₂ x

full_name: Asymptotics.IsBigO.mul
code: theorem IsBigO.mul {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} (h₁ : f₁ =O[l] g₁) (h₂ : f₂ =O[l] g₂) :
    (fun x => f₁ x * f₂ x) =O[l] fun x => g₁ x * g₂ x 
goal: (fun x => f₁ x * f₂ x) =O[l] fun x => g₁ x * g₂ x

full_name: Asymptotics.IsBigO.mul_isLittleO
code: theorem IsBigO.mul_isLittleO {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} (h₁ : f₁ =O[l] g₁) (h₂ : f₂ =o[l] g₂) :
    (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x 
goal: (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x

full_name: Asymptotics.IsLittleO.mul_isBigO
code: theorem IsLittleO.mul_isBigO {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} (h₁ : f₁ =o[l] g₁) (h₂ : f₂ =O[l] g₂) :
    (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x 
goal: (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x

full_name: Asymptotics.IsLittleO.mul
code: theorem IsLittleO.mul {f₁ f₂ : α → R} {g₁ g₂ : α → 𝕜} (h₁ : f₁ =o[l] g₁) (h₂ : f₂ =o[l] g₂) :
    (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x 
goal: (fun x => f₁ x * f₂ x) =o[l] fun x => g₁ x * g₂ x

full_name: Asymptotics.IsBigOWith.pow'
code: theorem IsBigOWith.pow' {f : α → R} {g : α → 𝕜} (h : IsBigOWith c l f g) :
    ∀ n : ℕ, IsBigOWith (Nat.casesOn n ‖(1 : R)‖ fun n => c ^ (n + 1))
      l (fun x => f x ^ n) fun x => g x ^ n
  
goal: Asymptotics.IsBigOWith (Nat.casesOn n ‖1‖ fun n => c ^ (n + 1)) l (fun x => f x ^ n) fun x => g x ^ n

full_name: Asymptotics.IsBigOWith.pow
code: theorem IsBigOWith.pow [NormOneClass R] {f : α → R} {g : α → 𝕜} (h : IsBigOWith c l f g) :
    ∀ n : ℕ, IsBigOWith (c ^ n) l (fun x => f x ^ n) fun x => g x ^ n
  
goal: Asymptotics.IsBigOWith (c ^ n) l (fun x => f x ^ n) fun x => g x ^ n

full_name: Asymptotics.IsBigOWith.of_pow
code: theorem IsBigOWith.of_pow {n : ℕ} {f : α → 𝕜} {g : α → R} (h : IsBigOWith c l (f ^ n) (g ^ n))
    (hn : n ≠ 0) (hc : c ≤ c' ^ n) (hc' : 0 ≤ c') : IsBigOWith c' l f g 
goal: Asymptotics.IsBigOWith c' l f g

full_name: Asymptotics.IsBigO.pow
code: theorem IsBigO.pow {f : α → R} {g : α → 𝕜} (h : f =O[l] g) (n : ℕ) :
    (fun x => f x ^ n) =O[l] fun x => g x ^ n 
goal: (fun x => f x ^ n) =O[l] fun x => g x ^ n

full_name: Asymptotics.IsBigO.of_pow
code: theorem IsBigO.of_pow {f : α → 𝕜} {g : α → R} {n : ℕ} (hn : n ≠ 0) (h : (f ^ n) =O[l] (g ^ n)) :
    f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsLittleO.pow
code: theorem IsLittleO.pow {f : α → R} {g : α → 𝕜} (h : f =o[l] g) {n : ℕ} (hn : 0 < n) :
    (fun x => f x ^ n) =o[l] fun x => g x ^ n 
goal: (fun x => f x ^ n) =o[l] fun x => g x ^ n

full_name: Asymptotics.IsLittleO.of_pow
code: theorem IsLittleO.of_pow {f : α → 𝕜} {g : α → R} {n : ℕ} (h : (f ^ n) =o[l] (g ^ n)) (hn : n ≠ 0) :
    f =o[l] g 
goal: f =o[l] g

full_name: Asymptotics.IsBigOWith.inv_rev
code: theorem IsBigOWith.inv_rev {f : α → 𝕜} {g : α → 𝕜'} (h : IsBigOWith c l f g)
    (h₀ : ∀ᶠ x in l, f x = 0 → g x = 0) : IsBigOWith c l (fun x => (g x)⁻¹) fun x => (f x)⁻¹ 
goal: Asymptotics.IsBigOWith c l (fun x => (g x)⁻¹) fun x => (f x)⁻¹

full_name: Asymptotics.IsBigO.inv_rev
code: theorem IsBigO.inv_rev {f : α → 𝕜} {g : α → 𝕜'} (h : f =O[l] g)
    (h₀ : ∀ᶠ x in l, f x = 0 → g x = 0) : (fun x => (g x)⁻¹) =O[l] fun x => (f x)⁻¹ 
goal: (fun x => (g x)⁻¹) =O[l] fun x => (f x)⁻¹

full_name: Asymptotics.IsLittleO.inv_rev
code: theorem IsLittleO.inv_rev {f : α → 𝕜} {g : α → 𝕜'} (h : f =o[l] g)
    (h₀ : ∀ᶠ x in l, f x = 0 → g x = 0) : (fun x => (g x)⁻¹) =o[l] fun x => (f x)⁻¹ 
goal: (fun x => (g x)⁻¹) =o[l] fun x => (f x)⁻¹

full_name: Asymptotics.IsBigOWith.const_smul_self
code: theorem IsBigOWith.const_smul_self (c' : R) :
    IsBigOWith (‖c'‖) l (fun x => c' • f' x) f' 
goal: Asymptotics.IsBigOWith ‖c'‖ l (fun x => c' • f' x) f'

full_name: Asymptotics.IsBigO.const_smul_self
code: theorem IsBigO.const_smul_self (c' : R) : (fun x => c' • f' x) =O[l] f' 
goal: (fun x => c' • f' x) =O[l] f'

full_name: Asymptotics.IsBigOWith.const_smul_left
code: theorem IsBigOWith.const_smul_left (h : IsBigOWith c l f' g) (c' : R) :
    IsBigOWith (‖c'‖ * c) l (fun x => c' • f' x) g 
goal: Asymptotics.IsBigOWith (‖c'‖ * c) l (fun x => c' • f' x) g

full_name: Asymptotics.IsBigO.const_smul_left
code: theorem IsBigO.const_smul_left (h : f' =O[l] g) (c : R) : (c • f') =O[l] g 
goal: (c • f') =O[l] g

full_name: Asymptotics.IsLittleO.const_smul_left
code: theorem IsLittleO.const_smul_left (h : f' =o[l] g) (c : R) : (c • f') =o[l] g 
goal: (c • f') =o[l] g

full_name: Asymptotics.isBigO_const_smul_left
code: theorem isBigO_const_smul_left {c : 𝕜} (hc : c ≠ 0) : (fun x => c • f' x) =O[l] g ↔ f' =O[l] g 
goal: (fun x => c • f' x) =O[l] g ↔ f' =O[l] g

full_name: Asymptotics.isLittleO_const_smul_left
code: theorem isLittleO_const_smul_left {c : 𝕜} (hc : c ≠ 0) :
    (fun x => c • f' x) =o[l] g ↔ f' =o[l] g 
goal: (fun x => c • f' x) =o[l] g ↔ f' =o[l] g

full_name: Asymptotics.isBigO_const_smul_right
code: theorem isBigO_const_smul_right {c : 𝕜} (hc : c ≠ 0) :
    (f =O[l] fun x => c • f' x) ↔ f =O[l] f' 
goal: (f =O[l] fun x => c • f' x) ↔ f =O[l] f'

full_name: Asymptotics.isLittleO_const_smul_right
code: theorem isLittleO_const_smul_right {c : 𝕜} (hc : c ≠ 0) :
    (f =o[l] fun x => c • f' x) ↔ f =o[l] f' 
goal: (f =o[l] fun x => c • f' x) ↔ f =o[l] f'

full_name: Asymptotics.IsBigOWith.smul
code: theorem IsBigOWith.smul (h₁ : IsBigOWith c l k₁ k₂) (h₂ : IsBigOWith c' l f' g') :
    IsBigOWith (c * c') l (fun x => k₁ x • f' x) fun x => k₂ x • g' x 
goal: Asymptotics.IsBigOWith (c * c') l (fun x => k₁ x • f' x) fun x => k₂ x • g' x

full_name: Asymptotics.IsBigO.smul
code: theorem IsBigO.smul (h₁ : k₁ =O[l] k₂) (h₂ : f' =O[l] g') :
    (fun x => k₁ x • f' x) =O[l] fun x => k₂ x • g' x 
goal: (fun x => k₁ x • f' x) =O[l] fun x => k₂ x • g' x

full_name: Asymptotics.IsBigO.smul_isLittleO
code: theorem IsBigO.smul_isLittleO (h₁ : k₁ =O[l] k₂) (h₂ : f' =o[l] g') :
    (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x 
goal: (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x

full_name: Asymptotics.IsLittleO.smul_isBigO
code: theorem IsLittleO.smul_isBigO (h₁ : k₁ =o[l] k₂) (h₂ : f' =O[l] g') :
    (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x 
goal: (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x

full_name: Asymptotics.IsLittleO.smul
code: theorem IsLittleO.smul (h₁ : k₁ =o[l] k₂) (h₂ : f' =o[l] g') :
    (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x 
goal: (fun x => k₁ x • f' x) =o[l] fun x => k₂ x • g' x

full_name: Asymptotics.IsBigOWith.sum
code: theorem IsBigOWith.sum (h : ∀ i ∈ s, IsBigOWith (C i) l (A i) g) :
    IsBigOWith (∑ i ∈ s, C i) l (fun x => ∑ i ∈ s, A i x) g 
goal: Asymptotics.IsBigOWith (∑ i ∈ s, C i) l (fun x => ∑ i ∈ s, A i x) g

full_name: Asymptotics.IsBigO.sum
code: theorem IsBigO.sum (h : ∀ i ∈ s, A i =O[l] g) : (fun x => ∑ i ∈ s, A i x) =O[l] g 
goal: (fun x => ∑ i ∈ s, A i x) =O[l] g

full_name: Asymptotics.IsLittleO.sum
code: theorem IsLittleO.sum (h : ∀ i ∈ s, A i =o[l] g') : (fun x => ∑ i ∈ s, A i x) =o[l] g' 
goal: (fun x => ∑ i ∈ s, A i x) =o[l] g'

full_name: Asymptotics.IsLittleO.tendsto_div_nhds_zero
code: theorem IsLittleO.tendsto_div_nhds_zero {f g : α → 𝕜} (h : f =o[l] g) :
    Tendsto (fun x => f x / g x) l (𝓝 0) 
goal: Filter.Tendsto (fun x => f x / g x) l (𝓝 0)

full_name: Asymptotics.IsLittleO.tendsto_inv_smul_nhds_zero
code: theorem IsLittleO.tendsto_inv_smul_nhds_zero [Module 𝕜 E'] [BoundedSMul 𝕜 E']
    {f : α → E'} {g : α → 𝕜}
    {l : Filter α} (h : f =o[l] g) : Tendsto (fun x => (g x)⁻¹ • f x) l (𝓝 0) 
goal: Filter.Tendsto (fun x => (g x)⁻¹ • f x) l (𝓝 0)

full_name: Asymptotics.isLittleO_iff_tendsto'
code: theorem isLittleO_iff_tendsto' {f g : α → 𝕜} (hgf : ∀ᶠ x in l, g x = 0 → f x = 0) :
    f =o[l] g ↔ Tendsto (fun x => f x / g x) l (𝓝 0) 
goal: f =o[l] g ↔ Filter.Tendsto (fun x => f x / g x) l (𝓝 0)

full_name: Asymptotics.isLittleO_iff_tendsto
code: theorem isLittleO_iff_tendsto {f g : α → 𝕜} (hgf : ∀ x, g x = 0 → f x = 0) :
    f =o[l] g ↔ Tendsto (fun x => f x / g x) l (𝓝 0) 
goal: f =o[l] g ↔ Filter.Tendsto (fun x => f x / g x) l (𝓝 0)

full_name: Asymptotics.isLittleO_const_left_of_ne
code: theorem isLittleO_const_left_of_ne {c : E''} (hc : c ≠ 0) :
    (fun _x => c) =o[l] g ↔ Tendsto (fun x => ‖g x‖) l atTop 
goal: (fun _x => c) =o[l] g ↔ Filter.Tendsto (fun x => ‖g x‖) l Filter.atTop

full_name: Asymptotics.isLittleO_const_left
code: @[simp]
theorem isLittleO_const_left {c : E''} :
    (fun _x => c) =o[l] g'' ↔ c = 0 ∨ Tendsto (norm ∘ g'') l atTop 
goal: (fun _x => c) =o[l] g'' ↔ c = 0 ∨ Filter.Tendsto (norm ∘ g'') l Filter.atTop

full_name: Asymptotics.isLittleO_const_const_iff
code: @[simp 1001] -- Porting note: increase priority so that this triggers before `isLittleO_const_left`
theorem isLittleO_const_const_iff [NeBot l] {d : E''} {c : F''} :
    ((fun _x => d) =o[l] fun _x => c) ↔ d = 0 
goal: ((fun _x => d) =o[l] fun _x => c) ↔ d = 0

full_name: Asymptotics.isLittleO_pure
code: @[simp]
theorem isLittleO_pure {x} : f'' =o[pure x] g'' ↔ f'' x = 0 
goal: f'' =o[pure x] g'' ↔ f'' x = 0

full_name: Asymptotics.isLittleO_const_id_cobounded
code: theorem isLittleO_const_id_cobounded (c : F'') :
    (fun _ => c) =o[Bornology.cobounded E''] id 
goal: (fun x => c) =o[Bornology.cobounded E''] id

full_name: Asymptotics.isLittleO_const_id_atTop
code: theorem isLittleO_const_id_atTop (c : E'') : (fun _x : ℝ => c) =o[atTop] id 
goal: (fun _x => c) =o[Filter.atTop] id

full_name: Asymptotics.isLittleO_const_id_atBot
code: theorem isLittleO_const_id_atBot (c : E'') : (fun _x : ℝ => c) =o[atBot] id 
goal: (fun _x => c) =o[Filter.atBot] id

full_name: Asymptotics.IsBigOWith.eventually_mul_div_cancel
code: theorem IsBigOWith.eventually_mul_div_cancel (h : IsBigOWith c l u v) : u / v * v =ᶠ[l] u 
goal: u / v * v =ᶠ[l] u

full_name: Asymptotics.IsBigO.eventually_mul_div_cancel
code: /-- If `u = O(v)` along `l`, then `(u / v) * v = u` eventually at `l`. -/
theorem IsBigO.eventually_mul_div_cancel (h : u =O[l] v) : u / v * v =ᶠ[l] u 
goal: u / v * v =ᶠ[l] u

full_name: Asymptotics.IsLittleO.eventually_mul_div_cancel
code: /-- If `u = o(v)` along `l`, then `(u / v) * v = u` eventually at `l`. -/
theorem IsLittleO.eventually_mul_div_cancel (h : u =o[l] v) : u / v * v =ᶠ[l] u 
goal: u / v * v =ᶠ[l] u

full_name: Asymptotics.isBigOWith_of_eq_mul
code: /-- If `‖φ‖` is eventually bounded by `c`, and `u =ᶠ[l] φ * v`, then we have `IsBigOWith c u v l`.
    This does not require any assumptions on `c`, which is why we keep this version along with
    `IsBigOWith_iff_exists_eq_mul`. -/
theorem isBigOWith_of_eq_mul {u v : α → R} (φ : α → R) (hφ : ∀ᶠ x in l, ‖φ x‖ ≤ c)
    (h : u =ᶠ[l] φ * v) :
    IsBigOWith c l u v 
goal: Asymptotics.IsBigOWith c l u v

full_name: Asymptotics.isBigOWith_iff_exists_eq_mul
code: theorem isBigOWith_iff_exists_eq_mul (hc : 0 ≤ c) :
    IsBigOWith c l u v ↔ ∃ φ : α → 𝕜, (∀ᶠ x in l, ‖φ x‖ ≤ c) ∧ u =ᶠ[l] φ * v 
goal: Asymptotics.IsBigOWith c l u v ↔ ∃ φ, (∀ᶠ (x : α) in l, ‖φ x‖ ≤ c) ∧ u =ᶠ[l] φ * v

full_name: Asymptotics.IsBigOWith.exists_eq_mul
code: theorem IsBigOWith.exists_eq_mul (h : IsBigOWith c l u v) (hc : 0 ≤ c) :
    ∃ φ : α → 𝕜, (∀ᶠ x in l, ‖φ x‖ ≤ c) ∧ u =ᶠ[l] φ * v 
goal: ∃ φ, (∀ᶠ (x : α) in l, ‖φ x‖ ≤ c) ∧ u =ᶠ[l] φ * v

full_name: Asymptotics.isBigO_iff_exists_eq_mul
code: theorem isBigO_iff_exists_eq_mul :
    u =O[l] v ↔ ∃ φ : α → 𝕜, l.IsBoundedUnder (· ≤ ·) (norm ∘ φ) ∧ u =ᶠ[l] φ * v 
goal: u =O[l] v ↔ ∃ φ, Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l (norm ∘ φ) ∧ u =ᶠ[l] φ * v

full_name: Asymptotics.isLittleO_iff_exists_eq_mul
code: theorem isLittleO_iff_exists_eq_mul :
    u =o[l] v ↔ ∃ φ : α → 𝕜, Tendsto φ l (𝓝 0) ∧ u =ᶠ[l] φ * v 
goal: u =o[l] v ↔ ∃ φ, Filter.Tendsto φ l (𝓝 0) ∧ u =ᶠ[l] φ * v

full_name: Asymptotics.div_isBoundedUnder_of_isBigO
code: theorem div_isBoundedUnder_of_isBigO {α : Type*} {l : Filter α} {f g : α → 𝕜} (h : f =O[l] g) :
    IsBoundedUnder (· ≤ ·) l fun x => ‖f x / g x‖ 
goal: Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x / g x‖

full_name: Asymptotics.isBigO_iff_div_isBoundedUnder
code: theorem isBigO_iff_div_isBoundedUnder {α : Type*} {l : Filter α} {f g : α → 𝕜}
    (hgf : ∀ᶠ x in l, g x = 0 → f x = 0) :
    f =O[l] g ↔ IsBoundedUnder (· ≤ ·) l fun x => ‖f x / g x‖ 
goal: f =O[l] g ↔ Filter.IsBoundedUnder (fun x x_1 => x ≤ x_1) l fun x => ‖f x / g x‖

full_name: Asymptotics.isBigO_of_div_tendsto_nhds
code: theorem isBigO_of_div_tendsto_nhds {α : Type*} {l : Filter α} {f g : α → 𝕜}
    (hgf : ∀ᶠ x in l, g x = 0 → f x = 0) (c : 𝕜) (H : Filter.Tendsto (f / g) l (𝓝 c)) :
    f =O[l] g 
goal: f =O[l] g

full_name: Asymptotics.IsLittleO.tendsto_zero_of_tendsto
code: theorem IsLittleO.tendsto_zero_of_tendsto {α E 𝕜 : Type*} [NormedAddCommGroup E] [NormedField 𝕜]
    {u : α → E} {v : α → 𝕜} {l : Filter α} {y : 𝕜} (huv : u =o[l] v) (hv : Tendsto v l (𝓝 y)) :
    Tendsto u l (𝓝 0) 
goal: Filter.Tendsto u l (𝓝 0)

full_name: Asymptotics.isLittleO_pow_pow
code: theorem isLittleO_pow_pow {m n : ℕ} (h : m < n) : (fun x : 𝕜 => x ^ n) =o[𝓝 0] fun x => x ^ m 
goal: (fun x => x ^ n) =o[𝓝 0] fun x => x ^ m

full_name: Asymptotics.isLittleO_norm_pow_norm_pow
code: theorem isLittleO_norm_pow_norm_pow {m n : ℕ} (h : m < n) :
    (fun x : E' => ‖x‖ ^ n) =o[𝓝 0] fun x => ‖x‖ ^ m 
goal: (fun x => ‖x‖ ^ n) =o[𝓝 0] fun x => ‖x‖ ^ m

full_name: Asymptotics.isLittleO_pow_id
code: theorem isLittleO_pow_id {n : ℕ} (h : 1 < n) : (fun x : 𝕜 => x ^ n) =o[𝓝 0] fun x => x 
goal: (fun x => x ^ n) =o[𝓝 0] fun x => x

full_name: Asymptotics.isLittleO_norm_pow_id
code: theorem isLittleO_norm_pow_id {n : ℕ} (h : 1 < n) :
    (fun x : E' => ‖x‖ ^ n) =o[𝓝 0] fun x => x 
goal: (fun x => ‖x‖ ^ n) =o[𝓝 0] fun x => x

full_name: Asymptotics.IsBigO.eq_zero_of_norm_pow_within
code: theorem IsBigO.eq_zero_of_norm_pow_within {f : E'' → F''} {s : Set E''} {x₀ : E''} {n : ℕ}
    (h : f =O[𝓝[s] x₀] fun x => ‖x - x₀‖ ^ n) (hx₀ : x₀ ∈ s) (hn : n ≠ 0) : f x₀ = 0 
goal: f x₀ = 0

full_name: Asymptotics.IsBigO.eq_zero_of_norm_pow
code: theorem IsBigO.eq_zero_of_norm_pow {f : E'' → F''} {x₀ : E''} {n : ℕ}
    (h : f =O[𝓝 x₀] fun x => ‖x - x₀‖ ^ n) (hn : n ≠ 0) : f x₀ = 0 
goal: f x₀ = 0

full_name: Asymptotics.isLittleO_pow_sub_pow_sub
code: theorem isLittleO_pow_sub_pow_sub (x₀ : E') {n m : ℕ} (h : n < m) :
    (fun x => ‖x - x₀‖ ^ m) =o[𝓝 x₀] fun x => ‖x - x₀‖ ^ n 
goal: (fun x => ‖x - x₀‖ ^ m) =o[𝓝 x₀] fun x => ‖x - x₀‖ ^ n

full_name: Asymptotics.isLittleO_pow_sub_sub
code: theorem isLittleO_pow_sub_sub (x₀ : E') {m : ℕ} (h : 1 < m) :
    (fun x => ‖x - x₀‖ ^ m) =o[𝓝 x₀] fun x => x - x₀ 
goal: (fun x => ‖x - x₀‖ ^ m) =o[𝓝 x₀] fun x => x - x₀

full_name: Asymptotics.IsBigOWith.right_le_sub_of_lt_one
code: theorem IsBigOWith.right_le_sub_of_lt_one {f₁ f₂ : α → E'} (h : IsBigOWith c l f₁ f₂) (hc : c < 1) :
    IsBigOWith (1 / (1 - c)) l f₂ fun x => f₂ x - f₁ x 
goal: Asymptotics.IsBigOWith (1 / (1 - c)) l f₂ fun x => f₂ x - f₁ x

full_name: Asymptotics.IsBigOWith.right_le_add_of_lt_one
code: theorem IsBigOWith.right_le_add_of_lt_one {f₁ f₂ : α → E'} (h : IsBigOWith c l f₁ f₂) (hc : c < 1) :
    IsBigOWith (1 / (1 - c)) l f₂ fun x => f₁ x + f₂ x 
goal: Asymptotics.IsBigOWith (1 / (1 - c)) l f₂ fun x => f₁ x + f₂ x

full_name: Asymptotics.IsLittleO.right_isBigO_sub
code: theorem IsLittleO.right_isBigO_sub {f₁ f₂ : α → E'} (h : f₁ =o[l] f₂) :
    f₂ =O[l] fun x => f₂ x - f₁ x 
goal: f₂ =O[l] fun x => f₂ x - f₁ x

full_name: Asymptotics.IsLittleO.right_isBigO_add
code: theorem IsLittleO.right_isBigO_add {f₁ f₂ : α → E'} (h : f₁ =o[l] f₂) :
    f₂ =O[l] fun x => f₁ x + f₂ x 
goal: f₂ =O[l] fun x => f₁ x + f₂ x

full_name: Asymptotics.IsLittleO.right_isBigO_add'
code: theorem IsLittleO.right_isBigO_add' {f₁ f₂ : α → E'} (h : f₁ =o[l] f₂) :
    f₂ =O[l] (f₂ + f₁) 
goal: f₂ =O[l] (f₂ + f₁)

full_name: Asymptotics.bound_of_isBigO_cofinite
code: /-- If `f x = O(g x)` along `cofinite`, then there exists a positive constant `C` such that
`‖f x‖ ≤ C * ‖g x‖` whenever `g x ≠ 0`. -/
theorem bound_of_isBigO_cofinite (h : f =O[cofinite] g'') :
    ∃ C > 0, ∀ ⦃x⦄, g'' x ≠ 0 → ‖f x‖ ≤ C * ‖g'' x‖ 
goal: ∃ C > 0, ∀ ⦃x : α⦄, g'' x ≠ 0 → ‖f x‖ ≤ C * ‖g'' x‖

full_name: Asymptotics.isBigO_cofinite_iff
code: theorem isBigO_cofinite_iff (h : ∀ x, g'' x = 0 → f'' x = 0) :
    f'' =O[cofinite] g'' ↔ ∃ C, ∀ x, ‖f'' x‖ ≤ C * ‖g'' x‖ 
goal: f'' =O[Filter.cofinite] g'' ↔ ∃ C, ∀ (x : α), ‖f'' x‖ ≤ C * ‖g'' x‖

full_name: Asymptotics.bound_of_isBigO_nat_atTop
code: theorem bound_of_isBigO_nat_atTop {f : ℕ → E} {g'' : ℕ → E''} (h : f =O[atTop] g'') :
    ∃ C > 0, ∀ ⦃x⦄, g'' x ≠ 0 → ‖f x‖ ≤ C * ‖g'' x‖ 
goal: ∃ C > 0, ∀ ⦃x : ℕ⦄, g'' x ≠ 0 → ‖f x‖ ≤ C * ‖g'' x‖

full_name: Asymptotics.isBigO_nat_atTop_iff
code: theorem isBigO_nat_atTop_iff {f : ℕ → E''} {g : ℕ → F''} (h : ∀ x, g x = 0 → f x = 0) :
    f =O[atTop] g ↔ ∃ C, ∀ x, ‖f x‖ ≤ C * ‖g x‖ 
goal: f =O[Filter.atTop] g ↔ ∃ C, ∀ (x : ℕ), ‖f x‖ ≤ C * ‖g x‖

full_name: Asymptotics.isBigO_one_nat_atTop_iff
code: theorem isBigO_one_nat_atTop_iff {f : ℕ → E''} :
    f =O[atTop] (fun _n => 1 : ℕ → ℝ) ↔ ∃ C, ∀ n, ‖f n‖ ≤ C 
goal: (f =O[Filter.atTop] fun _n => 1) ↔ ∃ C, ∀ (n : ℕ), ‖f n‖ ≤ C

full_name: Asymptotics.isBigOWith_pi
code: theorem isBigOWith_pi {ι : Type*} [Fintype ι] {E' : ι → Type*} [∀ i, NormedAddCommGroup (E' i)]
    {f : α → ∀ i, E' i} {C : ℝ} (hC : 0 ≤ C) :
    IsBigOWith C l f g' ↔ ∀ i, IsBigOWith C l (fun x => f x i) g' 
goal: Asymptotics.IsBigOWith C l f g' ↔ ∀ (i : ι), Asymptotics.IsBigOWith C l (fun x => f x i) g'

full_name: Asymptotics.isBigO_pi
code: @[simp]
theorem isBigO_pi {ι : Type*} [Fintype ι] {E' : ι → Type*} [∀ i, NormedAddCommGroup (E' i)]
    {f : α → ∀ i, E' i} : f =O[l] g' ↔ ∀ i, (fun x => f x i) =O[l] g' 
goal: f =O[l] g' ↔ ∀ (i : ι), (fun x => f x i) =O[l] g'

full_name: Asymptotics.isLittleO_pi
code: @[simp]
theorem isLittleO_pi {ι : Type*} [Fintype ι] {E' : ι → Type*} [∀ i, NormedAddCommGroup (E' i)]
    {f : α → ∀ i, E' i} : f =o[l] g' ↔ ∀ i, (fun x => f x i) =o[l] g' 
goal: f =o[l] g' ↔ ∀ (i : ι), (fun x => f x i) =o[l] g'

full_name: Asymptotics.IsBigO.natCast_atTop
code: theorem IsBigO.natCast_atTop {R : Type*} [StrictOrderedSemiring R] [Archimedean R]
    {f : R → E} {g : R → F} (h : f =O[atTop] g) :
    (fun (n : ℕ) => f n) =O[atTop] (fun n => g n) 
goal: (fun n => f ↑n) =O[Filter.atTop] fun n => g ↑n

full_name: Asymptotics.IsLittleO.natCast_atTop
code: theorem IsLittleO.natCast_atTop {R : Type*} [StrictOrderedSemiring R] [Archimedean R]
    {f : R → E} {g : R → F} (h : f =o[atTop] g) :
    (fun (n : ℕ) => f n) =o[atTop] (fun n => g n) 
goal: (fun n => f ↑n) =o[Filter.atTop] fun n => g ↑n

full_name: Asymptotics.isBigO_atTop_iff_eventually_exists
code: theorem isBigO_atTop_iff_eventually_exists {α : Type*} [SemilatticeSup α] [Nonempty α]
    {f : α → E} {g : α → F} : f =O[atTop] g ↔ ∀ᶠ n₀ in atTop, ∃ c, ∀ n ≥ n₀, ‖f n‖ ≤ c * ‖g n‖ 
goal: f =O[Filter.atTop] g ↔ ∀ᶠ (n₀ : α) in Filter.atTop, ∃ c, ∀ n ≥ n₀, ‖f n‖ ≤ c * ‖g n‖

full_name: Asymptotics.isBigO_atTop_iff_eventually_exists_pos
code: theorem isBigO_atTop_iff_eventually_exists_pos {α : Type*}
    [SemilatticeSup α] [Nonempty α] {f : α → G} {g : α → G'} :
    f =O[atTop] g ↔ ∀ᶠ n₀ in atTop, ∃ c > 0, ∀ n ≥ n₀, c * ‖f n‖ ≤ ‖g n‖ 
goal: f =O[Filter.atTop] g ↔ ∀ᶠ (n₀ : α) in Filter.atTop, ∃ c > 0, ∀ n ≥ n₀, c * ‖f n‖ ≤ ‖g n‖

full_name: summable_of_isBigO
code: theorem summable_of_isBigO {ι E} [SeminormedAddCommGroup E] [CompleteSpace E]
    {f : ι → E} {g : ι → ℝ} (hg : Summable g) (h : f =O[cofinite] g) : Summable f 
goal: Summable f

full_name: summable_of_isBigO_nat
code: theorem summable_of_isBigO_nat {E} [SeminormedAddCommGroup E] [CompleteSpace E]
    {f : ℕ → E} {g : ℕ → ℝ} (hg : Summable g) (h : f =O[atTop] g) : Summable f 
goal: Summable f

full_name: Asymptotics.IsBigO.comp_summable_norm
code: lemma Asymptotics.IsBigO.comp_summable_norm {ι E F : Type*}
    [SeminormedAddCommGroup E] [SeminormedAddCommGroup F] {f : E → F} {g : ι → E}
    (hf : f =O[𝓝 0] id) (hg : Summable (‖g ·‖)) : Summable (‖f <| g ·‖) 
goal: Summable fun x => ‖f (g x)‖

full_name: PartialHomeomorph.isBigOWith_congr
code: /-- Transfer `IsBigOWith` over a `PartialHomeomorph`. -/
theorem isBigOWith_congr (e : PartialHomeomorph α β) {b : β} (hb : b ∈ e.target) {f : β → E}
    {g : β → F} {C : ℝ} : IsBigOWith C (𝓝 b) f g ↔ IsBigOWith C (𝓝 (e.symm b)) (f ∘ e) (g ∘ e) 
goal: Asymptotics.IsBigOWith C (𝓝 b) f g ↔ Asymptotics.IsBigOWith C (𝓝 (↑e.symm b)) (f ∘ ↑e) (g ∘ ↑e)

full_name: PartialHomeomorph.isBigO_congr
code: /-- Transfer `IsBigO` over a `PartialHomeomorph`. -/
theorem isBigO_congr (e : PartialHomeomorph α β) {b : β} (hb : b ∈ e.target) {f : β → E}
    {g : β → F} : f =O[𝓝 b] g ↔ (f ∘ e) =O[𝓝 (e.symm b)] (g ∘ e) 
goal: f =O[𝓝 b] g ↔ (f ∘ ↑e) =O[𝓝 (↑e.symm b)] (g ∘ ↑e)

full_name: PartialHomeomorph.isLittleO_congr
code: /-- Transfer `IsLittleO` over a `PartialHomeomorph`. -/
theorem isLittleO_congr (e : PartialHomeomorph α β) {b : β} (hb : b ∈ e.target) {f : β → E}
    {g : β → F} : f =o[𝓝 b] g ↔ (f ∘ e) =o[𝓝 (e.symm b)] (g ∘ e) 
goal: f =o[𝓝 b] g ↔ (f ∘ ↑e) =o[𝓝 (↑e.symm b)] (g ∘ ↑e)

full_name: Homeomorph.isBigOWith_congr
code: /-- Transfer `IsBigOWith` over a `Homeomorph`. -/
theorem isBigOWith_congr (e : α ≃ₜ β) {b : β} {f : β → E} {g : β → F} {C : ℝ} :
    IsBigOWith C (𝓝 b) f g ↔ IsBigOWith C (𝓝 (e.symm b)) (f ∘ e) (g ∘ e) 
goal: Asymptotics.IsBigOWith C (𝓝 b) f g ↔ Asymptotics.IsBigOWith C (𝓝 (e.symm b)) (f ∘ ⇑e) (g ∘ ⇑e)

full_name: Homeomorph.isBigO_congr
code: /-- Transfer `IsBigO` over a `Homeomorph`. -/
theorem isBigO_congr (e : α ≃ₜ β) {b : β} {f : β → E} {g : β → F} :
    f =O[𝓝 b] g ↔ (f ∘ e) =O[𝓝 (e.symm b)] (g ∘ e) 
goal: f =O[𝓝 b] g ↔ (f ∘ ⇑e) =O[𝓝 (e.symm b)] (g ∘ ⇑e)

full_name: Homeomorph.isLittleO_congr
code: /-- Transfer `IsLittleO` over a `Homeomorph`. -/
theorem isLittleO_congr (e : α ≃ₜ β) {b : β} {f : β → E} {g : β → F} :
    f =o[𝓝 b] g ↔ (f ∘ e) =o[𝓝 (e.symm b)] (g ∘ e) 
goal: f =o[𝓝 b] g ↔ (f ∘ ⇑e) =o[𝓝 (e.symm b)] (g ∘ ⇑e)