analysis.normed_space.extr | Mathlib porting status

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

17ef379e

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

4f4a1c87

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
 import Analysis.NormedSpace.Ray
-import Topology.LocalExtr
+import Topology.Order.LocalExtr
 
 #align_import analysis.normed_space.extr from "leanprover-community/mathlib"@"4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b"

4f4a1c87

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Analysis.NormedSpace.Ray
-import Mathbin.Topology.LocalExtr
+import Analysis.NormedSpace.Ray
+import Topology.LocalExtr
 
 #align_import analysis.normed_space.extr 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,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.normed_space.extr
-! 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.Analysis.NormedSpace.Ray
 import Mathbin.Topology.LocalExtr
 
+#align_import analysis.normed_space.extr from "leanprover-community/mathlib"@"4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b"
+
 /-!
 # (Local) maximums in a normed space

4f4a1c87

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -36,6 +36,7 @@ section
 
 variable {f : α → E} {l : Filter α} {s : Set α} {c : α} {y : E}
 
+#print IsMaxFilter.norm_add_sameRay /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
 `c` and `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul
 along `l` at `c`. -/
@@ -47,14 +48,18 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
       _ ≤ ‖f c‖ + ‖y‖ := (add_le_add_right hx _)
       _ = ‖f c + y‖ := hy.norm_add.symm
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay
+-/
 
+#print IsMaxFilter.norm_add_self /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
 `c`, then the function `λ x, ‖f x + f c‖` has a maximul along `l` at `c`. -/
 theorem IsMaxFilter.norm_add_self (h : IsMaxFilter (norm ∘ f) l c) :
     IsMaxFilter (fun x => ‖f x + f c‖) l c :=
   h.norm_add_sameRay SameRay.rfl
 #align is_max_filter.norm_add_self IsMaxFilter.norm_add_self
+-/
 
+#print IsMaxOn.norm_add_sameRay /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c` and
 `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul on `s` at
 `c`. -/
@@ -62,17 +67,21 @@ theorem IsMaxOn.norm_add_sameRay (h : IsMaxOn (norm ∘ f) s c) (hy : SameRay 
     IsMaxOn (fun x => ‖f x + y‖) s c :=
   h.norm_add_sameRay hy
 #align is_max_on.norm_add_same_ray IsMaxOn.norm_add_sameRay
+-/
 
+#print IsMaxOn.norm_add_self /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c`,
 then the function `λ x, ‖f x + f c‖` has a maximul on `s` at `c`. -/
 theorem IsMaxOn.norm_add_self (h : IsMaxOn (norm ∘ f) s c) : IsMaxOn (fun x => ‖f x + f c‖) s c :=
   h.norm_add_self
 #align is_max_on.norm_add_self IsMaxOn.norm_add_self
+-/
 
 end
 
 variable {f : X → E} {s : Set X} {c : X} {y : E}
 
+#print IsLocalMaxOn.norm_add_sameRay /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum on a set `s` at a point
 `c` and `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a local
 maximul on `s` at `c`. -/
@@ -80,25 +89,32 @@ theorem IsLocalMaxOn.norm_add_sameRay (h : IsLocalMaxOn (norm ∘ f) s c) (hy :
     IsLocalMaxOn (fun x => ‖f x + y‖) s c :=
   h.norm_add_sameRay hy
 #align is_local_max_on.norm_add_same_ray IsLocalMaxOn.norm_add_sameRay
+-/
 
+#print IsLocalMaxOn.norm_add_self /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum on a set `s` at a point
 `c`, then the function `λ x, ‖f x + f c‖` has a local maximul on `s` at `c`. -/
 theorem IsLocalMaxOn.norm_add_self (h : IsLocalMaxOn (norm ∘ f) s c) :
     IsLocalMaxOn (fun x => ‖f x + f c‖) s c :=
   h.norm_add_self
 #align is_local_max_on.norm_add_self IsLocalMaxOn.norm_add_self
+-/
 
+#print IsLocalMax.norm_add_sameRay /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c` and `y` is
 a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a local maximul at `c`. -/
 theorem IsLocalMax.norm_add_sameRay (h : IsLocalMax (norm ∘ f) c) (hy : SameRay ℝ (f c) y) :
     IsLocalMax (fun x => ‖f x + y‖) c :=
   h.norm_add_sameRay hy
 #align is_local_max.norm_add_same_ray IsLocalMax.norm_add_sameRay
+-/
 
+#print IsLocalMax.norm_add_self /-
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c`, then the
 function `λ x, ‖f x + f c‖` has a local maximul at `c`. -/
 theorem IsLocalMax.norm_add_self (h : IsLocalMax (norm ∘ f) c) :
     IsLocalMax (fun x => ‖f x + f c‖) c :=
   h.norm_add_self
 #align is_local_max.norm_add_self IsLocalMax.norm_add_self
+-/

4f4a1c87

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -46,7 +46,6 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
       ‖f x + y‖ ≤ ‖f x‖ + ‖y‖ := norm_add_le _ _
       _ ≤ ‖f c‖ + ‖y‖ := (add_le_add_right hx _)
       _ = ‖f c + y‖ := hy.norm_add.symm
-      
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay
 
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point

4f4a1c87

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -36,12 +36,6 @@ section
 
 variable {f : α → E} {l : Filter α} {s : Set α} {c : α} {y : E}
 
-/- warning: is_max_filter.norm_add_same_ray -> IsMaxFilter.norm_add_sameRay is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u1} α} {c : α} {y : E}, (IsMaxFilter.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) l c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxFilter.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) l c)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u2} α} {c : α} {y : E}, (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) l c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) l c)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
 `c` and `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul
 along `l` at `c`. -/
@@ -55,12 +49,6 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
       
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay
 
-/- warning: is_max_filter.norm_add_self -> IsMaxFilter.norm_add_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u1} α} {c : α}, (IsMaxFilter.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) l c) -> (IsMaxFilter.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) l c)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u2} α} {c : α}, (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) l c) -> (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) l c)
-Case conversion may be inaccurate. Consider using '#align is_max_filter.norm_add_self IsMaxFilter.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
 `c`, then the function `λ x, ‖f x + f c‖` has a maximul along `l` at `c`. -/
 theorem IsMaxFilter.norm_add_self (h : IsMaxFilter (norm ∘ f) l c) :
@@ -68,12 +56,6 @@ theorem IsMaxFilter.norm_add_self (h : IsMaxFilter (norm ∘ f) l c) :
   h.norm_add_sameRay SameRay.rfl
 #align is_max_filter.norm_add_self IsMaxFilter.norm_add_self
 
-/- warning: is_max_on.norm_add_same_ray -> IsMaxOn.norm_add_sameRay is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u1} α} {c : α} {y : E}, (IsMaxOn.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxOn.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) s c)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u2} α} {c : α} {y : E}, (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) s c)
-Case conversion may be inaccurate. Consider using '#align is_max_on.norm_add_same_ray IsMaxOn.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c` and
 `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul on `s` at
 `c`. -/
@@ -82,12 +64,6 @@ theorem IsMaxOn.norm_add_sameRay (h : IsMaxOn (norm ∘ f) s c) (hy : SameRay 
   h.norm_add_sameRay hy
 #align is_max_on.norm_add_same_ray IsMaxOn.norm_add_sameRay
 
-/- warning: is_max_on.norm_add_self -> IsMaxOn.norm_add_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u1} α} {c : α}, (IsMaxOn.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (IsMaxOn.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) s c)
-but is expected to have type
-  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u2} α} {c : α}, (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) s c)
-Case conversion may be inaccurate. Consider using '#align is_max_on.norm_add_self IsMaxOn.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c`,
 then the function `λ x, ‖f x + f c‖` has a maximul on `s` at `c`. -/
 theorem IsMaxOn.norm_add_self (h : IsMaxOn (norm ∘ f) s c) : IsMaxOn (fun x => ‖f x + f c‖) s c :=
@@ -98,12 +74,6 @@ end
 
 variable {f : X → E} {s : Set X} {c : X} {y : E}
 
-/- warning: is_local_max_on.norm_add_same_ray -> IsLocalMaxOn.norm_add_sameRay is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {s : Set.{u1} X} {c : X} {y : E}, (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) s c)
-but is expected to have type
-  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {s : Set.{u2} X} {c : X} {y : E}, (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) s c)
-Case conversion may be inaccurate. Consider using '#align is_local_max_on.norm_add_same_ray IsLocalMaxOn.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum on a set `s` at a point
 `c` and `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a local
 maximul on `s` at `c`. -/
@@ -112,12 +82,6 @@ theorem IsLocalMaxOn.norm_add_sameRay (h : IsLocalMaxOn (norm ∘ f) s c) (hy :
   h.norm_add_sameRay hy
 #align is_local_max_on.norm_add_same_ray IsLocalMaxOn.norm_add_sameRay
 
-/- warning: is_local_max_on.norm_add_self -> IsLocalMaxOn.norm_add_self is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {s : Set.{u1} X} {c : X}, (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) s c)
-but is expected to have type
-  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {s : Set.{u2} X} {c : X}, (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) s c)
-Case conversion may be inaccurate. Consider using '#align is_local_max_on.norm_add_self IsLocalMaxOn.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum on a set `s` at a point
 `c`, then the function `λ x, ‖f x + f c‖` has a local maximul on `s` at `c`. -/
 theorem IsLocalMaxOn.norm_add_self (h : IsLocalMaxOn (norm ∘ f) s c) :
@@ -125,12 +89,6 @@ theorem IsLocalMaxOn.norm_add_self (h : IsLocalMaxOn (norm ∘ f) s c) :
   h.norm_add_self
 #align is_local_max_on.norm_add_self IsLocalMaxOn.norm_add_self
 
-/- warning: is_local_max.norm_add_same_ray -> IsLocalMax.norm_add_sameRay is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {c : X} {y : E}, (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) c)
-but is expected to have type
-  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {c : X} {y : E}, (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) c)
-Case conversion may be inaccurate. Consider using '#align is_local_max.norm_add_same_ray IsLocalMax.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c` and `y` is
 a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a local maximul at `c`. -/
 theorem IsLocalMax.norm_add_sameRay (h : IsLocalMax (norm ∘ f) c) (hy : SameRay ℝ (f c) y) :
@@ -138,12 +96,6 @@ theorem IsLocalMax.norm_add_sameRay (h : IsLocalMax (norm ∘ f) c) (hy : SameRa
   h.norm_add_sameRay hy
 #align is_local_max.norm_add_same_ray IsLocalMax.norm_add_sameRay
 
-/- warning: is_local_max.norm_add_self -> IsLocalMax.norm_add_self is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {c : X}, (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) c) -> (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) c)
-but is expected to have type
-  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {c : X}, (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) c) -> (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) c)
-Case conversion may be inaccurate. Consider using '#align is_local_max.norm_add_self IsLocalMax.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c`, then the
 function `λ x, ‖f x + f c‖` has a local maximul at `c`. -/
 theorem IsLocalMax.norm_add_self (h : IsLocalMax (norm ∘ f) c) :

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: Yury Kudryashov
 
 ! This file was ported from Lean 3 source module analysis.normed_space.extr
-! leanprover-community/mathlib commit 17ef379e997badd73e5eabb4d38f11919ab3c4b3
+! leanprover-community/mathlib commit 4f4a1c875d0baa92ab5d92f3fb1bb258ad9f3e5b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Topology.LocalExtr
 /-!
 # (Local) maximums in a normed space
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we prove the following lemma, see `is_max_filter.norm_add_same_ray`. If `f : α → E` is
 a function such that `norm ∘ f` has a maximum along a filter `l` at a point `c` and `y` is a vector
 on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul along `l` at `c`.

17ef379e

bump to nightly-2023-04-13-12

mathlib commit https://github.com/leanprover-community/mathlib/commit/347636a7a80595d55bedf6e6fbd996a3c39da69a

51949a4d

Diff

@@ -33,6 +33,12 @@ section
 
 variable {f : α → E} {l : Filter α} {s : Set α} {c : α} {y : E}
 
+/- warning: is_max_filter.norm_add_same_ray -> IsMaxFilter.norm_add_sameRay is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u1} α} {c : α} {y : E}, (IsMaxFilter.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) l c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxFilter.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) l c)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u2} α} {c : α} {y : E}, (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) l c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) l c)
+Case conversion may be inaccurate. Consider using '#align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
 `c` and `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul
 along `l` at `c`. -/
@@ -46,6 +52,12 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
       
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay
 
+/- warning: is_max_filter.norm_add_self -> IsMaxFilter.norm_add_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u1} α} {c : α}, (IsMaxFilter.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) l c) -> (IsMaxFilter.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) l c)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {l : Filter.{u2} α} {c : α}, (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) l c) -> (IsMaxFilter.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) l c)
+Case conversion may be inaccurate. Consider using '#align is_max_filter.norm_add_self IsMaxFilter.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point
 `c`, then the function `λ x, ‖f x + f c‖` has a maximul along `l` at `c`. -/
 theorem IsMaxFilter.norm_add_self (h : IsMaxFilter (norm ∘ f) l c) :
@@ -53,6 +65,12 @@ theorem IsMaxFilter.norm_add_self (h : IsMaxFilter (norm ∘ f) l c) :
   h.norm_add_sameRay SameRay.rfl
 #align is_max_filter.norm_add_self IsMaxFilter.norm_add_self
 
+/- warning: is_max_on.norm_add_same_ray -> IsMaxOn.norm_add_sameRay is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u1} α} {c : α} {y : E}, (IsMaxOn.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxOn.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) s c)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u2} α} {c : α} {y : E}, (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) s c)
+Case conversion may be inaccurate. Consider using '#align is_max_on.norm_add_same_ray IsMaxOn.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c` and
 `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a maximul on `s` at
 `c`. -/
@@ -61,6 +79,12 @@ theorem IsMaxOn.norm_add_sameRay (h : IsMaxOn (norm ∘ f) s c) (hy : SameRay 
   h.norm_add_sameRay hy
 #align is_max_on.norm_add_same_ray IsMaxOn.norm_add_sameRay
 
+/- warning: is_max_on.norm_add_self -> IsMaxOn.norm_add_self is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u1} α} {c : α}, (IsMaxOn.{u1, 0} α Real Real.preorder (Function.comp.{succ u1, succ u2, 1} α E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (IsMaxOn.{u1, 0} α Real Real.preorder (fun (x : α) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) s c)
+but is expected to have type
+  forall {α : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] {f : α -> E} {s : Set.{u2} α} {c : α}, (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} α E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (IsMaxOn.{u2, 0} α Real Real.instPreorderReal (fun (x : α) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) s c)
+Case conversion may be inaccurate. Consider using '#align is_max_on.norm_add_self IsMaxOn.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum on a set `s` at a point `c`,
 then the function `λ x, ‖f x + f c‖` has a maximul on `s` at `c`. -/
 theorem IsMaxOn.norm_add_self (h : IsMaxOn (norm ∘ f) s c) : IsMaxOn (fun x => ‖f x + f c‖) s c :=
@@ -71,6 +95,12 @@ end
 
 variable {f : X → E} {s : Set X} {c : X} {y : E}
 
+/- warning: is_local_max_on.norm_add_same_ray -> IsLocalMaxOn.norm_add_sameRay is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {s : Set.{u1} X} {c : X} {y : E}, (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) s c)
+but is expected to have type
+  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {s : Set.{u2} X} {c : X} {y : E}, (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) s c)
+Case conversion may be inaccurate. Consider using '#align is_local_max_on.norm_add_same_ray IsLocalMaxOn.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum on a set `s` at a point
 `c` and `y` is a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a local
 maximul on `s` at `c`. -/
@@ -79,6 +109,12 @@ theorem IsLocalMaxOn.norm_add_sameRay (h : IsLocalMaxOn (norm ∘ f) s c) (hy :
   h.norm_add_sameRay hy
 #align is_local_max_on.norm_add_same_ray IsLocalMaxOn.norm_add_sameRay
 
+/- warning: is_local_max_on.norm_add_self -> IsLocalMaxOn.norm_add_self is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {s : Set.{u1} X} {c : X}, (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) s c) -> (IsLocalMaxOn.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) s c)
+but is expected to have type
+  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {s : Set.{u2} X} {c : X}, (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) s c) -> (IsLocalMaxOn.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) s c)
+Case conversion may be inaccurate. Consider using '#align is_local_max_on.norm_add_self IsLocalMaxOn.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum on a set `s` at a point
 `c`, then the function `λ x, ‖f x + f c‖` has a local maximul on `s` at `c`. -/
 theorem IsLocalMaxOn.norm_add_self (h : IsLocalMaxOn (norm ∘ f) s c) :
@@ -86,6 +122,12 @@ theorem IsLocalMaxOn.norm_add_self (h : IsLocalMaxOn (norm ∘ f) s c) :
   h.norm_add_self
 #align is_local_max_on.norm_add_self IsLocalMaxOn.norm_add_self
 
+/- warning: is_local_max.norm_add_same_ray -> IsLocalMax.norm_add_sameRay is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {c : X} {y : E}, (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) c) -> (SameRay.{0, u2} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u2} E (SeminormedAddCommGroup.toAddCommGroup.{u2} E _inst_1)) (NormedSpace.toModule.{0, u2} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) y)) c)
+but is expected to have type
+  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {c : X} {y : E}, (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) c) -> (SameRay.{0, u1} Real Real.strictOrderedCommSemiring E (AddCommGroup.toAddCommMonoid.{u1} E (SeminormedAddCommGroup.toAddCommGroup.{u1} E _inst_1)) (NormedSpace.toModule.{0, u1} Real E Real.normedField _inst_1 _inst_2) (f c) y) -> (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) y)) c)
+Case conversion may be inaccurate. Consider using '#align is_local_max.norm_add_same_ray IsLocalMax.norm_add_sameRayₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c` and `y` is
 a vector on the same ray as `f c`, then the function `λ x, ‖f x + y‖` has a local maximul at `c`. -/
 theorem IsLocalMax.norm_add_sameRay (h : IsLocalMax (norm ∘ f) c) (hy : SameRay ℝ (f c) y) :
@@ -93,6 +135,12 @@ theorem IsLocalMax.norm_add_sameRay (h : IsLocalMax (norm ∘ f) c) (hy : SameRa
   h.norm_add_sameRay hy
 #align is_local_max.norm_add_same_ray IsLocalMax.norm_add_sameRay
 
+/- warning: is_local_max.norm_add_self -> IsLocalMax.norm_add_self is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {E : Type.{u2}} [_inst_1 : SeminormedAddCommGroup.{u2} E] [_inst_2 : NormedSpace.{0, u2} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u1} X] {f : X -> E} {c : X}, (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (Function.comp.{succ u1, succ u2, 1} X E Real (Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1)) f) c) -> (IsLocalMax.{u1, 0} X Real _inst_3 Real.preorder (fun (x : X) => Norm.norm.{u2} E (SeminormedAddCommGroup.toHasNorm.{u2} E _inst_1) (HAdd.hAdd.{u2, u2, u2} E E E (instHAdd.{u2} E (AddZeroClass.toHasAdd.{u2} E (AddMonoid.toAddZeroClass.{u2} E (SubNegMonoid.toAddMonoid.{u2} E (AddGroup.toSubNegMonoid.{u2} E (SeminormedAddGroup.toAddGroup.{u2} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u2} E _inst_1))))))) (f x) (f c))) c)
+but is expected to have type
+  forall {X : Type.{u2}} {E : Type.{u1}} [_inst_1 : SeminormedAddCommGroup.{u1} E] [_inst_2 : NormedSpace.{0, u1} Real E Real.normedField _inst_1] [_inst_3 : TopologicalSpace.{u2} X] {f : X -> E} {c : X}, (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (Function.comp.{succ u2, succ u1, 1} X E Real (Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1)) f) c) -> (IsLocalMax.{u2, 0} X Real _inst_3 Real.instPreorderReal (fun (x : X) => Norm.norm.{u1} E (SeminormedAddCommGroup.toNorm.{u1} E _inst_1) (HAdd.hAdd.{u1, u1, u1} E E E (instHAdd.{u1} E (AddZeroClass.toAdd.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (SeminormedAddGroup.toAddGroup.{u1} E (SeminormedAddCommGroup.toSeminormedAddGroup.{u1} E _inst_1))))))) (f x) (f c))) c)
+Case conversion may be inaccurate. Consider using '#align is_local_max.norm_add_self IsLocalMax.norm_add_selfₓ'. -/
 /-- If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c`, then the
 function `λ x, ‖f x + f c‖` has a local maximul at `c`. -/
 theorem IsLocalMax.norm_add_self (h : IsLocalMax (norm ∘ f) c) :

17ef379e

bump to nightly-2023-03-01-20

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

20cadee0

Diff

@@ -41,7 +41,7 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
   h.mono fun x hx =>
     calc
       ‖f x + y‖ ≤ ‖f x‖ + ‖y‖ := norm_add_le _ _
-      _ ≤ ‖f c‖ + ‖y‖ := add_le_add_right hx _
+      _ ≤ ‖f c‖ + ‖y‖ := (add_le_add_right hx _)
       _ = ‖f c + y‖ := hy.norm_add.symm
       
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay

17ef379e

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

17ef379e

chore: superfluous parentheses part 2 (#12131)

Co-authored-by: Moritz Firsching <firsching@google.com>

d48d30ac

Diff

@@ -38,7 +38,7 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
   h.mono fun x hx =>
     calc
       ‖f x + y‖ ≤ ‖f x‖ + ‖y‖ := norm_add_le _ _
-      _ ≤ ‖f c‖ + ‖y‖ := (add_le_add_right hx _)
+      _ ≤ ‖f c‖ + ‖y‖ := add_le_add_right hx _
       _ = ‖f c + y‖ := hy.norm_add.symm
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay

17ef379e

move(Topology/Order): Move anything that doesn't concern algebra (#11610)

Move files from Topology.Algebra.Order to Topology.Order when they do not contain any algebra. Also move Topology.LocalExtr to Topology.Order.LocalExtr.

According to git, the moves are:

Mathlib/Topology/{Algebra => }/Order/ExtendFrom.lean
Mathlib/Topology/{Algebra => }/Order/ExtrClosure.lean
Mathlib/Topology/{Algebra => }/Order/Filter.lean
Mathlib/Topology/{Algebra => }/Order/IntermediateValue.lean
Mathlib/Topology/{Algebra => }/Order/LeftRight.lean
Mathlib/Topology/{Algebra => }/Order/LeftRightLim.lean
Mathlib/Topology/{Algebra => }/Order/MonotoneContinuity.lean
Mathlib/Topology/{Algebra => }/Order/MonotoneConvergence.lean
Mathlib/Topology/{Algebra => }/Order/ProjIcc.lean
Mathlib/Topology/{Algebra => }/Order/T5.lean
Mathlib/Topology/{ => Order}/LocalExtr.lean

cd9902cc

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
 import Mathlib.Analysis.NormedSpace.Ray
-import Mathlib.Topology.LocalExtr
+import Mathlib.Topology.Order.LocalExtr
 
 #align_import analysis.normed_space.extr from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"

17ef379e

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

@@ -24,7 +24,7 @@ local maximum, normed space
 -/
 
 
-variable {α X E : Type _} [SeminormedAddCommGroup E] [NormedSpace ℝ E] [TopologicalSpace X]
+variable {α X E : Type*} [SeminormedAddCommGroup E] [NormedSpace ℝ E] [TopologicalSpace X]
 
 section

17ef379e

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,15 +2,12 @@
 Copyright (c) 2022 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.normed_space.extr
-! leanprover-community/mathlib commit 17ef379e997badd73e5eabb4d38f11919ab3c4b3
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.NormedSpace.Ray
 import Mathlib.Topology.LocalExtr
 
+#align_import analysis.normed_space.extr from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"
+
 /-!
 # (Local) maximums in a normed space

17ef379e

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -43,7 +43,6 @@ theorem IsMaxFilter.norm_add_sameRay (h : IsMaxFilter (norm ∘ f) l c) (hy : Sa
       ‖f x + y‖ ≤ ‖f x‖ + ‖y‖ := norm_add_le _ _
       _ ≤ ‖f c‖ + ‖y‖ := (add_le_add_right hx _)
       _ = ‖f c + y‖ := hy.norm_add.symm
-
 #align is_max_filter.norm_add_same_ray IsMaxFilter.norm_add_sameRay
 
 /-- If `f : α → E` is a function such that `norm ∘ f` has a maximum along a filter `l` at a point

17ef379e

feat: port Analysis.NormedSpace.Extr (#3418)

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

4372f6e7

`analysis.normed_space.extr` ⟷ `Mathlib.Analysis.NormedSpace.Extr`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 611

analysis.normed_space.extr ⟷ Mathlib.Analysis.NormedSpace.Extr

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 611

`analysis.normed_space.extr` ⟷ `Mathlib.Analysis.NormedSpace.Extr`