Documentation

Mathlib.Analysis.Asymptotics.Arith

Arithmetic operations on asymptotic relations #

This file develops the behavior of IsBigOWith, IsBigO, and IsLittleO under absolute values, negation, addition, subtraction, zero, constants, and finite sums.

Simplification: absolute value #

@[simp]
theorem Asymptotics.isBigOWith_abs_right {α : Type u_1} {E : Type u_2} [Norm E] {c : } {f : αE} {l : Filter α} {u : α} :
(IsBigOWith c l f fun (x : α) => |u x|) IsBigOWith c l f u
theorem Asymptotics.IsBigOWith.of_abs_right {α : Type u_1} {E : Type u_2} [Norm E] {c : } {f : αE} {l : Filter α} {u : α} :
(IsBigOWith c l f fun (x : α) => |u x|)IsBigOWith c l f u

Alias of the forward direction of Asymptotics.isBigOWith_abs_right.

theorem Asymptotics.IsBigOWith.abs_right {α : Type u_1} {E : Type u_2} [Norm E] {c : } {f : αE} {l : Filter α} {u : α} :
IsBigOWith c l f uIsBigOWith c l f fun (x : α) => |u x|

Alias of the reverse direction of Asymptotics.isBigOWith_abs_right.

@[simp]
theorem Asymptotics.isBigO_abs_right {α : Type u_1} {E : Type u_2} [Norm E] {f : αE} {l : Filter α} {u : α} :
(f =O[l] fun (x : α) => |u x|) f =O[l] u
theorem Asymptotics.IsBigO.of_abs_right {α : Type u_1} {E : Type u_2} [Norm E] {f : αE} {l : Filter α} {u : α} :
(f =O[l] fun (x : α) => |u x|) → f =O[l] u

Alias of the forward direction of Asymptotics.isBigO_abs_right.

theorem Asymptotics.IsBigO.abs_right {α : Type u_1} {E : Type u_2} [Norm E] {f : αE} {l : Filter α} {u : α} :
f =O[l] uf =O[l] fun (x : α) => |u x|

Alias of the reverse direction of Asymptotics.isBigO_abs_right.

@[simp]
theorem Asymptotics.isLittleO_abs_right {α : Type u_1} {E : Type u_2} [Norm E] {f : αE} {l : Filter α} {u : α} :
(f =o[l] fun (x : α) => |u x|) f =o[l] u
theorem Asymptotics.IsLittleO.of_abs_right {α : Type u_1} {E : Type u_2} [Norm E] {f : αE} {l : Filter α} {u : α} :
(f =o[l] fun (x : α) => |u x|) → f =o[l] u

Alias of the forward direction of Asymptotics.isLittleO_abs_right.

theorem Asymptotics.IsLittleO.abs_right {α : Type u_1} {E : Type u_2} [Norm E] {f : αE} {l : Filter α} {u : α} :
f =o[l] uf =o[l] fun (x : α) => |u x|

Alias of the reverse direction of Asymptotics.isLittleO_abs_right.

@[simp]
theorem Asymptotics.isBigOWith_abs_left {α : Type u_1} {F : Type u_3} [Norm F] {c : } {g : αF} {l : Filter α} {u : α} :
IsBigOWith c l (fun (x : α) => |u x|) g IsBigOWith c l u g
theorem Asymptotics.IsBigOWith.abs_left {α : Type u_1} {F : Type u_3} [Norm F] {c : } {g : αF} {l : Filter α} {u : α} :
IsBigOWith c l u gIsBigOWith c l (fun (x : α) => |u x|) g

Alias of the reverse direction of Asymptotics.isBigOWith_abs_left.

theorem Asymptotics.IsBigOWith.of_abs_left {α : Type u_1} {F : Type u_3} [Norm F] {c : } {g : αF} {l : Filter α} {u : α} :
IsBigOWith c l (fun (x : α) => |u x|) gIsBigOWith c l u g

Alias of the forward direction of Asymptotics.isBigOWith_abs_left.

@[simp]
theorem Asymptotics.isBigO_abs_left {α : Type u_1} {F : Type u_3} [Norm F] {g : αF} {l : Filter α} {u : α} :
(fun (x : α) => |u x|) =O[l] g u =O[l] g
theorem Asymptotics.IsBigO.abs_left {α : Type u_1} {F : Type u_3} [Norm F] {g : αF} {l : Filter α} {u : α} :
u =O[l] g(fun (x : α) => |u x|) =O[l] g

Alias of the reverse direction of Asymptotics.isBigO_abs_left.

theorem Asymptotics.IsBigO.of_abs_left {α : Type u_1} {F : Type u_3} [Norm F] {g : αF} {l : Filter α} {u : α} :
(fun (x : α) => |u x|) =O[l] gu =O[l] g

Alias of the forward direction of Asymptotics.isBigO_abs_left.

@[simp]
theorem Asymptotics.isLittleO_abs_left {α : Type u_1} {F : Type u_3} [Norm F] {g : αF} {l : Filter α} {u : α} :
(fun (x : α) => |u x|) =o[l] g u =o[l] g
theorem Asymptotics.IsLittleO.of_abs_left {α : Type u_1} {F : Type u_3} [Norm F] {g : αF} {l : Filter α} {u : α} :
(fun (x : α) => |u x|) =o[l] gu =o[l] g

Alias of the forward direction of Asymptotics.isLittleO_abs_left.

theorem Asymptotics.IsLittleO.abs_left {α : Type u_1} {F : Type u_3} [Norm F] {g : αF} {l : Filter α} {u : α} :
u =o[l] g(fun (x : α) => |u x|) =o[l] g

Alias of the reverse direction of Asymptotics.isLittleO_abs_left.

theorem Asymptotics.isBigOWith_abs_abs {α : Type u_1} {c : } {l : Filter α} {u v : α} :
(IsBigOWith c l (fun (x : α) => |u x|) fun (x : α) => |v x|) IsBigOWith c l u v
theorem Asymptotics.IsBigOWith.of_abs_abs {α : Type u_1} {c : } {l : Filter α} {u v : α} :
(IsBigOWith c l (fun (x : α) => |u x|) fun (x : α) => |v x|)IsBigOWith c l u v

Alias of the forward direction of Asymptotics.isBigOWith_abs_abs.

theorem Asymptotics.IsBigOWith.abs_abs {α : Type u_1} {c : } {l : Filter α} {u v : α} :
IsBigOWith c l u vIsBigOWith c l (fun (x : α) => |u x|) fun (x : α) => |v x|

Alias of the reverse direction of Asymptotics.isBigOWith_abs_abs.

theorem Asymptotics.isBigO_abs_abs {α : Type u_1} {l : Filter α} {u v : α} :
((fun (x : α) => |u x|) =O[l] fun (x : α) => |v x|) u =O[l] v
theorem Asymptotics.IsBigO.of_abs_abs {α : Type u_1} {l : Filter α} {u v : α} :
((fun (x : α) => |u x|) =O[l] fun (x : α) => |v x|) → u =O[l] v

Alias of the forward direction of Asymptotics.isBigO_abs_abs.

theorem Asymptotics.IsBigO.abs_abs {α : Type u_1} {l : Filter α} {u v : α} :
u =O[l] v(fun (x : α) => |u x|) =O[l] fun (x : α) => |v x|

Alias of the reverse direction of Asymptotics.isBigO_abs_abs.

theorem Asymptotics.isLittleO_abs_abs {α : Type u_1} {l : Filter α} {u v : α} :
((fun (x : α) => |u x|) =o[l] fun (x : α) => |v x|) u =o[l] v
theorem Asymptotics.IsLittleO.abs_abs {α : Type u_1} {l : Filter α} {u v : α} :
u =o[l] v(fun (x : α) => |u x|) =o[l] fun (x : α) => |v x|

Alias of the reverse direction of Asymptotics.isLittleO_abs_abs.

theorem Asymptotics.IsLittleO.of_abs_abs {α : Type u_1} {l : Filter α} {u v : α} :
((fun (x : α) => |u x|) =o[l] fun (x : α) => |v x|) → u =o[l] v

Alias of the forward direction of Asymptotics.isLittleO_abs_abs.

Simplification: negate #

@[simp]
theorem Asymptotics.isBigOWith_neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {c : } {f : αE} {g' : αF'} {l : Filter α} :
(IsBigOWith c l f fun (x : α) => -g' x) IsBigOWith c l f g'
theorem Asymptotics.IsBigOWith.neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {c : } {f : αE} {g' : αF'} {l : Filter α} :
IsBigOWith c l f g'IsBigOWith c l f fun (x : α) => -g' x

Alias of the reverse direction of Asymptotics.isBigOWith_neg_right.

theorem Asymptotics.IsBigOWith.of_neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {c : } {f : αE} {g' : αF'} {l : Filter α} :
(IsBigOWith c l f fun (x : α) => -g' x)IsBigOWith c l f g'

Alias of the forward direction of Asymptotics.isBigOWith_neg_right.

@[simp]
theorem Asymptotics.isBigO_neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {f : αE} {g' : αF'} {l : Filter α} :
(f =O[l] fun (x : α) => -g' x) f =O[l] g'
theorem Asymptotics.IsBigO.neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {f : αE} {g' : αF'} {l : Filter α} :
f =O[l] g'f =O[l] fun (x : α) => -g' x

Alias of the reverse direction of Asymptotics.isBigO_neg_right.

theorem Asymptotics.IsBigO.of_neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {f : αE} {g' : αF'} {l : Filter α} :
(f =O[l] fun (x : α) => -g' x) → f =O[l] g'

Alias of the forward direction of Asymptotics.isBigO_neg_right.

@[simp]
theorem Asymptotics.isLittleO_neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {f : αE} {g' : αF'} {l : Filter α} :
(f =o[l] fun (x : α) => -g' x) f =o[l] g'
theorem Asymptotics.IsLittleO.of_neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {f : αE} {g' : αF'} {l : Filter α} :
(f =o[l] fun (x : α) => -g' x) → f =o[l] g'

Alias of the forward direction of Asymptotics.isLittleO_neg_right.

theorem Asymptotics.IsLittleO.neg_right {α : Type u_1} {E : Type u_2} {F' : Type u_5} [Norm E] [SeminormedAddCommGroup F'] {f : αE} {g' : αF'} {l : Filter α} :
f =o[l] g'f =o[l] fun (x : α) => -g' x

Alias of the reverse direction of Asymptotics.isLittleO_neg_right.

@[simp]
theorem Asymptotics.isBigOWith_neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c : } {g : αF} {f' : αE'} {l : Filter α} :
IsBigOWith c l (fun (x : α) => -f' x) g IsBigOWith c l f' g
theorem Asymptotics.IsBigOWith.neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c : } {g : αF} {f' : αE'} {l : Filter α} :
IsBigOWith c l f' gIsBigOWith c l (fun (x : α) => -f' x) g

Alias of the reverse direction of Asymptotics.isBigOWith_neg_left.

theorem Asymptotics.IsBigOWith.of_neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c : } {g : αF} {f' : αE'} {l : Filter α} :
IsBigOWith c l (fun (x : α) => -f' x) gIsBigOWith c l f' g

Alias of the forward direction of Asymptotics.isBigOWith_neg_left.

@[simp]
theorem Asymptotics.isBigO_neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {f' : αE'} {l : Filter α} :
(fun (x : α) => -f' x) =O[l] g f' =O[l] g
theorem Asymptotics.IsBigO.neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {f' : αE'} {l : Filter α} :
f' =O[l] g(fun (x : α) => -f' x) =O[l] g

Alias of the reverse direction of Asymptotics.isBigO_neg_left.

theorem Asymptotics.IsBigO.of_neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {f' : αE'} {l : Filter α} :
(fun (x : α) => -f' x) =O[l] gf' =O[l] g

Alias of the forward direction of Asymptotics.isBigO_neg_left.

@[simp]
theorem Asymptotics.isLittleO_neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {f' : αE'} {l : Filter α} :
(fun (x : α) => -f' x) =o[l] g f' =o[l] g
theorem Asymptotics.IsLittleO.of_neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {f' : αE'} {l : Filter α} :
(fun (x : α) => -f' x) =o[l] gf' =o[l] g

Alias of the forward direction of Asymptotics.isLittleO_neg_left.

theorem Asymptotics.IsLittleO.neg_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {f' : αE'} {l : Filter α} :
f' =o[l] g(fun (x : α) => -f' x) =o[l] g

Alias of the reverse direction of Asymptotics.isLittleO_neg_left.

theorem Asymptotics.IsBigOWith.eq_zero_imp {α : Type u_1} {E'' : Type u_6} {F'' : Type u_7} [NormedAddCommGroup E''] [NormedAddCommGroup F''] {c : } {f'' : αE''} {g'' : αF''} {l : Filter α} (h : IsBigOWith c l f'' g'') :
∀ᶠ (x : α) in l, g'' x = 0f'' x = 0
theorem Asymptotics.IsBigO.eq_zero_imp {α : Type u_1} {E'' : Type u_6} {F'' : Type u_7} [NormedAddCommGroup E''] [NormedAddCommGroup F''] {f'' : αE''} {g'' : αF''} {l : Filter α} (h : f'' =O[l] g'') :
∀ᶠ (x : α) in l, g'' x = 0f'' x = 0

Addition and subtraction #

theorem Asymptotics.IsBigOWith.add {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c₁ c₂ : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : IsBigOWith c₂ l f₂ g) :
IsBigOWith (c₁ + c₂) l (fun (x : α) => f₁ x + f₂ x) g
theorem Asymptotics.IsBigO.add {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =O[l] g) (h₂ : f₂ =O[l] g) :
(fun (x : α) => f₁ x + f₂ x) =O[l] g
theorem Asymptotics.IsLittleO.add {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =o[l] g) (h₂ : f₂ =o[l] g) :
(fun (x : α) => f₁ x + f₂ x) =o[l] g
theorem Asymptotics.IsBigOWith.add_add {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {c₁ c₂ : } {l : Filter α} {f₁ f₂ : αE'} {g₁ g₂ : α} (h₁ : IsBigOWith c₁ l f₁ g₁) (h₂ : IsBigOWith c₂ l f₂ g₂) :
IsBigOWith (max c₁ c₂) l (fun (x : α) => f₁ x + f₂ x) fun (x : α) => g₁ x + g₂ x
theorem Asymptotics.IsBigO.add_add {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {f₁ f₂ : αE'} {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
theorem Asymptotics.IsLittleO.add_add {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] {l : Filter α} {f₁ f₂ : αE'} {g₁ g₂ : αF'} (h₁ : f₁ =o[l] g₁) (h₂ : f₂ =o[l] g₂) :
(fun (x : α) => f₁ x + f₂ x) =o[l] fun (x : α) => g₁ x + g₂ x
theorem Asymptotics.IsBigO.add_isLittleO {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =O[l] g) (h₂ : f₂ =o[l] g) :
(fun (x : α) => f₁ x + f₂ x) =O[l] g
theorem Asymptotics.IsLittleO.add_isBigO {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =o[l] g) (h₂ : f₂ =O[l] g) :
(fun (x : α) => f₁ x + f₂ x) =O[l] g
theorem Asymptotics.IsBigOWith.add_isLittleO {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c₁ c₂ : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : f₂ =o[l] g) (hc : c₁ < c₂) :
IsBigOWith c₂ l (fun (x : α) => f₁ x + f₂ x) g
theorem Asymptotics.IsLittleO.add_isBigOWith {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c₁ c₂ : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =o[l] g) (h₂ : IsBigOWith c₁ l f₂ g) (hc : c₁ < c₂) :
IsBigOWith c₂ l (fun (x : α) => f₁ x + f₂ x) g
theorem Asymptotics.IsBigOWith.sub {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c₁ c₂ : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : IsBigOWith c₂ l f₂ g) :
IsBigOWith (c₁ + c₂) l (fun (x : α) => f₁ x - f₂ x) g
theorem Asymptotics.IsBigOWith.sub_isLittleO {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c₁ c₂ : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : IsBigOWith c₁ l f₁ g) (h₂ : f₂ =o[l] g) (hc : c₁ < c₂) :
IsBigOWith c₂ l (fun (x : α) => f₁ x - f₂ x) g
theorem Asymptotics.IsBigO.sub {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =O[l] g) (h₂ : f₂ =O[l] g) :
(fun (x : α) => f₁ x - f₂ x) =O[l] g
theorem Asymptotics.IsLittleO.sub {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =o[l] g) (h₂ : f₂ =o[l] g) :
(fun (x : α) => f₁ x - f₂ x) =o[l] g
theorem Asymptotics.IsBigO.add_iff_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₂ : f₂ =O[l] g) :
(fun (x : α) => f₁ x + f₂ x) =O[l] g f₁ =O[l] g
theorem Asymptotics.IsBigO.add_iff_right {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =O[l] g) :
(fun (x : α) => f₁ x + f₂ x) =O[l] g f₂ =O[l] g
theorem Asymptotics.IsLittleO.add_iff_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₂ : f₂ =o[l] g) :
(fun (x : α) => f₁ x + f₂ x) =o[l] g f₁ =o[l] g
theorem Asymptotics.IsLittleO.add_iff_right {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =o[l] g) :
(fun (x : α) => f₁ x + f₂ x) =o[l] g f₂ =o[l] g
theorem Asymptotics.IsBigO.sub_iff_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₂ : f₂ =O[l] g) :
(fun (x : α) => f₁ x - f₂ x) =O[l] g f₁ =O[l] g
theorem Asymptotics.IsBigO.sub_iff_right {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =O[l] g) :
(fun (x : α) => f₁ x - f₂ x) =O[l] g f₂ =O[l] g
theorem Asymptotics.IsLittleO.sub_iff_left {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₂ : f₂ =o[l] g) :
(fun (x : α) => f₁ x - f₂ x) =o[l] g f₁ =o[l] g
theorem Asymptotics.IsLittleO.sub_iff_right {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h₁ : f₁ =o[l] g) :
(fun (x : α) => f₁ x - f₂ x) =o[l] g f₂ =o[l] g

Lemmas about IsBigO (f₁ - f₂) g l / IsLittleO (f₁ - f₂) g l treated as a binary relation #

theorem Asymptotics.IsBigOWith.symm {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h : IsBigOWith c l (fun (x : α) => f₁ x - f₂ x) g) :
IsBigOWith c l (fun (x : α) => f₂ x - f₁ x) g
theorem Asymptotics.isBigOWith_comm {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c : } {g : αF} {l : Filter α} {f₁ f₂ : αE'} :
IsBigOWith c l (fun (x : α) => f₁ x - f₂ x) g IsBigOWith c l (fun (x : α) => f₂ x - f₁ x) g
theorem Asymptotics.IsBigO.symm {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h : (fun (x : α) => f₁ x - f₂ x) =O[l] g) :
(fun (x : α) => f₂ x - f₁ x) =O[l] g
theorem Asymptotics.isBigO_comm {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} :
(fun (x : α) => f₁ x - f₂ x) =O[l] g (fun (x : α) => f₂ x - f₁ x) =O[l] g
theorem Asymptotics.IsLittleO.symm {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h : (fun (x : α) => f₁ x - f₂ x) =o[l] g) :
(fun (x : α) => f₂ x - f₁ x) =o[l] g
theorem Asymptotics.isLittleO_comm {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} :
(fun (x : α) => f₁ x - f₂ x) =o[l] g (fun (x : α) => f₂ x - f₁ x) =o[l] g
theorem Asymptotics.IsBigOWith.triangle {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {c c' : } {g : αF} {l : Filter α} {f₁ f₂ f₃ : αE'} (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
theorem Asymptotics.IsBigO.triangle {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ f₃ : αE'} (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
theorem Asymptotics.IsLittleO.triangle {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ f₃ : αE'} (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
theorem Asymptotics.IsBigO.congr_of_sub {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h : (fun (x : α) => f₁ x - f₂ x) =O[l] g) :
f₁ =O[l] g f₂ =O[l] g
theorem Asymptotics.IsLittleO.congr_of_sub {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {f₁ f₂ : αE'} (h : (fun (x : α) => f₁ x - f₂ x) =o[l] g) :
f₁ =o[l] g f₂ =o[l] g

Zero and other constants #

theorem Asymptotics.isLittleO_zero {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] (g' : αF') (l : Filter α) :
(fun (_x : α) => 0) =o[l] g'
theorem Asymptotics.isBigOWith_zero {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] {c : } (g' : αF') (l : Filter α) (hc : 0 c) :
IsBigOWith c l (fun (_x : α) => 0) g'
theorem Asymptotics.isBigOWith_zero' {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] (g : αF) (l : Filter α) :
IsBigOWith 0 l (fun (_x : α) => 0) g
theorem Asymptotics.isBigO_zero {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] (g : αF) (l : Filter α) :
(fun (_x : α) => 0) =O[l] g
theorem Asymptotics.isBigO_refl_left {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] {f' : αE'} (g' : αF') (l : Filter α) :
(fun (x : α) => f' x - f' x) =O[l] g'
theorem Asymptotics.isLittleO_refl_left {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] {f' : αE'} (g' : αF') (l : Filter α) :
(fun (x : α) => f' x - f' x) =o[l] g'
@[simp]
theorem Asymptotics.isBigOWith_zero_right_iff {α : Type u_1} {F' : Type u_5} {E'' : Type u_6} [SeminormedAddCommGroup F'] [NormedAddCommGroup E''] {c : } {f'' : αE''} {l : Filter α} :
(IsBigOWith c l f'' fun (_x : α) => 0) f'' =ᶠ[l] 0
@[simp]
theorem Asymptotics.isBigO_zero_right_iff {α : Type u_1} {F' : Type u_5} {E'' : Type u_6} [SeminormedAddCommGroup F'] [NormedAddCommGroup E''] {f'' : αE''} {l : Filter α} :
(f'' =O[l] fun (_x : α) => 0) f'' =ᶠ[l] 0
@[simp]
theorem Asymptotics.isLittleO_zero_right_iff {α : Type u_1} {F' : Type u_5} {E'' : Type u_6} [SeminormedAddCommGroup F'] [NormedAddCommGroup E''] {f'' : αE''} {l : Filter α} :
(f'' =o[l] fun (_x : α) => 0) f'' =ᶠ[l] 0
theorem Asymptotics.isBigOWith_const_const {α : Type u_1} {E : Type u_2} {F'' : Type u_7} [Norm E] [NormedAddCommGroup F''] (c : E) {c' : F''} (hc' : c' 0) (l : Filter α) :
IsBigOWith (c / c') l (fun (_x : α) => c) fun (_x : α) => c'
theorem Asymptotics.isBigO_const_const {α : Type u_1} {E : Type u_2} {F'' : Type u_7} [Norm E] [NormedAddCommGroup F''] (c : E) {c' : F''} (hc' : c' 0) (l : Filter α) :
(fun (_x : α) => c) =O[l] fun (_x : α) => c'
@[simp]
theorem Asymptotics.isBigO_const_const_iff {α : Type u_1} {E'' : Type u_6} {F'' : Type u_7} [NormedAddCommGroup E''] [NormedAddCommGroup F''] {c : E''} {c' : F''} (l : Filter α) [l.NeBot] :
((fun (_x : α) => c) =O[l] fun (_x : α) => c') c' = 0c = 0
@[simp]
theorem Asymptotics.isBigO_pure {α : Type u_1} {E'' : Type u_6} {F'' : Type u_7} [NormedAddCommGroup E''] [NormedAddCommGroup F''] {f'' : αE''} {g'' : αF''} {x : α} :
f'' =O[pure x] g'' g'' x = 0f'' x = 0

Sum #

theorem Asymptotics.IsBigOWith.sum {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {ι : Type u_8} {A : ιαE'} {C : ι} {s : Finset ι} (h : is, IsBigOWith (C i) l (A i) g) :
IsBigOWith (∑ is, C i) l (∑ is, A i) g
theorem Asymptotics.IsBigOWith.fun_sum {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {ι : Type u_8} {A : ιαE'} {C : ι} {s : Finset ι} (h : is, IsBigOWith (C i) l (A i) g) :
IsBigOWith (∑ is, C i) l (fun (a : α) => cs, A c a) g

Eta-expanded form of Asymptotics.IsBigOWith.sum

theorem Asymptotics.IsBigO.sum {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {ι : Type u_8} {A : ιαE'} {s : Finset ι} (h : is, A i =O[l] g) :
(∑ is, A i) =O[l] g
theorem Asymptotics.IsBigO.fun_sum {α : Type u_1} {F : Type u_3} {E' : Type u_4} [Norm F] [SeminormedAddCommGroup E'] {g : αF} {l : Filter α} {ι : Type u_8} {A : ιαE'} {s : Finset ι} (h : is, A i =O[l] g) :
(fun (a : α) => cs, A c a) =O[l] g

Eta-expanded form of Asymptotics.IsBigO.sum

theorem Asymptotics.IsLittleO.sum {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] {g' : αF'} {l : Filter α} {ι : Type u_8} {A : ιαE'} {s : Finset ι} (h : is, A i =o[l] g') :
(∑ is, A i) =o[l] g'
theorem Asymptotics.IsLittleO.fun_sum {α : Type u_1} {E' : Type u_4} {F' : Type u_5} [SeminormedAddCommGroup E'] [SeminormedAddCommGroup F'] {g' : αF'} {l : Filter α} {ι : Type u_8} {A : ιαE'} {s : Finset ι} (h : is, A i =o[l] g') :
(fun (a : α) => cs, A c a) =o[l] g'

Eta-expanded form of Asymptotics.IsLittleO.sum

theorem Asymptotics.IsBigOWith.sum_congr {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ιαE'} {C : ι} {s : Finset ι} {B : ια} (hAB : is, IsBigOWith (C i) l (A i) (B i)) :
IsBigOWith (sSup (C '' s)) l (fun (H : α) => is, A i H) fun (H : α) => is, B i H

If each term A i of a sum IsBigO of B i, then the sum of the A i IsBigO of the sum of the norms of the B i.

theorem Asymptotics.IsBigO.sum_congr {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ιαE'} {s : Finset ι} {B : ια} (hAB : is, A i =O[l] B i) :
(fun (H : α) => is, A i H) =O[l] fun (H : α) => is, B i H
theorem Asymptotics.IsLittleO.sum_congr {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ιαE'} {s : Finset ι} {B : ια} (hAB : is, A i =o[l] B i) :
(fun (H : α) => is, A i H) =o[l] fun (H : α) => is, B i H
theorem Asymptotics.IsBigOWith.sum_congr' {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ιαE'} {B : ια} {C : } {i : αFinset ι} (hAB : IsBigOWith C ( ×ˢ l) (Function.uncurry A) (Function.uncurry B)) :
IsBigOWith C l (fun (H : α) => ji H, A j H) fun (H : α) => ji H, B j H

Similar to IsBigOWith.sum_congr except the index set can change in the sum. This requires the constant in hAB to be independent of the index i and also the big-O relationship to "kick in" at the same point along the running variable. Hence the in ⊤ ×ˢ l.

theorem Asymptotics.IsBigO.sum_congr' {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ιαE'} {B : ια} {i : αFinset ι} (hAB : Function.uncurry A =O[ ×ˢ l] Function.uncurry B) :
(fun (H : α) => ji H, A j H) =O[l] fun (H : α) => ji H, B j H
theorem Asymptotics.IsLittleO.sum_congr' {α : Type u_1} {E' : Type u_4} [SeminormedAddCommGroup E'] {l : Filter α} {ι : Type u_8} {A : ιαE'} {B : ια} {i : αFinset ι} (hAB : Function.uncurry A =o[ ×ˢ l] Function.uncurry B) :
(fun (H : α) => ji H, A j H) =o[l] fun (H : α) => ji H, B j H