order.filter.zero_and_bounded_at_filter

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

f2ce6086

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

4f4a1c87

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -101,7 +101,7 @@ def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
 theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : ZeroAtFilter l f) : BoundedAtFilter l f :=
   by
-  rw [zero_at_filter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf 
+  rw [zero_at_filter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf
   exact hf.is_O
 #align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilter
 -/

4f4a1c87

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2022 Chris Birkbeck. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Birkbeck, David Loeffler
 -/
-import Mathbin.Algebra.Module.Submodule.Basic
-import Mathbin.Topology.Algebra.Monoid
-import Mathbin.Analysis.Asymptotics.Asymptotics
+import Algebra.Module.Submodule.Basic
+import Topology.Algebra.Monoid
+import Analysis.Asymptotics.Asymptotics
 
 #align_import order.filter.zero_and_bounded_at_filter from "leanprover-community/mathlib"@"4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b"

4f4a1c87

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Chris Birkbeck. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Birkbeck, David Loeffler
-
-! This file was ported from Lean 3 source module order.filter.zero_and_bounded_at_filter
-! leanprover-community/mathlib commit 4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Module.Submodule.Basic
 import Mathbin.Topology.Algebra.Monoid
 import Mathbin.Analysis.Asymptotics.Asymptotics
 
+#align_import order.filter.zero_and_bounded_at_filter from "leanprover-community/mathlib"@"4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b"
+
 /-!
 # Zero and Bounded at filter

4f4a1c87

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -47,14 +47,18 @@ theorem zero_zeroAtFilter [Zero β] [TopologicalSpace β] (l : Filter α) :
 #align filter.zero_zero_at_filter Filter.zero_zeroAtFilter
 -/
 
+#print Filter.ZeroAtFilter.add /-
 theorem ZeroAtFilter.add [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd β] {l : Filter α}
     {f g : α → β} (hf : ZeroAtFilter l f) (hg : ZeroAtFilter l g) : ZeroAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.zero_at_filter.add Filter.ZeroAtFilter.add
+-/
 
+#print Filter.ZeroAtFilter.neg /-
 theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [ContinuousNeg β] {l : Filter α}
     {f : α → β} (hf : ZeroAtFilter l f) : ZeroAtFilter l (-f) := by simpa using hf.neg
 #align filter.zero_at_filter.neg Filter.ZeroAtFilter.neg
+-/
 
 #print Filter.ZeroAtFilter.smul /-
 theorem ZeroAtFilter.smul {𝕜 : Type _} [TopologicalSpace 𝕜] [TopologicalSpace β] [Zero 𝕜] [Zero β]
@@ -63,6 +67,7 @@ theorem ZeroAtFilter.smul {𝕜 : Type _} [TopologicalSpace 𝕜] [TopologicalSp
 #align filter.zero_at_filter.smul Filter.ZeroAtFilter.smul
 -/
 
+#print Filter.zeroAtFilterSubmodule /-
 /-- `zero_at_filter_submodule l` is the submodule of `f : α → β` which
 tend to zero along `l`. -/
 def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β] [ContinuousMul β]
@@ -73,7 +78,9 @@ def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β]
   add_mem' a b ha hb := ha.add hb
   smul_mem' c f hf := hf.smul c
 #align filter.zero_at_filter_submodule Filter.zeroAtFilterSubmodule
+-/
 
+#print Filter.zeroAtFilterAddSubmonoid /-
 /-- `zero_at_filter_add_submonoid l` is the additive submonoid of `f : α → β`
 which tend to zero along `l`. -/
 def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd β]
@@ -83,6 +90,7 @@ def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [Continuous
   add_mem' a b ha hb := ha.add hb
   zero_mem' := zero_zeroAtFilter l
 #align filter.zero_at_filter_add_submonoid Filter.zeroAtFilterAddSubmonoid
+-/
 
 #print Filter.BoundedAtFilter /-
 /-- If `l` is a filter on `α`, then a function `f: α → β` is `bounded_at_filter l`
@@ -92,12 +100,14 @@ def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
 #align filter.bounded_at_filter Filter.BoundedAtFilter
 -/
 
+#print Filter.ZeroAtFilter.boundedAtFilter /-
 theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : ZeroAtFilter l f) : BoundedAtFilter l f :=
   by
   rw [zero_at_filter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf 
   exact hf.is_O
 #align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilter
+-/
 
 #print Filter.const_boundedAtFilter /-
 theorem const_boundedAtFilter [NormedField β] (l : Filter α) (c : β) :
@@ -106,15 +116,19 @@ theorem const_boundedAtFilter [NormedField β] (l : Filter α) (c : β) :
 #align filter.const_bounded_at_filter Filter.const_boundedAtFilter
 -/
 
+#print Filter.BoundedAtFilter.add /-
 theorem BoundedAtFilter.add [NormedAddCommGroup β] {l : Filter α} {f g : α → β}
     (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.bounded_at_filter.add Filter.BoundedAtFilter.add
+-/
 
+#print Filter.BoundedAtFilter.neg /-
 theorem BoundedAtFilter.neg [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : BoundedAtFilter l f) : BoundedAtFilter l (-f) :=
   hf.neg_left
 #align filter.bounded_at_filter.neg Filter.BoundedAtFilter.neg
+-/
 
 #print Filter.BoundedAtFilter.smul /-
 theorem BoundedAtFilter.smul {𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup β] [NormedSpace 𝕜 β]
@@ -123,6 +137,7 @@ theorem BoundedAtFilter.smul {𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGr
 #align filter.bounded_at_filter.smul Filter.BoundedAtFilter.smul
 -/
 
+#print Filter.BoundedAtFilter.mul /-
 theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β} (hf : BoundedAtFilter l f)
     (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g) :=
   by
@@ -131,6 +146,7 @@ theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β} (
   ext x
   simp
 #align filter.bounded_at_filter.mul Filter.BoundedAtFilter.mul
+-/
 
 #print Filter.boundedFilterSubmodule /-
 /-- The submodule of functions that are bounded along a filter `l`. -/

4f4a1c87

bump to nightly-2023-06-01-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

b9c87c70

Diff

@@ -95,7 +95,7 @@ def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
 theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : ZeroAtFilter l f) : BoundedAtFilter l f :=
   by
-  rw [zero_at_filter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf
+  rw [zero_at_filter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf 
   exact hf.is_O
 #align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilter

4f4a1c87

bump to nightly-2023-05-28-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

8d353152

Diff

@@ -30,7 +30,7 @@ namespace Filter
 
 variable {α β : Type _}
 
-open Topology
+open scoped Topology
 
 #print Filter.ZeroAtFilter /-
 /-- If `l` is a filter on `α`, then a function `f : α → β` is `zero_at_filter l`

4f4a1c87

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -47,23 +47,11 @@ theorem zero_zeroAtFilter [Zero β] [TopologicalSpace β] (l : Filter α) :
 #align filter.zero_zero_at_filter Filter.zero_zeroAtFilter
 -/
 
-/- warning: filter.zero_at_filter.add -> Filter.ZeroAtFilter.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toHasAdd.{u2} β _inst_2)] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β _inst_2) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β _inst_2) _inst_1 l g) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β _inst_2) _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β _inst_2))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toAdd.{u2} β _inst_2)] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toZero.{u2} β _inst_2) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toZero.{u2} β _inst_2) _inst_1 l g) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toZero.{u2} β _inst_2) _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u2} β _inst_2))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter.add Filter.ZeroAtFilter.addₓ'. -/
 theorem ZeroAtFilter.add [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd β] {l : Filter α}
     {f g : α → β} (hf : ZeroAtFilter l f) (hg : ZeroAtFilter l g) : ZeroAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.zero_at_filter.add Filter.ZeroAtFilter.add
 
-/- warning: filter.zero_at_filter.neg -> Filter.ZeroAtFilter.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddGroup.{u2} β] [_inst_3 : ContinuousNeg.{u2} β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2))] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2)))) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2)))) _inst_1 l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2))) f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddGroup.{u2} β] [_inst_3 : ContinuousNeg.{u2} β _inst_1 (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2))))] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2)))) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2)))) _inst_1 l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2))))) f))
-Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter.neg Filter.ZeroAtFilter.negₓ'. -/
 theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [ContinuousNeg β] {l : Filter α}
     {f : α → β} (hf : ZeroAtFilter l f) : ZeroAtFilter l (-f) := by simpa using hf.neg
 #align filter.zero_at_filter.neg Filter.ZeroAtFilter.neg
@@ -75,12 +63,6 @@ theorem ZeroAtFilter.smul {𝕜 : Type _} [TopologicalSpace 𝕜] [TopologicalSp
 #align filter.zero_at_filter.smul Filter.ZeroAtFilter.smul
 -/
 
-/- warning: filter.zero_at_filter_submodule -> Filter.zeroAtFilterSubmodule is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : Semiring.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (Distrib.toHasAdd.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))))] [_inst_4 : ContinuousMul.{u2} β _inst_1 (Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))))], (Filter.{u1} α) -> (Submodule.{u2, max u1 u2} β (α -> β) _inst_2 (Pi.addCommMonoid.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2)))) (Pi.Function.module.{u1, u2, u2} α β β _inst_2 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))) (Semiring.toModule.{u2} β _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : Semiring.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (Distrib.toAdd.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))))] [_inst_4 : ContinuousMul.{u2} β _inst_1 (NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2)))], (Filter.{u1} α) -> (Submodule.{u2, max u1 u2} β (α -> β) _inst_2 (Pi.addCommMonoid.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2)))) (Pi.module.{u1, u2, u2} α (fun (a._@.Mathlib.Order.Filter.ZeroAndBoundedAtFilter._hyg.224 : α) => β) β _inst_2 (fun (i : α) => NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))) (fun (i : α) => Semiring.toModule.{u2} β _inst_2)))
-Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter_submodule Filter.zeroAtFilterSubmoduleₓ'. -/
 /-- `zero_at_filter_submodule l` is the submodule of `f : α → β` which
 tend to zero along `l`. -/
 def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β] [ContinuousMul β]
@@ -92,12 +74,6 @@ def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β]
   smul_mem' c f hf := hf.smul c
 #align filter.zero_at_filter_submodule Filter.zeroAtFilterSubmodule
 
-/- warning: filter.zero_at_filter_add_submonoid -> Filter.zeroAtFilterAddSubmonoid is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toHasAdd.{u2} β _inst_2)], (Filter.{u1} α) -> (AddSubmonoid.{max u1 u2} (α -> β) (Pi.addZeroClass.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toAdd.{u2} β _inst_2)], (Filter.{u1} α) -> (AddSubmonoid.{max u1 u2} (α -> β) (Pi.addZeroClass.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)))
-Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter_add_submonoid Filter.zeroAtFilterAddSubmonoidₓ'. -/
 /-- `zero_at_filter_add_submonoid l` is the additive submonoid of `f : α → β`
 which tend to zero along `l`. -/
 def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd β]
@@ -116,12 +92,6 @@ def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
 #align filter.bounded_at_filter Filter.BoundedAtFilter
 -/
 
-/- warning: filter.zero_at_filter.bounded_at_filter -> Filter.ZeroAtFilter.boundedAtFilter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l f)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (NormedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l f)
-Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilterₓ'. -/
 theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : ZeroAtFilter l f) : BoundedAtFilter l f :=
   by
@@ -136,23 +106,11 @@ theorem const_boundedAtFilter [NormedField β] (l : Filter α) (c : β) :
 #align filter.const_bounded_at_filter Filter.const_boundedAtFilter
 -/
 
-/- warning: filter.bounded_at_filter.add -> Filter.BoundedAtFilter.add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.bounded_at_filter.add Filter.BoundedAtFilter.addₓ'. -/
 theorem BoundedAtFilter.add [NormedAddCommGroup β] {l : Filter α} {f g : α → β}
     (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.bounded_at_filter.add Filter.BoundedAtFilter.add
 
-/- warning: filter.bounded_at_filter.neg -> Filter.BoundedAtFilter.neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1))))) f))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (NormedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))))) f))
-Case conversion may be inaccurate. Consider using '#align filter.bounded_at_filter.neg Filter.BoundedAtFilter.negₓ'. -/
 theorem BoundedAtFilter.neg [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : BoundedAtFilter l f) : BoundedAtFilter l (-f) :=
   hf.neg_left
@@ -165,12 +123,6 @@ theorem BoundedAtFilter.smul {𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGr
 #align filter.bounded_at_filter.smul Filter.BoundedAtFilter.smul
 -/
 
-/- warning: filter.bounded_at_filter.mul -> Filter.BoundedAtFilter.mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toHasNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toHasNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toHasNorm.{u2} β _inst_1) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) f g))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toNorm.{u2} β _inst_1) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))) f g))
-Case conversion may be inaccurate. Consider using '#align filter.bounded_at_filter.mul Filter.BoundedAtFilter.mulₓ'. -/
 theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β} (hf : BoundedAtFilter l f)
     (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g) :=
   by

4f4a1c87

bump to nightly-2023-04-16-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b

63127953

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Birkbeck, David Loeffler
 
 ! This file was ported from Lean 3 source module order.filter.zero_and_bounded_at_filter
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
+! leanprover-community/mathlib commit 4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Analysis.Asymptotics.Asymptotics
 /-!
 # Zero and Bounded at filter
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Given a filter `l` we define the notion of a function being `zero_at_filter` as well as being
 `bounded_at_filter`. Alongside this we construct the `submodule`, `add_submonoid` of functions
 that are `zero_at_filter`. Similarly, we construct the `submodule` and `subalgebra` of functions

f2ce6086

bump to nightly-2023-04-14-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/7ebf83ed9c262adbf983ef64d5e8c2ae94b625f4

60fdc414

Diff

@@ -29,31 +29,55 @@ variable {α β : Type _}
 
 open Topology
 
+#print Filter.ZeroAtFilter /-
 /-- If `l` is a filter on `α`, then a function `f : α → β` is `zero_at_filter l`
   if it tends to zero along `l`. -/
 def ZeroAtFilter [Zero β] [TopologicalSpace β] (l : Filter α) (f : α → β) : Prop :=
   Filter.Tendsto f l (𝓝 0)
 #align filter.zero_at_filter Filter.ZeroAtFilter
+-/
 
+#print Filter.zero_zeroAtFilter /-
 theorem zero_zeroAtFilter [Zero β] [TopologicalSpace β] (l : Filter α) :
     ZeroAtFilter l (0 : α → β) :=
   tendsto_const_nhds
 #align filter.zero_zero_at_filter Filter.zero_zeroAtFilter
+-/
 
+/- warning: filter.zero_at_filter.add -> Filter.ZeroAtFilter.add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toHasAdd.{u2} β _inst_2)] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β _inst_2) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β _inst_2) _inst_1 l g) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β _inst_2) _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β _inst_2))) f g))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toAdd.{u2} β _inst_2)] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toZero.{u2} β _inst_2) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toZero.{u2} β _inst_2) _inst_1 l g) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toZero.{u2} β _inst_2) _inst_1 l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u2} β _inst_2))) f g))
+Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter.add Filter.ZeroAtFilter.addₓ'. -/
 theorem ZeroAtFilter.add [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd β] {l : Filter α}
     {f g : α → β} (hf : ZeroAtFilter l f) (hg : ZeroAtFilter l g) : ZeroAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.zero_at_filter.add Filter.ZeroAtFilter.add
 
+/- warning: filter.zero_at_filter.neg -> Filter.ZeroAtFilter.neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddGroup.{u2} β] [_inst_3 : ContinuousNeg.{u2} β _inst_1 (SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2))] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2)))) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2)))) _inst_1 l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β _inst_2))) f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddGroup.{u2} β] [_inst_3 : ContinuousNeg.{u2} β _inst_1 (NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2))))] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2)))) _inst_1 l f) -> (Filter.ZeroAtFilter.{u1, u2} α β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2)))) _inst_1 l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (AddGroup.toSubtractionMonoid.{u2} β _inst_2))))) f))
+Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter.neg Filter.ZeroAtFilter.negₓ'. -/
 theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [ContinuousNeg β] {l : Filter α}
     {f : α → β} (hf : ZeroAtFilter l f) : ZeroAtFilter l (-f) := by simpa using hf.neg
 #align filter.zero_at_filter.neg Filter.ZeroAtFilter.neg
 
+#print Filter.ZeroAtFilter.smul /-
 theorem ZeroAtFilter.smul {𝕜 : Type _} [TopologicalSpace 𝕜] [TopologicalSpace β] [Zero 𝕜] [Zero β]
     [SMulWithZero 𝕜 β] [ContinuousSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜)
     (hf : ZeroAtFilter l f) : ZeroAtFilter l (c • f) := by simpa using hf.const_smul c
 #align filter.zero_at_filter.smul Filter.ZeroAtFilter.smul
+-/
 
+/- warning: filter.zero_at_filter_submodule -> Filter.zeroAtFilterSubmodule is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : Semiring.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (Distrib.toHasAdd.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))))] [_inst_4 : ContinuousMul.{u2} β _inst_1 (Distrib.toHasMul.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))))], (Filter.{u1} α) -> (Submodule.{u2, max u1 u2} β (α -> β) _inst_2 (Pi.addCommMonoid.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2)))) (Pi.Function.module.{u1, u2, u2} α β β _inst_2 (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))) (Semiring.toModule.{u2} β _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : Semiring.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (Distrib.toAdd.{u2} β (NonUnitalNonAssocSemiring.toDistrib.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))))] [_inst_4 : ContinuousMul.{u2} β _inst_1 (NonUnitalNonAssocSemiring.toMul.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2)))], (Filter.{u1} α) -> (Submodule.{u2, max u1 u2} β (α -> β) _inst_2 (Pi.addCommMonoid.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2)))) (Pi.module.{u1, u2, u2} α (fun (a._@.Mathlib.Order.Filter.ZeroAndBoundedAtFilter._hyg.224 : α) => β) β _inst_2 (fun (i : α) => NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} β (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u2} β (Semiring.toNonAssocSemiring.{u2} β _inst_2))) (fun (i : α) => Semiring.toModule.{u2} β _inst_2)))
+Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter_submodule Filter.zeroAtFilterSubmoduleₓ'. -/
 /-- `zero_at_filter_submodule l` is the submodule of `f : α → β` which
 tend to zero along `l`. -/
 def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β] [ContinuousMul β]
@@ -65,6 +89,12 @@ def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β]
   smul_mem' c f hf := hf.smul c
 #align filter.zero_at_filter_submodule Filter.zeroAtFilterSubmodule
 
+/- warning: filter.zero_at_filter_add_submonoid -> Filter.zeroAtFilterAddSubmonoid is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toHasAdd.{u2} β _inst_2)], (Filter.{u1} α) -> (AddSubmonoid.{max u1 u2} (α -> β) (Pi.addZeroClass.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : TopologicalSpace.{u2} β] [_inst_2 : AddZeroClass.{u2} β] [_inst_3 : ContinuousAdd.{u2} β _inst_1 (AddZeroClass.toAdd.{u2} β _inst_2)], (Filter.{u1} α) -> (AddSubmonoid.{max u1 u2} (α -> β) (Pi.addZeroClass.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => _inst_2)))
+Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter_add_submonoid Filter.zeroAtFilterAddSubmonoidₓ'. -/
 /-- `zero_at_filter_add_submonoid l` is the additive submonoid of `f : α → β`
 which tend to zero along `l`. -/
 def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd β]
@@ -75,12 +105,20 @@ def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [Continuous
   zero_mem' := zero_zeroAtFilter l
 #align filter.zero_at_filter_add_submonoid Filter.zeroAtFilterAddSubmonoid
 
+#print Filter.BoundedAtFilter /-
 /-- If `l` is a filter on `α`, then a function `f: α → β` is `bounded_at_filter l`
 if `f =O[l] 1`. -/
 def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
   Asymptotics.IsBigO l f (1 : α → ℝ)
 #align filter.bounded_at_filter Filter.BoundedAtFilter
+-/
 
+/- warning: filter.zero_at_filter.bounded_at_filter -> Filter.ZeroAtFilter.boundedAtFilter is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (AddZeroClass.toHasZero.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))) (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l f)
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.ZeroAtFilter.{u1, u2} α β (NegZeroClass.toZero.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (NormedAddCommGroup.toAddCommGroup.{u2} β _inst_1)))))) (UniformSpace.toTopologicalSpace.{u2} β (PseudoMetricSpace.toUniformSpace.{u2} β (SeminormedAddCommGroup.toPseudoMetricSpace.{u2} β (NormedAddCommGroup.toSeminormedAddCommGroup.{u2} β _inst_1)))) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l f)
+Case conversion may be inaccurate. Consider using '#align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilterₓ'. -/
 theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : ZeroAtFilter l f) : BoundedAtFilter l f :=
   by
@@ -88,26 +126,48 @@ theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f
   exact hf.is_O
 #align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilter
 
+#print Filter.const_boundedAtFilter /-
 theorem const_boundedAtFilter [NormedField β] (l : Filter α) (c : β) :
     BoundedAtFilter l (Function.const α c : α → β) :=
   Asymptotics.isBigO_const_const c one_ne_zero l
 #align filter.const_bounded_at_filter Filter.const_boundedAtFilter
+-/
 
+/- warning: filter.bounded_at_filter.add -> Filter.BoundedAtFilter.add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toHasAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) f g))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l (HAdd.hAdd.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHAdd.{max u1 u2} (α -> β) (Pi.instAdd.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => AddZeroClass.toAdd.{u2} β (AddMonoid.toAddZeroClass.{u2} β (SubNegMonoid.toAddMonoid.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1)))))))) f g))
+Case conversion may be inaccurate. Consider using '#align filter.bounded_at_filter.add Filter.BoundedAtFilter.addₓ'. -/
 theorem BoundedAtFilter.add [NormedAddCommGroup β] {l : Filter α} {f g : α → β}
     (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.bounded_at_filter.add Filter.BoundedAtFilter.add
 
+/- warning: filter.bounded_at_filter.neg -> Filter.BoundedAtFilter.neg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toHasNorm.{u2} β _inst_1) l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => SubNegMonoid.toHasNeg.{u2} β (AddGroup.toSubNegMonoid.{u2} β (NormedAddGroup.toAddGroup.{u2} β (NormedAddCommGroup.toNormedAddGroup.{u2} β _inst_1))))) f))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedAddCommGroup.{u2} β] {l : Filter.{u1} α} {f : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedAddCommGroup.toNorm.{u2} β _inst_1) l (Neg.neg.{max u1 u2} (α -> β) (Pi.instNeg.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NegZeroClass.toNeg.{u2} β (SubNegZeroMonoid.toNegZeroClass.{u2} β (SubtractionMonoid.toSubNegZeroMonoid.{u2} β (SubtractionCommMonoid.toSubtractionMonoid.{u2} β (AddCommGroup.toDivisionAddCommMonoid.{u2} β (NormedAddCommGroup.toAddCommGroup.{u2} β _inst_1))))))) f))
+Case conversion may be inaccurate. Consider using '#align filter.bounded_at_filter.neg Filter.BoundedAtFilter.negₓ'. -/
 theorem BoundedAtFilter.neg [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : BoundedAtFilter l f) : BoundedAtFilter l (-f) :=
   hf.neg_left
 #align filter.bounded_at_filter.neg Filter.BoundedAtFilter.neg
 
+#print Filter.BoundedAtFilter.smul /-
 theorem BoundedAtFilter.smul {𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup β] [NormedSpace 𝕜 β]
     {l : Filter α} {f : α → β} (c : 𝕜) (hf : BoundedAtFilter l f) : BoundedAtFilter l (c • f) :=
   hf.const_smul_left c
 #align filter.bounded_at_filter.smul Filter.BoundedAtFilter.smul
+-/
 
+/- warning: filter.bounded_at_filter.mul -> Filter.BoundedAtFilter.mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toHasNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toHasNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toHasNorm.{u2} β _inst_1) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => Distrib.toHasMul.{u2} β (Ring.toDistrib.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1))))))) f g))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : NormedField.{u2} β] {l : Filter.{u1} α} {f : α -> β} {g : α -> β}, (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toNorm.{u2} β _inst_1) l f) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toNorm.{u2} β _inst_1) l g) -> (Filter.BoundedAtFilter.{u1, u2} α β (NormedField.toNorm.{u2} β _inst_1) l (HMul.hMul.{max u1 u2, max u1 u2, max u1 u2} (α -> β) (α -> β) (α -> β) (instHMul.{max u1 u2} (α -> β) (Pi.instMul.{u1, u2} α (fun (ᾰ : α) => β) (fun (i : α) => NonUnitalNonAssocRing.toMul.{u2} β (NonAssocRing.toNonUnitalNonAssocRing.{u2} β (Ring.toNonAssocRing.{u2} β (NormedRing.toRing.{u2} β (NormedCommRing.toNormedRing.{u2} β (NormedField.toNormedCommRing.{u2} β _inst_1)))))))) f g))
+Case conversion may be inaccurate. Consider using '#align filter.bounded_at_filter.mul Filter.BoundedAtFilter.mulₓ'. -/
 theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β} (hf : BoundedAtFilter l f)
     (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g) :=
   by
@@ -117,6 +177,7 @@ theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β} (
   simp
 #align filter.bounded_at_filter.mul Filter.BoundedAtFilter.mul
 
+#print Filter.boundedFilterSubmodule /-
 /-- The submodule of functions that are bounded along a filter `l`. -/
 def boundedFilterSubmodule [NormedField β] (l : Filter α) : Submodule β (α → β)
     where
@@ -125,7 +186,9 @@ def boundedFilterSubmodule [NormedField β] (l : Filter α) : Submodule β (α 
   add_mem' f g hf hg := hf.add hg
   smul_mem' c f hf := hf.smul c
 #align filter.bounded_filter_submodule Filter.boundedFilterSubmodule
+-/
 
+#print Filter.boundedFilterSubalgebra /-
 /-- The subalgebra of functions that are bounded along a filter `l`. -/
 def boundedFilterSubalgebra [NormedField β] (l : Filter α) : Subalgebra β (α → β) :=
   by
@@ -133,6 +196,7 @@ def boundedFilterSubalgebra [NormedField β] (l : Filter α) : Subalgebra β (α
   · exact const_bounded_at_filter l (1 : β)
   · simpa only [Pi.one_apply, mul_one, norm_mul] using hf.mul hg
 #align filter.bounded_filter_subalgebra Filter.boundedFilterSubalgebra
+-/
 
 end Filter

f2ce6086

bump to nightly-2023-04-12-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/039ef89bef6e58b32b62898dd48e9d1a4312bb65

0809e5be

Diff

@@ -78,19 +78,19 @@ def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [Continuous
 /-- If `l` is a filter on `α`, then a function `f: α → β` is `bounded_at_filter l`
 if `f =O[l] 1`. -/
 def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
-  Asymptotics.IsO l f (1 : α → ℝ)
+  Asymptotics.IsBigO l f (1 : α → ℝ)
 #align filter.bounded_at_filter Filter.BoundedAtFilter
 
 theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : ZeroAtFilter l f) : BoundedAtFilter l f :=
   by
-  rw [zero_at_filter, ← Asymptotics.isOCat_const_iff (one_ne_zero' ℝ)] at hf
+  rw [zero_at_filter, ← Asymptotics.isLittleO_const_iff (one_ne_zero' ℝ)] at hf
   exact hf.is_O
 #align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilter
 
 theorem const_boundedAtFilter [NormedField β] (l : Filter α) (c : β) :
     BoundedAtFilter l (Function.const α c : α → β) :=
-  Asymptotics.isO_const_const c one_ne_zero l
+  Asymptotics.isBigO_const_const c one_ne_zero l
 #align filter.const_bounded_at_filter Filter.const_boundedAtFilter
 
 theorem BoundedAtFilter.add [NormedAddCommGroup β] {l : Filter α} {f g : α → β}
@@ -112,7 +112,7 @@ theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β} (
     (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g) :=
   by
   refine' (hf.mul hg).trans _
-  convert Asymptotics.isO_refl _ l
+  convert Asymptotics.isBigO_refl _ l
   ext x
   simp
 #align filter.bounded_at_filter.mul Filter.BoundedAtFilter.mul

f2ce6086

bump to nightly-2023-03-09-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/21e3562c5e12d846c7def5eff8cdbc520d7d4936

a3ca2eeb

Diff

@@ -77,7 +77,7 @@ def zeroAtFilterAddSubmonoid [TopologicalSpace β] [AddZeroClass β] [Continuous
 
 /-- If `l` is a filter on `α`, then a function `f: α → β` is `bounded_at_filter l`
 if `f =O[l] 1`. -/
-def BoundedAtFilter [HasNorm β] (l : Filter α) (f : α → β) : Prop :=
+def BoundedAtFilter [Norm β] (l : Filter α) (f : α → β) : Prop :=
   Asymptotics.IsO l f (1 : α → ℝ)
 #align filter.bounded_at_filter Filter.BoundedAtFilter

f2ce6086

bump to nightly-2023-02-21-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

d36dd541

Diff

@@ -45,7 +45,7 @@ theorem ZeroAtFilter.add [TopologicalSpace β] [AddZeroClass β] [ContinuousAdd
   simpa using hf.add hg
 #align filter.zero_at_filter.add Filter.ZeroAtFilter.add
 
-theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [HasContinuousNeg β] {l : Filter α}
+theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [ContinuousNeg β] {l : Filter α}
     {f : α → β} (hf : ZeroAtFilter l f) : ZeroAtFilter l (-f) := by simpa using hf.neg
 #align filter.zero_at_filter.neg Filter.ZeroAtFilter.neg

f2ce6086

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

f2ce6086

feat: generalize boundedFilterSubalgebra (#10519)

This previously only worked for normed fields, now it works for seminormed algebras. There is no particular motivation for this beyond seeing where NormedSpace is too strong.

03e3005a

Diff

@@ -6,7 +6,7 @@ Authors: Chris Birkbeck, David Loeffler
 import Mathlib.Algebra.Module.Submodule.Basic
 import Mathlib.Topology.Algebra.Monoid
 import Mathlib.Analysis.Asymptotics.Asymptotics
-import Mathlib.Analysis.NormedSpace.Basic
+import Mathlib.Algebra.Algebra.Pi
 
 #align_import order.filter.zero_and_bounded_at_filter from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
 
@@ -23,7 +23,7 @@ that are `BoundedAtFilter`.
 
 namespace Filter
 
-variable {α β : Type*}
+variable {𝕜 α β : Type*}
 
 open Topology
 
@@ -48,15 +48,18 @@ nonrec theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [ContinuousN
     {f : α → β} (hf : ZeroAtFilter l f) : ZeroAtFilter l (-f) := by simpa using hf.neg
 #align filter.zero_at_filter.neg Filter.ZeroAtFilter.neg
 
-theorem ZeroAtFilter.smul {𝕜 : Type*} [TopologicalSpace 𝕜] [TopologicalSpace β] [Zero 𝕜] [Zero β]
-    [SMulWithZero 𝕜 β] [ContinuousSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜)
+theorem ZeroAtFilter.smul [TopologicalSpace β] [Zero 𝕜] [Zero β]
+    [SMulWithZero 𝕜 β] [ContinuousConstSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜)
     (hf : ZeroAtFilter l f) : ZeroAtFilter l (c • f) := by simpa using hf.const_smul c
 #align filter.zero_at_filter.smul Filter.ZeroAtFilter.smul
 
+variable (𝕜) in
 /-- `zeroAtFilterSubmodule l` is the submodule of `f : α → β` which
 tend to zero along `l`. -/
-def zeroAtFilterSubmodule [TopologicalSpace β] [Semiring β] [ContinuousAdd β] [ContinuousMul β]
-    (l : Filter α) : Submodule β (α → β) where
+def zeroAtFilterSubmodule
+    [TopologicalSpace β] [Semiring 𝕜] [AddCommMonoid β] [Module 𝕜 β]
+    [ContinuousAdd β] [ContinuousConstSMul 𝕜 β]
+    (l : Filter α) : Submodule 𝕜 (α → β) where
   carrier := ZeroAtFilter l
   zero_mem' := zero_zeroAtFilter l
   add_mem' ha hb := ha.add hb
@@ -84,46 +87,54 @@ theorem ZeroAtFilter.boundedAtFilter [NormedAddCommGroup β] {l : Filter α} {f
   exact hf.isBigO
 #align filter.zero_at_filter.bounded_at_filter Filter.ZeroAtFilter.boundedAtFilter
 
-theorem const_boundedAtFilter [NormedField β] (l : Filter α) (c : β) :
+theorem const_boundedAtFilter [Norm β] (l : Filter α) (c : β) :
     BoundedAtFilter l (Function.const α c : α → β) :=
   Asymptotics.isBigO_const_const c one_ne_zero l
 #align filter.const_bounded_at_filter Filter.const_boundedAtFilter
 
-nonrec theorem BoundedAtFilter.add [NormedAddCommGroup β] {l : Filter α} {f g : α → β}
+nonrec theorem BoundedAtFilter.add [SeminormedAddCommGroup β] {l : Filter α} {f g : α → β}
     (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f + g) := by
   simpa using hf.add hg
 #align filter.bounded_at_filter.add Filter.BoundedAtFilter.add
 
-theorem BoundedAtFilter.neg [NormedAddCommGroup β] {l : Filter α} {f : α → β}
+theorem BoundedAtFilter.neg [SeminormedAddCommGroup β] {l : Filter α} {f : α → β}
     (hf : BoundedAtFilter l f) : BoundedAtFilter l (-f) :=
   hf.neg_left
 #align filter.bounded_at_filter.neg Filter.BoundedAtFilter.neg
 
-theorem BoundedAtFilter.smul {𝕜 : Type*} [NormedField 𝕜] [NormedAddCommGroup β] [NormedSpace 𝕜 β]
+theorem BoundedAtFilter.smul
+    [SeminormedRing 𝕜] [SeminormedAddCommGroup β] [Module 𝕜 β] [BoundedSMul 𝕜 β]
     {l : Filter α} {f : α → β} (c : 𝕜) (hf : BoundedAtFilter l f) : BoundedAtFilter l (c • f) :=
   hf.const_smul_left c
 #align filter.bounded_at_filter.smul Filter.BoundedAtFilter.smul
 
-nonrec theorem BoundedAtFilter.mul [NormedField β] {l : Filter α} {f g : α → β}
+nonrec theorem BoundedAtFilter.mul [SeminormedRing β] {l : Filter α} {f g : α → β}
     (hf : BoundedAtFilter l f) (hg : BoundedAtFilter l g) : BoundedAtFilter l (f * g) := by
   refine' (hf.mul hg).trans _
   convert Asymptotics.isBigO_refl (E := ℝ) _ l
   simp
 #align filter.bounded_at_filter.mul Filter.BoundedAtFilter.mul
 
+variable (𝕜) in
 /-- The submodule of functions that are bounded along a filter `l`. -/
-def boundedFilterSubmodule [NormedField β] (l : Filter α) : Submodule β (α → β) where
+def boundedFilterSubmodule
+    [SeminormedRing 𝕜] [SeminormedAddCommGroup β] [Module 𝕜 β] [BoundedSMul 𝕜 β] (l : Filter α) :
+    Submodule 𝕜 (α → β) where
   carrier := BoundedAtFilter l
   zero_mem' := const_boundedAtFilter l 0
   add_mem' hf hg := hf.add hg
   smul_mem' c _ hf := hf.smul c
 #align filter.bounded_filter_submodule Filter.boundedFilterSubmodule
 
+variable (𝕜) in
 /-- The subalgebra of functions that are bounded along a filter `l`. -/
-def boundedFilterSubalgebra [NormedField β] (l : Filter α) : Subalgebra β (α → β) := by
-  refine' Submodule.toSubalgebra (boundedFilterSubmodule l) _ fun f g hf hg ↦ _
-  · exact const_boundedAtFilter l (1 : β)
-  · simpa only [Pi.one_apply, mul_one, norm_mul] using hf.mul hg
+def boundedFilterSubalgebra
+    [SeminormedCommRing 𝕜] [SeminormedRing β] [Algebra 𝕜 β] [BoundedSMul 𝕜 β] (l : Filter α) :
+    Subalgebra 𝕜 (α → β) :=
+  Submodule.toSubalgebra
+    (boundedFilterSubmodule 𝕜 l)
+    (const_boundedAtFilter l (1 : β))
+    (fun f g hf hg ↦ by simpa only [Pi.one_apply, mul_one, norm_mul] using hf.mul hg)
 #align filter.bounded_filter_subalgebra Filter.boundedFilterSubalgebra
 
 end Filter

f2ce6086

feat(Analysis/Asymptotics/Asymptotics): generalize smul lemmas to normed rings (#9811)

Using BoundedSMul instead of NormedSpace makes these true more generally. The old proofs do not generalize, so are replaced with copies of the mul proofs.

The const_smul_self lemmas match the existing const_mul_self ones.

shake then reports that the imports can be reduced.

1c8f2465

Diff

@@ -6,6 +6,7 @@ Authors: Chris Birkbeck, David Loeffler
 import Mathlib.Algebra.Module.Submodule.Basic
 import Mathlib.Topology.Algebra.Monoid
 import Mathlib.Analysis.Asymptotics.Asymptotics
+import Mathlib.Analysis.NormedSpace.Basic
 
 #align_import order.filter.zero_and_bounded_at_filter from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"

f2ce6086

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -22,7 +22,7 @@ that are `BoundedAtFilter`.
 
 namespace Filter
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 open Topology
 
@@ -47,7 +47,7 @@ nonrec theorem ZeroAtFilter.neg [TopologicalSpace β] [AddGroup β] [ContinuousN
     {f : α → β} (hf : ZeroAtFilter l f) : ZeroAtFilter l (-f) := by simpa using hf.neg
 #align filter.zero_at_filter.neg Filter.ZeroAtFilter.neg
 
-theorem ZeroAtFilter.smul {𝕜 : Type _} [TopologicalSpace 𝕜] [TopologicalSpace β] [Zero 𝕜] [Zero β]
+theorem ZeroAtFilter.smul {𝕜 : Type*} [TopologicalSpace 𝕜] [TopologicalSpace β] [Zero 𝕜] [Zero β]
     [SMulWithZero 𝕜 β] [ContinuousSMul 𝕜 β] {l : Filter α} {f : α → β} (c : 𝕜)
     (hf : ZeroAtFilter l f) : ZeroAtFilter l (c • f) := by simpa using hf.const_smul c
 #align filter.zero_at_filter.smul Filter.ZeroAtFilter.smul
@@ -98,7 +98,7 @@ theorem BoundedAtFilter.neg [NormedAddCommGroup β] {l : Filter α} {f : α →
   hf.neg_left
 #align filter.bounded_at_filter.neg Filter.BoundedAtFilter.neg
 
-theorem BoundedAtFilter.smul {𝕜 : Type _} [NormedField 𝕜] [NormedAddCommGroup β] [NormedSpace 𝕜 β]
+theorem BoundedAtFilter.smul {𝕜 : Type*} [NormedField 𝕜] [NormedAddCommGroup β] [NormedSpace 𝕜 β]
     {l : Filter α} {f : α → β} (c : 𝕜) (hf : BoundedAtFilter l f) : BoundedAtFilter l (c • f) :=
   hf.const_smul_left c
 #align filter.bounded_at_filter.smul Filter.BoundedAtFilter.smul

f2ce6086

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2022 Chris Birkbeck. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Birkbeck, David Loeffler
-
-! This file was ported from Lean 3 source module order.filter.zero_and_bounded_at_filter
-! leanprover-community/mathlib commit f2ce6086713c78a7f880485f7917ea547a215982
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Module.Submodule.Basic
 import Mathlib.Topology.Algebra.Monoid
 import Mathlib.Analysis.Asymptotics.Asymptotics
 
+#align_import order.filter.zero_and_bounded_at_filter from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
+
 /-!
 # Zero and Bounded at filter

f2ce6086

feat: port Order.Filter.ZeroAndBoundedAtFilter (#3435)

336482e7

`order.filter.zero_and_bounded_at_filter` ⟷ `Mathlib.Order.Filter.ZeroAndBoundedAtFilter`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 614

order.filter.zero_and_bounded_at_filter ⟷ Mathlib.Order.Filter.ZeroAndBoundedAtFilter

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 614

`order.filter.zero_and_bounded_at_filter` ⟷ `Mathlib.Order.Filter.ZeroAndBoundedAtFilter`