analysis.normed.order.lattice | 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

5dc275ec

(last sync)

feat(analysis/normed/order/lattice): add has_solid_norm (#18554)

See this Zulip thread

Co-authored-by: Yaël Dillies

Diff

@@ -31,13 +31,36 @@ normed, lattice, ordered, group
 -/
 
 /-!
-### Normed lattice orderd groups
+### Normed lattice ordered groups
 
 Motivated by the theory of Banach Lattices, this section introduces normed lattice ordered groups.
 -/
 
 local notation (name := abs) `|`a`|` := abs a
 
+section solid_norm
+
+/-- Let `α` be an `add_comm_group` with a `lattice` structure. A norm on `α` is *solid* if, for `a`
+and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
+-/
+class has_solid_norm (α : Type*) [normed_add_comm_group α] [lattice α] : Prop :=
+(solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖)
+
+variables {α : Type*} [normed_add_comm_group α] [lattice α] [has_solid_norm α]
+
+lemma norm_le_norm_of_abs_le_abs  {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ := has_solid_norm.solid h
+
+/-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
+lemma lattice_ordered_add_comm_group.is_solid_ball (r : ℝ) :
+  lattice_ordered_add_comm_group.is_solid (metric.ball (0 : α) r) :=
+λ _ hx _ hxy, mem_ball_zero_iff.mpr ((has_solid_norm.solid hxy).trans_lt (mem_ball_zero_iff.mp hx))
+
+instance : has_solid_norm ℝ := ⟨λ _ _, id⟩
+
+instance : has_solid_norm ℚ := ⟨λ _ _ _, by simpa only [norm, ← rat.cast_abs, rat.cast_le]⟩
+
+end solid_norm
+
 /--
 Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
 respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say, for `a` and `b` in
@@ -45,16 +68,11 @@ respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say
 said to be a normed lattice ordered group.
 -/
 class normed_lattice_add_comm_group (α : Type*)
-  extends normed_add_comm_group α, lattice α :=
+  extends normed_add_comm_group α, lattice α, has_solid_norm α :=
 (add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b)
-(solid : ∀ a b : α, |a| ≤ |b| → ‖a‖ ≤ ‖b‖)
-
-lemma solid {α : Type*} [normed_lattice_add_comm_group α] {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
-normed_lattice_add_comm_group.solid a b h
 
 instance : normed_lattice_add_comm_group ℝ :=
-{ add_le_add_left := λ _ _ h _, add_le_add le_rfl h,
-  solid := λ _ _, id, }
+{ add_le_add_left := λ _ _ h _, add_le_add le_rfl h,}
 
 /--
 A normed lattice ordered group is an ordered additive commutative group
@@ -64,7 +82,7 @@ instance normed_lattice_add_comm_group_to_ordered_add_comm_group {α : Type*}
   [h : normed_lattice_add_comm_group α] : ordered_add_comm_group α := { ..h }
 
 variables {α : Type*} [normed_lattice_add_comm_group α]
-open lattice_ordered_comm_group
+open lattice_ordered_comm_group has_solid_norm
 
 lemma dual_solid (a b : α) (h: b⊓-b ≤ a⊓-a) : ‖a‖ ≤ ‖b‖ :=
 begin

17ef379e

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

5dc275ec

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -5,7 +5,7 @@ Authors: Christopher Hoskin
 -/
 import Topology.Order.Lattice
 import Analysis.Normed.Group.Basic
-import Algebra.Order.LatticeGroup
+import Algebra.Order.Group.Lattice
 
 #align_import analysis.normed.order.lattice from "leanprover-community/mathlib"@"5dc275ec639221ca4d5f56938eb966f6ad9bc89f"

5dc275ec

bump to nightly-2024-01-18-06

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

d4b8c2fa

Diff

@@ -242,29 +242,29 @@ theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
 #align lipschitz_with_sup_right lipschitzWith_sup_right
 -/
 
-#print lipschitzWith_pos /-
-theorem lipschitzWith_pos : LipschitzWith 1 (PosPart.pos : α → α) :=
+#print lipschitzWith_posPart /-
+theorem lipschitzWith_posPart : LipschitzWith 1 (posPart : α → α) :=
   lipschitzWith_sup_right 0
-#align lipschitz_with_pos lipschitzWith_pos
+#align lipschitz_with_pos lipschitzWith_posPart
 -/
 
-#print continuous_pos /-
-theorem continuous_pos : Continuous (PosPart.pos : α → α) :=
-  LipschitzWith.continuous lipschitzWith_pos
-#align continuous_pos continuous_pos
+#print continuous_posPart /-
+theorem continuous_posPart : Continuous (posPart : α → α) :=
+  LipschitzWith.continuous lipschitzWith_posPart
+#align continuous_pos continuous_posPart
 -/
 
-#print continuous_neg' /-
-theorem continuous_neg' : Continuous (NegPart.neg : α → α) :=
-  continuous_pos.comp continuous_neg
-#align continuous_neg' continuous_neg'
+#print continuous_negPart /-
+theorem continuous_negPart : Continuous (negPart : α → α) :=
+  continuous_posPart.comp continuous_neg
+#align continuous_neg' continuous_negPart
 -/
 
 #print isClosed_nonneg /-
 theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed {x : E | 0 ≤ x} :=
   by
-  suffices {x : E | 0 ≤ x} = NegPart.neg ⁻¹' {(0 : E)} by rw [this];
-    exact IsClosed.preimage continuous_neg' isClosed_singleton
+  suffices {x : E | 0 ≤ x} = negPart ⁻¹' {(0 : E)} by rw [this];
+    exact IsClosed.preimage continuous_negPart isClosed_singleton
   ext1 x
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq, neg_eq_zero_iff]
 #align is_closed_nonneg isClosed_nonneg

5dc275ec

bump to nightly-2024-01-16-06

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

e3ed64a2

Diff

@@ -110,10 +110,10 @@ open LatticeOrderedCommGroup HasSolidNorm
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ :=
   by
   apply solid
-  rw [abs_eq_sup_neg]
+  rw [abs]
   nth_rw 1 [← neg_neg a]
   rw [← neg_inf]
-  rw [abs_eq_sup_neg]
+  rw [abs]
   nth_rw 1 [← neg_neg b]
   rwa [← neg_inf, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
 #align dual_solid dual_solid
@@ -219,7 +219,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toTopologicalLattice : Topo
 
 #print norm_abs_sub_abs /-
 theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ :=
-  solid (LatticeOrderedCommGroup.abs_abs_sub_abs_le _ _)
+  solid (abs_abs_sub_abs_le _ _)
 #align norm_abs_sub_abs norm_abs_sub_abs
 -/

5dc275ec

bump to nightly-2024-01-10-06

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

32726bc2

Diff

@@ -112,10 +112,10 @@ theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖
   apply solid
   rw [abs_eq_sup_neg]
   nth_rw 1 [← neg_neg a]
-  rw [← neg_inf_eq_sup_neg]
+  rw [← neg_inf]
   rw [abs_eq_sup_neg]
   nth_rw 1 [← neg_neg b]
-  rwa [← neg_inf_eq_sup_neg, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
+  rwa [← neg_inf, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
 #align dual_solid dual_solid
 -/

5dc275ec

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) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 -/
-import Mathbin.Topology.Order.Lattice
-import Mathbin.Analysis.Normed.Group.Basic
-import Mathbin.Algebra.Order.LatticeGroup
+import Topology.Order.Lattice
+import Analysis.Normed.Group.Basic
+import Algebra.Order.LatticeGroup
 
 #align_import analysis.normed.order.lattice from "leanprover-community/mathlib"@"5dc275ec639221ca4d5f56938eb966f6ad9bc89f"

5dc275ec

bump to nightly-2023-09-06-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

f3106448

Diff

@@ -188,7 +188,7 @@ theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖ :=
 -/
 instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousInf α :=
   by
-  refine' ⟨continuous_iff_continuousAt.2 fun q => tendsto_iff_norm_tendsto_zero.2 <| _⟩
+  refine' ⟨continuous_iff_continuousAt.2 fun q => tendsto_iff_norm_sub_tendsto_zero.2 <| _⟩
   have : ∀ p : α × α, ‖p.1 ⊓ p.2 - q.1 ⊓ q.2‖ ≤ ‖p.1 - q.1‖ + ‖p.2 - q.2‖ := fun _ =>
     norm_inf_sub_inf_le_add_norm _ _ _ _
   refine' squeeze_zero (fun e => norm_nonneg _) this _

5dc275ec

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) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
-
-! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 5dc275ec639221ca4d5f56938eb966f6ad9bc89f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Order.Lattice
 import Mathbin.Analysis.Normed.Group.Basic
 import Mathbin.Algebra.Order.LatticeGroup
 
+#align_import analysis.normed.order.lattice from "leanprover-community/mathlib"@"5dc275ec639221ca4d5f56938eb966f6ad9bc89f"
+
 /-!
 # Normed lattice ordered groups

5dc275ec

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -43,7 +43,6 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -/
 
 
--- mathport name: abs
 local notation "|" a "|" => abs a
 
 section SolidNorm
@@ -59,15 +58,19 @@ class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop whe
 
 variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
 
+#print norm_le_norm_of_abs_le_abs /-
 theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
   HasSolidNorm.solid h
 #align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
+-/
 
+#print LatticeOrderedAddCommGroup.isSolid_ball /-
 /-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
 theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
     LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>
   mem_ball_zero_iff.mpr ((HasSolidNorm.solid hxy).trans_lt (mem_ball_zero_iff.mp hx))
 #align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ball
+-/
 
 instance : HasSolidNorm ℝ :=
   ⟨fun _ _ => id⟩
@@ -106,6 +109,7 @@ variable {α : Type _} [NormedLatticeAddCommGroup α]
 
 open LatticeOrderedCommGroup HasSolidNorm
 
+#print dual_solid /-
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ :=
   by
   apply solid
@@ -116,6 +120,7 @@ theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖
   nth_rw 1 [← neg_neg b]
   rwa [← neg_inf_eq_sup_neg, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
 #align dual_solid dual_solid
+-/
 
 -- see Note [lower instance priority]
 /-- Let `α` be a normed lattice ordered group, then the order dual is also a
@@ -124,10 +129,13 @@ normed lattice ordered group.
 instance (priority := 100) : NormedLatticeAddCommGroup αᵒᵈ :=
   { OrderDual.orderedAddCommGroup, OrderDual.normedAddCommGroup with solid := dual_solid }
 
+#print norm_abs_eq_norm /-
 theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ :=
   (solid (abs_abs a).le).antisymm (solid (abs_abs a).symm.le)
 #align norm_abs_eq_norm norm_abs_eq_norm
+-/
 
+#print norm_inf_sub_inf_le_add_norm /-
 theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
   by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
@@ -142,7 +150,9 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
       · rw [@inf_comm _ _ c, @inf_comm _ _ c]
         exact abs_inf_sub_inf_le_abs _ _ _
 #align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_norm
+-/
 
+#print norm_sup_sub_sup_le_add_norm /-
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
   by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
@@ -157,19 +167,25 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
       · rw [@sup_comm _ _ c, @sup_comm _ _ c]
         exact abs_sup_sub_sup_le_abs _ _ _
 #align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_norm
+-/
 
+#print norm_inf_le_add /-
 theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖ :=
   by
   have h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_inf_sub_inf_le_add_norm x y 0 0
   simpa only [inf_idem, sub_zero] using h
 #align norm_inf_le_add norm_inf_le_add
+-/
 
+#print norm_sup_le_add /-
 theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖ :=
   by
   have h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_sup_sub_sup_le_add_norm x y 0 0
   simpa only [sup_idem, sub_zero] using h
 #align norm_sup_le_add norm_sup_le_add
+-/
 
+#print NormedLatticeAddCommGroup.continuousInf /-
 -- see Note [lower instance priority]
 /-- Let `α` be a normed lattice ordered group. Then the infimum is jointly continuous.
 -/
@@ -184,12 +200,15 @@ instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousI
       ((continuous_snd.tendsto q).sub tendsto_const_nhds).norm
   simp
 #align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf
+-/
 
+#print NormedLatticeAddCommGroup.continuousSup /-
 -- see Note [lower instance priority]
 instance (priority := 100) NormedLatticeAddCommGroup.continuousSup {α : Type _}
     [NormedLatticeAddCommGroup α] : ContinuousSup α :=
   OrderDual.continuousSup αᵒᵈ
 #align normed_lattice_add_comm_group_has_continuous_sup NormedLatticeAddCommGroup.continuousSup
+-/
 
 #print NormedLatticeAddCommGroup.toTopologicalLattice /-
 -- see Note [lower instance priority]
@@ -201,22 +220,30 @@ instance (priority := 100) NormedLatticeAddCommGroup.toTopologicalLattice : Topo
 #align normed_lattice_add_comm_group_topological_lattice NormedLatticeAddCommGroup.toTopologicalLattice
 -/
 
+#print norm_abs_sub_abs /-
 theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ :=
   solid (LatticeOrderedCommGroup.abs_abs_sub_abs_le _ _)
 #align norm_abs_sub_abs norm_abs_sub_abs
+-/
 
+#print norm_sup_sub_sup_le_norm /-
 theorem norm_sup_sub_sup_le_norm (x y z : α) : ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖ :=
   solid (abs_sup_sub_sup_le_abs x y z)
 #align norm_sup_sub_sup_le_norm norm_sup_sub_sup_le_norm
+-/
 
+#print norm_inf_sub_inf_le_norm /-
 theorem norm_inf_sub_inf_le_norm (x y z : α) : ‖x ⊓ z - y ⊓ z‖ ≤ ‖x - y‖ :=
   solid (abs_inf_sub_inf_le_abs x y z)
 #align norm_inf_sub_inf_le_norm norm_inf_sub_inf_le_norm
+-/
 
+#print lipschitzWith_sup_right /-
 theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
   LipschitzWith.of_dist_le_mul fun x y => by
     rw [Nonneg.coe_one, one_mul, dist_eq_norm, dist_eq_norm]; exact norm_sup_sub_sup_le_norm x y z
 #align lipschitz_with_sup_right lipschitzWith_sup_right
+-/
 
 #print lipschitzWith_pos /-
 theorem lipschitzWith_pos : LipschitzWith 1 (PosPart.pos : α → α) :=
@@ -236,6 +263,7 @@ theorem continuous_neg' : Continuous (NegPart.neg : α → α) :=
 #align continuous_neg' continuous_neg'
 -/
 
+#print isClosed_nonneg /-
 theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed {x : E | 0 ≤ x} :=
   by
   suffices {x : E | 0 ≤ x} = NegPart.neg ⁻¹' {(0 : E)} by rw [this];
@@ -243,7 +271,9 @@ theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed {x : E | 0
   ext1 x
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq, neg_eq_zero_iff]
 #align is_closed_nonneg isClosed_nonneg
+-/
 
+#print isClosed_le_of_isClosed_nonneg /-
 theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalSpace G]
     [ContinuousSub G] (h : IsClosed {x : G | 0 ≤ x}) : IsClosed {p : G × G | p.fst ≤ p.snd} :=
   by
@@ -252,6 +282,7 @@ theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalS
   rw [this]
   exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
 #align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonneg
+-/
 
 #print NormedLatticeAddCommGroup.orderClosedTopology /-
 -- See note [lower instance priority]

5dc275ec

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -141,7 +141,6 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
       · exact abs_inf_sub_inf_le_abs _ _ _
       · rw [@inf_comm _ _ c, @inf_comm _ _ c]
         exact abs_inf_sub_inf_le_abs _ _ _
-    
 #align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_norm
 
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
@@ -157,7 +156,6 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
       · exact abs_sup_sub_sup_le_abs _ _ _
       · rw [@sup_comm _ _ c, @sup_comm _ _ c]
         exact abs_sup_sub_sup_le_abs _ _ _
-    
 #align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_norm
 
 theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖ :=

5dc275ec

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -181,7 +181,8 @@ instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousI
   have : ∀ p : α × α, ‖p.1 ⊓ p.2 - q.1 ⊓ q.2‖ ≤ ‖p.1 - q.1‖ + ‖p.2 - q.2‖ := fun _ =>
     norm_inf_sub_inf_le_add_norm _ _ _ _
   refine' squeeze_zero (fun e => norm_nonneg _) this _
-  convert((continuous_fst.tendsto q).sub tendsto_const_nhds).norm.add
+  convert
+    ((continuous_fst.tendsto q).sub tendsto_const_nhds).norm.add
       ((continuous_snd.tendsto q).sub tendsto_const_nhds).norm
   simp
 #align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf
@@ -237,19 +238,19 @@ theorem continuous_neg' : Continuous (NegPart.neg : α → α) :=
 #align continuous_neg' continuous_neg'
 -/
 
-theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0 ≤ x } :=
+theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed {x : E | 0 ≤ x} :=
   by
-  suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)} by rw [this];
+  suffices {x : E | 0 ≤ x} = NegPart.neg ⁻¹' {(0 : E)} by rw [this];
     exact IsClosed.preimage continuous_neg' isClosed_singleton
   ext1 x
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq, neg_eq_zero_iff]
 #align is_closed_nonneg isClosed_nonneg
 
 theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalSpace G]
-    [ContinuousSub G] (h : IsClosed { x : G | 0 ≤ x }) : IsClosed { p : G × G | p.fst ≤ p.snd } :=
+    [ContinuousSub G] (h : IsClosed {x : G | 0 ≤ x}) : IsClosed {p : G × G | p.fst ≤ p.snd} :=
   by
-  have : { p : G × G | p.fst ≤ p.snd } = (fun p : G × G => p.snd - p.fst) ⁻¹' { x : G | 0 ≤ x } :=
-    by ext1 p; simp only [sub_nonneg, Set.preimage_setOf_eq]
+  have : {p : G × G | p.fst ≤ p.snd} = (fun p : G × G => p.snd - p.fst) ⁻¹' {x : G | 0 ≤ x} := by
+    ext1 p; simp only [sub_nonneg, Set.preimage_setOf_eq]
   rw [this]
   exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
 #align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonneg

5dc275ec

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -73,7 +73,7 @@ instance : HasSolidNorm ℝ :=
   ⟨fun _ _ => id⟩
 
 instance : HasSolidNorm ℚ :=
-  ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le] ⟩
+  ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le]⟩
 
 end SolidNorm
 
@@ -85,7 +85,7 @@ respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say
 said to be a normed lattice ordered group.
 -/
 class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α,
-  HasSolidNorm α where
+    HasSolidNorm α where
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
 -/

5dc275ec

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -59,22 +59,10 @@ class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop whe
 
 variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
 
-/- warning: norm_le_norm_of_abs_le_abs -> norm_le_norm_of_abs_le_abs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_2)))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α _inst_1)))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α _inst_1)))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) b)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α _inst_1) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α _inst_1) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_2)))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1)))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1)))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) b)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α _inst_1) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α _inst_1) b))
-Case conversion may be inaccurate. Consider using '#align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_absₓ'. -/
 theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
   HasSolidNorm.solid h
 #align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
 
-/- warning: lattice_ordered_add_comm_group.is_solid_ball -> LatticeOrderedAddCommGroup.isSolid_ball is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] (r : Real), LatticeOrderedAddCommGroup.IsSolid.{u1} α _inst_2 (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1) (Metric.ball.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α _inst_1))))))))) r)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] (r : Real), LatticeOrderedAddCommGroup.IsSolid.{u1} α _inst_2 (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1) (Metric.ball.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1)))))))) r)
-Case conversion may be inaccurate. Consider using '#align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ballₓ'. -/
 /-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
 theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
     LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>
@@ -118,12 +106,6 @@ variable {α : Type _} [NormedLatticeAddCommGroup α]
 
 open LatticeOrderedCommGroup HasSolidNorm
 
-/- warning: dual_solid -> dual_solid is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) b (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) b)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) a))) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) b (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) b)) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) a (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) a))) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
-Case conversion may be inaccurate. Consider using '#align dual_solid dual_solidₓ'. -/
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ :=
   by
   apply solid
@@ -142,22 +124,10 @@ normed lattice ordered group.
 instance (priority := 100) : NormedLatticeAddCommGroup αᵒᵈ :=
   { OrderDual.orderedAddCommGroup, OrderDual.normedAddCommGroup with solid := dual_solid }
 
-/- warning: norm_abs_eq_norm -> norm_abs_eq_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α), Eq.{1} Real (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a)) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α), Eq.{1} Real (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a)) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align norm_abs_eq_norm norm_abs_eq_normₓ'. -/
 theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ :=
   (solid (abs_abs a).le).antisymm (solid (abs_abs a).symm.le)
 #align norm_abs_eq_norm norm_abs_eq_norm
 
-/- warning: norm_inf_sub_inf_le_add_norm -> norm_inf_sub_inf_le_add_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a b) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) a b) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
-Case conversion may be inaccurate. Consider using '#align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_normₓ'. -/
 theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
   by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
@@ -174,12 +144,6 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
     
 #align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_norm
 
-/- warning: norm_sup_sub_sup_le_add_norm -> norm_sup_sub_sup_le_add_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a b) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a b) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
-Case conversion may be inaccurate. Consider using '#align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_normₓ'. -/
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
   by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
@@ -196,36 +160,18 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
     
 #align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_norm
 
-/- warning: norm_inf_le_add -> norm_inf_le_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
-Case conversion may be inaccurate. Consider using '#align norm_inf_le_add norm_inf_le_addₓ'. -/
 theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖ :=
   by
   have h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_inf_sub_inf_le_add_norm x y 0 0
   simpa only [inf_idem, sub_zero] using h
 #align norm_inf_le_add norm_inf_le_add
 
-/- warning: norm_sup_le_add -> norm_sup_le_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
-Case conversion may be inaccurate. Consider using '#align norm_sup_le_add norm_sup_le_addₓ'. -/
 theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖ :=
   by
   have h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_sup_sub_sup_le_add_norm x y 0 0
   simpa only [sup_idem, sub_zero] using h
 #align norm_sup_le_add norm_sup_le_add
 
-/- warning: normed_lattice_add_comm_group_has_continuous_inf -> NormedLatticeAddCommGroup.continuousInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α], ContinuousInf.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α], ContinuousInf.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))
-Case conversion may be inaccurate. Consider using '#align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInfₓ'. -/
 -- see Note [lower instance priority]
 /-- Let `α` be a normed lattice ordered group. Then the infimum is jointly continuous.
 -/
@@ -240,12 +186,6 @@ instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousI
   simp
 #align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf
 
-/- warning: normed_lattice_add_comm_group_has_continuous_sup -> NormedLatticeAddCommGroup.continuousSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} α], ContinuousSup.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_2))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} α], ContinuousSup.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_2))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_2)))
-Case conversion may be inaccurate. Consider using '#align normed_lattice_add_comm_group_has_continuous_sup NormedLatticeAddCommGroup.continuousSupₓ'. -/
 -- see Note [lower instance priority]
 instance (priority := 100) NormedLatticeAddCommGroup.continuousSup {α : Type _}
     [NormedLatticeAddCommGroup α] : ContinuousSup α :=
@@ -262,42 +202,18 @@ instance (priority := 100) NormedLatticeAddCommGroup.toTopologicalLattice : Topo
 #align normed_lattice_add_comm_group_topological_lattice NormedLatticeAddCommGroup.toTopologicalLattice
 -/
 
-/- warning: norm_abs_sub_abs -> norm_abs_sub_abs is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b))) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b))) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a b))
-Case conversion may be inaccurate. Consider using '#align norm_abs_sub_abs norm_abs_sub_absₓ'. -/
 theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ :=
   solid (LatticeOrderedCommGroup.abs_abs_sub_abs_le _ _)
 #align norm_abs_sub_abs norm_abs_sub_abs
 
-/- warning: norm_sup_sub_sup_le_norm -> norm_sup_sub_sup_le_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
-Case conversion may be inaccurate. Consider using '#align norm_sup_sub_sup_le_norm norm_sup_sub_sup_le_normₓ'. -/
 theorem norm_sup_sub_sup_le_norm (x y z : α) : ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖ :=
   solid (abs_sup_sub_sup_le_abs x y z)
 #align norm_sup_sub_sup_le_norm norm_sup_sub_sup_le_norm
 
-/- warning: norm_inf_sub_inf_le_norm -> norm_inf_sub_inf_le_norm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) x z) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
-Case conversion may be inaccurate. Consider using '#align norm_inf_sub_inf_le_norm norm_inf_sub_inf_le_normₓ'. -/
 theorem norm_inf_sub_inf_le_norm (x y z : α) : ‖x ⊓ z - y ⊓ z‖ ≤ ‖x - y‖ :=
   solid (abs_inf_sub_inf_le_abs x y z)
 #align norm_inf_sub_inf_le_norm norm_inf_sub_inf_le_norm
 
-/- warning: lipschitz_with_sup_right -> lipschitzWith_sup_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (z : α), LipschitzWith.{u1, u1} α α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (fun (x : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (z : α), LipschitzWith.{u1, u1} α α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedAddCommGroup.toMetricSpace.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedAddCommGroup.toMetricSpace.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (fun (x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z)
-Case conversion may be inaccurate. Consider using '#align lipschitz_with_sup_right lipschitzWith_sup_rightₓ'. -/
 theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
   LipschitzWith.of_dist_le_mul fun x y => by
     rw [Nonneg.coe_one, one_mul, dist_eq_norm, dist_eq_norm]; exact norm_sup_sub_sup_le_norm x y z
@@ -321,12 +237,6 @@ theorem continuous_neg' : Continuous (NegPart.neg : α → α) :=
 #align continuous_neg' continuous_neg'
 -/
 
-/- warning: is_closed_nonneg -> isClosed_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toHasLe.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (OfNat.mk.{u1} E 0 (Zero.zero.{u1} E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E (NormedAddCommGroup.toNormedAddGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2)))))))))) x))
-but is expected to have type
-  forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toLE.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (Zero.toOfNat0.{u1} E (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (SubtractionCommMonoid.toSubtractionMonoid.{u1} E (AddCommGroup.toDivisionAddCommMonoid.{u1} E (NormedAddCommGroup.toAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))))))) x))
-Case conversion may be inaccurate. Consider using '#align is_closed_nonneg isClosed_nonnegₓ'. -/
 theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0 ≤ x } :=
   by
   suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)} by rw [this];
@@ -335,12 +245,6 @@ theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq, neg_eq_zero_iff]
 #align is_closed_nonneg isClosed_nonneg
 
-/- warning: is_closed_le_of_is_closed_nonneg -> isClosed_le_of_isClosed_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toHasLe.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (Prod.topologicalSpace.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toHasLe.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (Zero.toOfNat0.{u1} G (NegZeroClass.toZero.{u1} G (SubNegZeroMonoid.toNegZeroClass.{u1} G (SubtractionMonoid.toSubNegZeroMonoid.{u1} G (SubtractionCommMonoid.toSubtractionMonoid.{u1} G (AddCommGroup.toDivisionAddCommMonoid.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2)))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (instTopologicalSpaceProd.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
-Case conversion may be inaccurate. Consider using '#align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonnegₓ'. -/
 theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalSpace G]
     [ContinuousSub G] (h : IsClosed { x : G | 0 ≤ x }) : IsClosed { p : G × G | p.fst ≤ p.snd } :=
   by

5dc275ec

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -299,10 +299,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (z : α), LipschitzWith.{u1, u1} α α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedAddCommGroup.toMetricSpace.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedAddCommGroup.toMetricSpace.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (fun (x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z)
 Case conversion may be inaccurate. Consider using '#align lipschitz_with_sup_right lipschitzWith_sup_rightₓ'. -/
 theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
-  LipschitzWith.of_dist_le_mul fun x y =>
-    by
-    rw [Nonneg.coe_one, one_mul, dist_eq_norm, dist_eq_norm]
-    exact norm_sup_sub_sup_le_norm x y z
+  LipschitzWith.of_dist_le_mul fun x y => by
+    rw [Nonneg.coe_one, one_mul, dist_eq_norm, dist_eq_norm]; exact norm_sup_sub_sup_le_norm x y z
 #align lipschitz_with_sup_right lipschitzWith_sup_right
 
 #print lipschitzWith_pos /-
@@ -331,9 +329,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align is_closed_nonneg isClosed_nonnegₓ'. -/
 theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0 ≤ x } :=
   by
-  suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)}
-    by
-    rw [this]
+  suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)} by rw [this];
     exact IsClosed.preimage continuous_neg' isClosed_singleton
   ext1 x
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq, neg_eq_zero_iff]
@@ -349,9 +345,7 @@ theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalS
     [ContinuousSub G] (h : IsClosed { x : G | 0 ≤ x }) : IsClosed { p : G × G | p.fst ≤ p.snd } :=
   by
   have : { p : G × G | p.fst ≤ p.snd } = (fun p : G × G => p.snd - p.fst) ⁻¹' { x : G | 0 ≤ x } :=
-    by
-    ext1 p
-    simp only [sub_nonneg, Set.preimage_setOf_eq]
+    by ext1 p; simp only [sub_nonneg, Set.preimage_setOf_eq]
   rw [this]
   exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
 #align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonneg

5dc275ec

bump to nightly-2023-05-16-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

b550b1b3

Diff

@@ -48,19 +48,33 @@ local notation "|" a "|" => abs a
 
 section SolidNorm
 
+#print HasSolidNorm /-
 /-- Let `α` be an `add_comm_group` with a `lattice` structure. A norm on `α` is *solid* if, for `a`
 and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
 -/
 class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop where
   solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖
 #align has_solid_norm HasSolidNorm
+-/
 
 variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
 
+/- warning: norm_le_norm_of_abs_le_abs -> norm_le_norm_of_abs_le_abs is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_2)))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α _inst_1)))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α _inst_1)))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) b)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α _inst_1) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α _inst_1) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α _inst_2)))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1)))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1)))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α _inst_2))) b)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α _inst_1) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α _inst_1) b))
+Case conversion may be inaccurate. Consider using '#align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_absₓ'. -/
 theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
   HasSolidNorm.solid h
 #align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
 
+/- warning: lattice_ordered_add_comm_group.is_solid_ball -> LatticeOrderedAddCommGroup.isSolid_ball is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] (r : Real), LatticeOrderedAddCommGroup.IsSolid.{u1} α _inst_2 (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1) (Metric.ball.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α _inst_1))))))))) r)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedAddCommGroup.{u1} α] [_inst_2 : Lattice.{u1} α] [_inst_3 : HasSolidNorm.{u1} α _inst_1 _inst_2] (r : Real), LatticeOrderedAddCommGroup.IsSolid.{u1} α _inst_2 (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1) (Metric.ball.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α _inst_1)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α _inst_1)))))))) r)
+Case conversion may be inaccurate. Consider using '#align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ballₓ'. -/
 /-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
 theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
     LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>

5dc275ec

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -106,7 +106,7 @@ open LatticeOrderedCommGroup HasSolidNorm
 
 /- warning: dual_solid -> dual_solid is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) b (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) b)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) a))) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) b (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) b)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) a))) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) b (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) b)) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) a (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) a))) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
 Case conversion may be inaccurate. Consider using '#align dual_solid dual_solidₓ'. -/
@@ -311,7 +311,7 @@ theorem continuous_neg' : Continuous (NegPart.neg : α → α) :=
 
 /- warning: is_closed_nonneg -> isClosed_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toLE.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (OfNat.mk.{u1} E 0 (Zero.zero.{u1} E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E (NormedAddCommGroup.toNormedAddGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2)))))))))) x))
+  forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toHasLe.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (OfNat.mk.{u1} E 0 (Zero.zero.{u1} E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E (NormedAddCommGroup.toNormedAddGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2)))))))))) x))
 but is expected to have type
   forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toLE.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (Zero.toOfNat0.{u1} E (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (SubtractionCommMonoid.toSubtractionMonoid.{u1} E (AddCommGroup.toDivisionAddCommMonoid.{u1} E (NormedAddCommGroup.toAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))))))) x))
 Case conversion may be inaccurate. Consider using '#align is_closed_nonneg isClosed_nonnegₓ'. -/
@@ -327,7 +327,7 @@ theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0
 
 /- warning: is_closed_le_of_is_closed_nonneg -> isClosed_le_of_isClosed_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (Prod.topologicalSpace.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
+  forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toHasLe.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (Prod.topologicalSpace.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toHasLe.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (Zero.toOfNat0.{u1} G (NegZeroClass.toZero.{u1} G (SubNegZeroMonoid.toNegZeroClass.{u1} G (SubtractionMonoid.toSubNegZeroMonoid.{u1} G (SubtractionCommMonoid.toSubtractionMonoid.{u1} G (AddCommGroup.toDivisionAddCommMonoid.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2)))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (instTopologicalSpaceProd.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
 Case conversion may be inaccurate. Consider using '#align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonnegₓ'. -/

5dc275ec

bump to nightly-2023-05-12-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

c1990cb3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 
 ! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
+! leanprover-community/mathlib commit 5dc275ec639221ca4d5f56938eb966f6ad9bc89f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -37,7 +37,7 @@ normed, lattice, ordered, group
 
 
 /-!
-### Normed lattice orderd groups
+### Normed lattice ordered groups
 
 Motivated by the theory of Banach Lattices, this section introduces normed lattice ordered groups.
 -/
@@ -46,6 +46,35 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -- mathport name: abs
 local notation "|" a "|" => abs a
 
+section SolidNorm
+
+/-- Let `α` be an `add_comm_group` with a `lattice` structure. A norm on `α` is *solid* if, for `a`
+and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
+-/
+class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop where
+  solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖
+#align has_solid_norm HasSolidNorm
+
+variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
+
+theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
+  HasSolidNorm.solid h
+#align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
+
+/-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
+theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
+    LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>
+  mem_ball_zero_iff.mpr ((HasSolidNorm.solid hxy).trans_lt (mem_ball_zero_iff.mp hx))
+#align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ball
+
+instance : HasSolidNorm ℝ :=
+  ⟨fun _ _ => id⟩
+
+instance : HasSolidNorm ℚ :=
+  ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le] ⟩
+
+end SolidNorm
+
 #print NormedLatticeAddCommGroup /-
 /--
 Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
@@ -53,26 +82,13 @@ respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say
 `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`. Then `α` is
 said to be a normed lattice ordered group.
 -/
-class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α where
+class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α,
+  HasSolidNorm α where
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
-  solid : ∀ a b : α, |a| ≤ |b| → ‖a‖ ≤ ‖b‖
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
 -/
 
-/- warning: solid -> solid is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
-Case conversion may be inaccurate. Consider using '#align solid solidₓ'. -/
-theorem solid {α : Type _} [NormedLatticeAddCommGroup α] {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
-  NormedLatticeAddCommGroup.solid a b h
-#align solid solid
-
-instance : NormedLatticeAddCommGroup ℝ
-    where
-  add_le_add_left _ _ h _ := add_le_add le_rfl h
-  solid _ _ := id
+instance : NormedLatticeAddCommGroup ℝ where add_le_add_left _ _ h _ := add_le_add le_rfl h
 
 #print NormedLatticeAddCommGroup.toOrderedAddCommGroup /-
 -- see Note [lower instance priority]
@@ -86,7 +102,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α :
 
 variable {α : Type _} [NormedLatticeAddCommGroup α]
 
-open LatticeOrderedCommGroup
+open LatticeOrderedCommGroup HasSolidNorm
 
 /- warning: dual_solid -> dual_solid is a dubious translation:
 lean 3 declaration is

10bf4f82

bump to nightly-2023-05-12-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/28b2a92f2996d28e580450863c130955de0ed398

a0458e84

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 
 ! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 5dc275ec639221ca4d5f56938eb966f6ad9bc89f
+! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -37,7 +37,7 @@ normed, lattice, ordered, group
 
 
 /-!
-### Normed lattice ordered groups
+### Normed lattice orderd groups
 
 Motivated by the theory of Banach Lattices, this section introduces normed lattice ordered groups.
 -/
@@ -46,35 +46,6 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -- mathport name: abs
 local notation "|" a "|" => abs a
 
-section SolidNorm
-
-/-- Let `α` be an `add_comm_group` with a `lattice` structure. A norm on `α` is *solid* if, for `a`
-and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
--/
-class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop where
-  solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖
-#align has_solid_norm HasSolidNorm
-
-variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
-
-theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
-  HasSolidNorm.solid h
-#align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
-
-/-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
-theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
-    LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>
-  mem_ball_zero_iff.mpr ((HasSolidNorm.solid hxy).trans_lt (mem_ball_zero_iff.mp hx))
-#align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ball
-
-instance : HasSolidNorm ℝ :=
-  ⟨fun _ _ => id⟩
-
-instance : HasSolidNorm ℚ :=
-  ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le] ⟩
-
-end SolidNorm
-
 #print NormedLatticeAddCommGroup /-
 /--
 Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
@@ -82,13 +53,26 @@ respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say
 `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`. Then `α` is
 said to be a normed lattice ordered group.
 -/
-class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α,
-  HasSolidNorm α where
+class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α where
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
+  solid : ∀ a b : α, |a| ≤ |b| → ‖a‖ ≤ ‖b‖
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
 -/
 
-instance : NormedLatticeAddCommGroup ℝ where add_le_add_left _ _ h _ := add_le_add le_rfl h
+/- warning: solid -> solid is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+Case conversion may be inaccurate. Consider using '#align solid solidₓ'. -/
+theorem solid {α : Type _} [NormedLatticeAddCommGroup α] {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
+  NormedLatticeAddCommGroup.solid a b h
+#align solid solid
+
+instance : NormedLatticeAddCommGroup ℝ
+    where
+  add_le_add_left _ _ h _ := add_le_add le_rfl h
+  solid _ _ := id
 
 #print NormedLatticeAddCommGroup.toOrderedAddCommGroup /-
 -- see Note [lower instance priority]
@@ -102,7 +86,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α :
 
 variable {α : Type _} [NormedLatticeAddCommGroup α]
 
-open LatticeOrderedCommGroup HasSolidNorm
+open LatticeOrderedCommGroup
 
 /- warning: dual_solid -> dual_solid is a dubious translation:
 lean 3 declaration is

5dc275ec

bump to nightly-2023-05-12-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/2f8347015b12b0864dfaf366ec4909eb70c78740

de75b5e2

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 
 ! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
+! leanprover-community/mathlib commit 5dc275ec639221ca4d5f56938eb966f6ad9bc89f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -37,7 +37,7 @@ normed, lattice, ordered, group
 
 
 /-!
-### Normed lattice orderd groups
+### Normed lattice ordered groups
 
 Motivated by the theory of Banach Lattices, this section introduces normed lattice ordered groups.
 -/
@@ -46,6 +46,35 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -- mathport name: abs
 local notation "|" a "|" => abs a
 
+section SolidNorm
+
+/-- Let `α` be an `add_comm_group` with a `lattice` structure. A norm on `α` is *solid* if, for `a`
+and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
+-/
+class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop where
+  solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖
+#align has_solid_norm HasSolidNorm
+
+variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
+
+theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
+  HasSolidNorm.solid h
+#align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
+
+/-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
+theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
+    LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>
+  mem_ball_zero_iff.mpr ((HasSolidNorm.solid hxy).trans_lt (mem_ball_zero_iff.mp hx))
+#align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ball
+
+instance : HasSolidNorm ℝ :=
+  ⟨fun _ _ => id⟩
+
+instance : HasSolidNorm ℚ :=
+  ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le] ⟩
+
+end SolidNorm
+
 #print NormedLatticeAddCommGroup /-
 /--
 Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
@@ -53,26 +82,13 @@ respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say
 `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`. Then `α` is
 said to be a normed lattice ordered group.
 -/
-class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α where
+class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α,
+  HasSolidNorm α where
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
-  solid : ∀ a b : α, |a| ≤ |b| → ‖a‖ ≤ ‖b‖
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
 -/
 
-/- warning: solid -> solid is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
-Case conversion may be inaccurate. Consider using '#align solid solidₓ'. -/
-theorem solid {α : Type _} [NormedLatticeAddCommGroup α] {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
-  NormedLatticeAddCommGroup.solid a b h
-#align solid solid
-
-instance : NormedLatticeAddCommGroup ℝ
-    where
-  add_le_add_left _ _ h _ := add_le_add le_rfl h
-  solid _ _ := id
+instance : NormedLatticeAddCommGroup ℝ where add_le_add_left _ _ h _ := add_le_add le_rfl h
 
 #print NormedLatticeAddCommGroup.toOrderedAddCommGroup /-
 -- see Note [lower instance priority]
@@ -86,7 +102,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α :
 
 variable {α : Type _} [NormedLatticeAddCommGroup α]
 
-open LatticeOrderedCommGroup
+open LatticeOrderedCommGroup HasSolidNorm
 
 /- warning: dual_solid -> dual_solid is a dubious translation:
 lean 3 declaration is

10bf4f82

bump to nightly-2023-03-17-00

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

c85864d4

Diff

@@ -205,8 +205,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousI
   have : ∀ p : α × α, ‖p.1 ⊓ p.2 - q.1 ⊓ q.2‖ ≤ ‖p.1 - q.1‖ + ‖p.2 - q.2‖ := fun _ =>
     norm_inf_sub_inf_le_add_norm _ _ _ _
   refine' squeeze_zero (fun e => norm_nonneg _) this _
-  convert
-    ((continuous_fst.tendsto q).sub tendsto_const_nhds).norm.add
+  convert((continuous_fst.tendsto q).sub tendsto_const_nhds).norm.add
       ((continuous_snd.tendsto q).sub tendsto_const_nhds).norm
   simp
 #align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf

10bf4f82

bump to nightly-2023-03-16-03

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

8ae28b0b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 
 ! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 17ef379e997badd73e5eabb4d38f11919ab3c4b3
+! leanprover-community/mathlib commit 10bf4f825ad729c5653adc039dafa3622e7f93c9
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Algebra.Order.LatticeGroup
 /-!
 # Normed lattice ordered groups
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Motivated by the theory of Banach Lattices, we then define `normed_lattice_add_comm_group` as a
 lattice with a covariant normed group addition satisfying the solid axiom.

17ef379e

bump to nightly-2023-03-14-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

2d6bcebd

Diff

@@ -43,6 +43,7 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -- mathport name: abs
 local notation "|" a "|" => abs a
 
+#print NormedLatticeAddCommGroup /-
 /--
 Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
 respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say, for `a` and `b` in
@@ -53,7 +54,14 @@ class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lat
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
   solid : ∀ a b : α, |a| ≤ |b| → ‖a‖ ≤ ‖b‖
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
+-/
 
+/- warning: solid -> solid is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b)) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+Case conversion may be inaccurate. Consider using '#align solid solidₓ'. -/
 theorem solid {α : Type _} [NormedLatticeAddCommGroup α] {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
   NormedLatticeAddCommGroup.solid a b h
 #align solid solid
@@ -63,18 +71,26 @@ instance : NormedLatticeAddCommGroup ℝ
   add_le_add_left _ _ h _ := add_le_add le_rfl h
   solid _ _ := id
 
+#print NormedLatticeAddCommGroup.toOrderedAddCommGroup /-
 -- see Note [lower instance priority]
 /-- A normed lattice ordered group is an ordered additive commutative group
 -/
-instance (priority := 100) normedLatticeAddCommGroupToOrderedAddCommGroup {α : Type _}
+instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α : Type _}
     [h : NormedLatticeAddCommGroup α] : OrderedAddCommGroup α :=
   { h with }
-#align normed_lattice_add_comm_group_to_ordered_add_comm_group normedLatticeAddCommGroupToOrderedAddCommGroup
+#align normed_lattice_add_comm_group_to_ordered_add_comm_group NormedLatticeAddCommGroup.toOrderedAddCommGroup
+-/
 
 variable {α : Type _} [NormedLatticeAddCommGroup α]
 
 open LatticeOrderedCommGroup
 
+/- warning: dual_solid -> dual_solid is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) b (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) b)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) a))) -> (LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedAddCommGroup.toPartialOrder.{u1} α (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} α _inst_1)))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) b (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) b)) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) a (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) a))) -> (LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) b))
+Case conversion may be inaccurate. Consider using '#align dual_solid dual_solidₓ'. -/
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ :=
   by
   apply solid
@@ -93,10 +109,22 @@ normed lattice ordered group.
 instance (priority := 100) : NormedLatticeAddCommGroup αᵒᵈ :=
   { OrderDual.orderedAddCommGroup, OrderDual.normedAddCommGroup with solid := dual_solid }
 
+/- warning: norm_abs_eq_norm -> norm_abs_eq_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α), Eq.{1} Real (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a)) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α), Eq.{1} Real (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a)) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align norm_abs_eq_norm norm_abs_eq_normₓ'. -/
 theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ :=
   (solid (abs_abs a).le).antisymm (solid (abs_abs a).symm.le)
 #align norm_abs_eq_norm norm_abs_eq_norm
 
+/- warning: norm_inf_sub_inf_le_add_norm -> norm_inf_sub_inf_le_add_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a b) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) a b) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
+Case conversion may be inaccurate. Consider using '#align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_normₓ'. -/
 theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
   by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
@@ -113,6 +141,12 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
     
 #align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_norm
 
+/- warning: norm_sup_sub_sup_le_add_norm -> norm_sup_sub_sup_le_add_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a b) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α) (c : α) (d : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) a b) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) c d))) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a c)) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) b d)))
+Case conversion may be inaccurate. Consider using '#align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_normₓ'. -/
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ :=
   by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
@@ -129,22 +163,40 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
     
 #align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_norm
 
+/- warning: norm_inf_le_add -> norm_inf_le_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
+Case conversion may be inaccurate. Consider using '#align norm_inf_le_add norm_inf_le_addₓ'. -/
 theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖ :=
   by
   have h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_inf_sub_inf_le_add_norm x y 0 0
   simpa only [inf_idem, sub_zero] using h
 #align norm_inf_le_add norm_inf_le_add
 
+/- warning: norm_sup_le_add -> norm_sup_le_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x y)) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) x) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) y))
+Case conversion may be inaccurate. Consider using '#align norm_sup_le_add norm_sup_le_addₓ'. -/
 theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖ :=
   by
   have h : ‖x ⊔ y - 0 ⊔ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_sup_sub_sup_le_add_norm x y 0 0
   simpa only [sup_idem, sub_zero] using h
 #align norm_sup_le_add norm_sup_le_add
 
+/- warning: normed_lattice_add_comm_group_has_continuous_inf -> NormedLatticeAddCommGroup.continuousInf is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α], ContinuousInf.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α], ContinuousInf.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))
+Case conversion may be inaccurate. Consider using '#align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInfₓ'. -/
 -- see Note [lower instance priority]
 /-- Let `α` be a normed lattice ordered group. Then the infimum is jointly continuous.
 -/
-instance (priority := 100) normedLatticeAddCommGroup_continuousInf : ContinuousInf α :=
+instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousInf α :=
   by
   refine' ⟨continuous_iff_continuousAt.2 fun q => tendsto_iff_norm_tendsto_zero.2 <| _⟩
   have : ∀ p : α × α, ‖p.1 ⊓ p.2 - q.1 ⊓ q.2‖ ≤ ‖p.1 - q.1‖ + ‖p.2 - q.2‖ := fun _ =>
@@ -154,34 +206,66 @@ instance (priority := 100) normedLatticeAddCommGroup_continuousInf : ContinuousI
     ((continuous_fst.tendsto q).sub tendsto_const_nhds).norm.add
       ((continuous_snd.tendsto q).sub tendsto_const_nhds).norm
   simp
-#align normed_lattice_add_comm_group_has_continuous_inf normedLatticeAddCommGroup_continuousInf
-
+#align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf
+
+/- warning: normed_lattice_add_comm_group_has_continuous_sup -> NormedLatticeAddCommGroup.continuousSup is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} α], ContinuousSup.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_2))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_2)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} α], ContinuousSup.{u1} α (UniformSpace.toTopologicalSpace.{u1} α (PseudoMetricSpace.toUniformSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_2))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_2)))
+Case conversion may be inaccurate. Consider using '#align normed_lattice_add_comm_group_has_continuous_sup NormedLatticeAddCommGroup.continuousSupₓ'. -/
 -- see Note [lower instance priority]
-instance (priority := 100) normedLatticeAddCommGroup_continuousSup {α : Type _}
+instance (priority := 100) NormedLatticeAddCommGroup.continuousSup {α : Type _}
     [NormedLatticeAddCommGroup α] : ContinuousSup α :=
   OrderDual.continuousSup αᵒᵈ
-#align normed_lattice_add_comm_group_has_continuous_sup normedLatticeAddCommGroup_continuousSup
+#align normed_lattice_add_comm_group_has_continuous_sup NormedLatticeAddCommGroup.continuousSup
 
+#print NormedLatticeAddCommGroup.toTopologicalLattice /-
 -- see Note [lower instance priority]
 /--
 Let `α` be a normed lattice ordered group. Then `α` is a topological lattice in the norm topology.
 -/
-instance (priority := 100) normedLatticeAddCommGroupTopologicalLattice : TopologicalLattice α :=
+instance (priority := 100) NormedLatticeAddCommGroup.toTopologicalLattice : TopologicalLattice α :=
   TopologicalLattice.mk
-#align normed_lattice_add_comm_group_topological_lattice normedLatticeAddCommGroupTopologicalLattice
+#align normed_lattice_add_comm_group_topological_lattice NormedLatticeAddCommGroup.toTopologicalLattice
+-/
 
+/- warning: norm_abs_sub_abs -> norm_abs_sub_abs is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))) (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b))) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (a : α) (b : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) a) (Abs.abs.{u1} α (Neg.toHasAbs.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (SubtractionCommMonoid.toSubtractionMonoid.{u1} α (AddCommGroup.toDivisionAddCommMonoid.{u1} α (NormedAddCommGroup.toAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1))))))) (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)))) b))) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) a b))
+Case conversion may be inaccurate. Consider using '#align norm_abs_sub_abs norm_abs_sub_absₓ'. -/
 theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ :=
   solid (LatticeOrderedCommGroup.abs_abs_sub_abs_le _ _)
 #align norm_abs_sub_abs norm_abs_sub_abs
 
+/- warning: norm_sup_sub_sup_le_norm -> norm_sup_sub_sup_le_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z) (Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z) (Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
+Case conversion may be inaccurate. Consider using '#align norm_sup_sub_sup_le_norm norm_sup_sub_sup_le_normₓ'. -/
 theorem norm_sup_sub_sup_le_norm (x y z : α) : ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖ :=
   solid (abs_sup_sub_sup_le_abs x y z)
 #align norm_sup_sub_sup_le_norm norm_sup_sub_sup_le_norm
 
+/- warning: norm_inf_sub_inf_le_norm -> norm_inf_sub_inf_le_norm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.hasLe (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z) (Inf.inf.{u1} α (SemilatticeInf.toHasInf.{u1} α (Lattice.toSemilatticeInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toHasNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (x : α) (y : α) (z : α), LE.le.{0} Real Real.instLEReal (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) x z) (Inf.inf.{u1} α (Lattice.toInf.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1)) y z))) (Norm.norm.{u1} α (NormedAddCommGroup.toNorm.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (NormedAddGroup.toAddGroup.{u1} α (NormedAddCommGroup.toNormedAddGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))))) x y))
+Case conversion may be inaccurate. Consider using '#align norm_inf_sub_inf_le_norm norm_inf_sub_inf_le_normₓ'. -/
 theorem norm_inf_sub_inf_le_norm (x y z : α) : ‖x ⊓ z - y ⊓ z‖ ≤ ‖x - y‖ :=
   solid (abs_inf_sub_inf_le_abs x y z)
 #align norm_inf_sub_inf_le_norm norm_inf_sub_inf_le_norm
 
+/- warning: lipschitz_with_sup_right -> lipschitzWith_sup_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (z : α), LipschitzWith.{u1, u1} α α (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (PseudoMetricSpace.toPseudoEMetricSpace.{u1} α (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} α (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (fun (x : α) => Sup.sup.{u1} α (SemilatticeSup.toHasSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : NormedLatticeAddCommGroup.{u1} α] (z : α), LipschitzWith.{u1, u1} α α (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedAddCommGroup.toMetricSpace.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (EMetricSpace.toPseudoEMetricSpace.{u1} α (MetricSpace.toEMetricSpace.{u1} α (NormedAddCommGroup.toMetricSpace.{u1} α (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (fun (x : α) => Sup.sup.{u1} α (SemilatticeSup.toSup.{u1} α (Lattice.toSemilatticeSup.{u1} α (NormedLatticeAddCommGroup.toLattice.{u1} α _inst_1))) x z)
+Case conversion may be inaccurate. Consider using '#align lipschitz_with_sup_right lipschitzWith_sup_rightₓ'. -/
 theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
   LipschitzWith.of_dist_le_mul fun x y =>
     by
@@ -189,18 +273,30 @@ theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
     exact norm_sup_sub_sup_le_norm x y z
 #align lipschitz_with_sup_right lipschitzWith_sup_right
 
+#print lipschitzWith_pos /-
 theorem lipschitzWith_pos : LipschitzWith 1 (PosPart.pos : α → α) :=
   lipschitzWith_sup_right 0
 #align lipschitz_with_pos lipschitzWith_pos
+-/
 
+#print continuous_pos /-
 theorem continuous_pos : Continuous (PosPart.pos : α → α) :=
   LipschitzWith.continuous lipschitzWith_pos
 #align continuous_pos continuous_pos
+-/
 
+#print continuous_neg' /-
 theorem continuous_neg' : Continuous (NegPart.neg : α → α) :=
   continuous_pos.comp continuous_neg
 #align continuous_neg' continuous_neg'
+-/
 
+/- warning: is_closed_nonneg -> isClosed_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toLE.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (OfNat.mk.{u1} E 0 (Zero.zero.{u1} E (AddZeroClass.toHasZero.{u1} E (AddMonoid.toAddZeroClass.{u1} E (SubNegMonoid.toAddMonoid.{u1} E (AddGroup.toSubNegMonoid.{u1} E (NormedAddGroup.toAddGroup.{u1} E (NormedAddCommGroup.toNormedAddGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2)))))))))) x))
+but is expected to have type
+  forall {E : Type.{u1}} [_inst_2 : NormedLatticeAddCommGroup.{u1} E], IsClosed.{u1} E (UniformSpace.toTopologicalSpace.{u1} E (PseudoMetricSpace.toUniformSpace.{u1} E (SeminormedAddCommGroup.toPseudoMetricSpace.{u1} E (NormedAddCommGroup.toSeminormedAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))) (setOf.{u1} E (fun (x : E) => LE.le.{u1} E (Preorder.toLE.{u1} E (PartialOrder.toPreorder.{u1} E (OrderedAddCommGroup.toPartialOrder.{u1} E (NormedLatticeAddCommGroup.toOrderedAddCommGroup.{u1} E _inst_2)))) (OfNat.ofNat.{u1} E 0 (Zero.toOfNat0.{u1} E (NegZeroClass.toZero.{u1} E (SubNegZeroMonoid.toNegZeroClass.{u1} E (SubtractionMonoid.toSubNegZeroMonoid.{u1} E (SubtractionCommMonoid.toSubtractionMonoid.{u1} E (AddCommGroup.toDivisionAddCommMonoid.{u1} E (NormedAddCommGroup.toAddCommGroup.{u1} E (NormedLatticeAddCommGroup.toNormedAddCommGroup.{u1} E _inst_2))))))))) x))
+Case conversion may be inaccurate. Consider using '#align is_closed_nonneg isClosed_nonnegₓ'. -/
 theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0 ≤ x } :=
   by
   suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)}
@@ -211,6 +307,12 @@ theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq, neg_eq_zero_iff]
 #align is_closed_nonneg isClosed_nonneg
 
+/- warning: is_closed_le_of_is_closed_nonneg -> isClosed_le_of_isClosed_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toHasSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (OfNat.mk.{u1} G 0 (Zero.zero.{u1} G (AddZeroClass.toHasZero.{u1} G (AddMonoid.toAddZeroClass.{u1} G (SubNegMonoid.toAddMonoid.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (Prod.topologicalSpace.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_2 : OrderedAddCommGroup.{u1} G] [_inst_3 : TopologicalSpace.{u1} G] [_inst_4 : ContinuousSub.{u1} G _inst_3 (SubNegMonoid.toSub.{u1} G (AddGroup.toSubNegMonoid.{u1} G (AddCommGroup.toAddGroup.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2))))], (IsClosed.{u1} G _inst_3 (setOf.{u1} G (fun (x : G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (OfNat.ofNat.{u1} G 0 (Zero.toOfNat0.{u1} G (NegZeroClass.toZero.{u1} G (SubNegZeroMonoid.toNegZeroClass.{u1} G (SubtractionMonoid.toSubNegZeroMonoid.{u1} G (SubtractionCommMonoid.toSubtractionMonoid.{u1} G (AddCommGroup.toDivisionAddCommMonoid.{u1} G (OrderedAddCommGroup.toAddCommGroup.{u1} G _inst_2)))))))) x))) -> (IsClosed.{u1} (Prod.{u1, u1} G G) (instTopologicalSpaceProd.{u1, u1} G G _inst_3 _inst_3) (setOf.{u1} (Prod.{u1, u1} G G) (fun (p : Prod.{u1, u1} G G) => LE.le.{u1} G (Preorder.toLE.{u1} G (PartialOrder.toPreorder.{u1} G (OrderedAddCommGroup.toPartialOrder.{u1} G _inst_2))) (Prod.fst.{u1, u1} G G p) (Prod.snd.{u1, u1} G G p))))
+Case conversion may be inaccurate. Consider using '#align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonnegₓ'. -/
 theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalSpace G]
     [ContinuousSub G] (h : IsClosed { x : G | 0 ≤ x }) : IsClosed { p : G × G | p.fst ≤ p.snd } :=
   by
@@ -222,9 +324,11 @@ theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalS
   exact IsClosed.preimage (continuous_snd.sub continuous_fst) h
 #align is_closed_le_of_is_closed_nonneg isClosed_le_of_isClosed_nonneg
 
+#print NormedLatticeAddCommGroup.orderClosedTopology /-
 -- See note [lower instance priority]
 instance (priority := 100) NormedLatticeAddCommGroup.orderClosedTopology {E}
     [NormedLatticeAddCommGroup E] : OrderClosedTopology E :=
   ⟨isClosed_le_of_isClosed_nonneg isClosed_nonneg⟩
 #align normed_lattice_add_comm_group.order_closed_topology NormedLatticeAddCommGroup.orderClosedTopology
+-/

17ef379e

bump to nightly-2023-03-01-20

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

20cadee0

Diff

@@ -104,7 +104,7 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
   rw [abs_of_nonneg (|a - c| + |b - d|) (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊓ b - c ⊓ d| = |a ⊓ b - c ⊓ b + (c ⊓ b - c ⊓ d)| := by rw [sub_add_sub_cancel]
-    _ ≤ |a ⊓ b - c ⊓ b| + |c ⊓ b - c ⊓ d| := abs_add_le _ _
+    _ ≤ |a ⊓ b - c ⊓ b| + |c ⊓ b - c ⊓ d| := (abs_add_le _ _)
     _ ≤ |a - c| + |b - d| := by
       apply add_le_add
       · exact abs_inf_sub_inf_le_abs _ _ _
@@ -120,7 +120,7 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
   rw [abs_of_nonneg (|a - c| + |b - d|) (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊔ b - c ⊔ d| = |a ⊔ b - c ⊔ b + (c ⊔ b - c ⊔ d)| := by rw [sub_add_sub_cancel]
-    _ ≤ |a ⊔ b - c ⊔ b| + |c ⊔ b - c ⊔ d| := abs_add_le _ _
+    _ ≤ |a ⊔ b - c ⊔ b| + |c ⊔ b - c ⊔ d| := (abs_add_le _ _)
     _ ≤ |a - c| + |b - d| := by
       apply add_le_add
       · exact abs_sup_sub_sup_le_abs _ _ _

17ef379e

bump to nightly-2023-02-21-22

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

d36dd541

Diff

@@ -212,8 +212,7 @@ theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0
 #align is_closed_nonneg isClosed_nonneg
 
 theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalSpace G]
-    [HasContinuousSub G] (h : IsClosed { x : G | 0 ≤ x }) :
-    IsClosed { p : G × G | p.fst ≤ p.snd } :=
+    [ContinuousSub G] (h : IsClosed { x : G | 0 ≤ x }) : IsClosed { p : G × G | p.fst ≤ p.snd } :=
   by
   have : { p : G × G | p.fst ≤ p.snd } = (fun p : G × G => p.snd - p.fst) ⁻¹' { x : G | 0 ≤ x } :=
     by

17ef379e

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

5dc275ec

chore: superfluous parentheses part 2 (#12131)

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

d48d30ac

Diff

@@ -122,7 +122,7 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
   rw [abs_of_nonneg (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊓ b - c ⊓ d| = |a ⊓ b - c ⊓ b + (c ⊓ b - c ⊓ d)| := by rw [sub_add_sub_cancel]
-    _ ≤ |a ⊓ b - c ⊓ b| + |c ⊓ b - c ⊓ d| := (abs_add_le _ _)
+    _ ≤ |a ⊓ b - c ⊓ b| + |c ⊓ b - c ⊓ d| := abs_add_le _ _
     _ ≤ |a - c| + |b - d| := by
       apply add_le_add
       · exact abs_inf_sub_inf_le_abs _ _ _
@@ -136,7 +136,7 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
   rw [abs_of_nonneg (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊔ b - c ⊔ d| = |a ⊔ b - c ⊔ b + (c ⊔ b - c ⊔ d)| := by rw [sub_add_sub_cancel]
-    _ ≤ |a ⊔ b - c ⊔ b| + |c ⊔ b - c ⊔ d| := (abs_add_le _ _)
+    _ ≤ |a ⊔ b - c ⊔ b| + |c ⊔ b - c ⊔ d| := abs_add_le _ _
     _ ≤ |a - c| + |b - d| := by
       apply add_le_add
       · exact abs_sup_sub_sup_le_abs _ _ _

5dc275ec

chore(Order): add missing inst prefix to instance names (#11238)

This is not exhaustive; it largely does not rename instances that relate to algebra, and only focuses on the "core" order files.

4d23d2cb

Diff

@@ -107,8 +107,9 @@ theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖
 /-- Let `α` be a normed lattice ordered group, then the order dual is also a
 normed lattice ordered group.
 -/
-instance (priority := 100) OrderDual.normedLatticeAddCommGroup : NormedLatticeAddCommGroup αᵒᵈ :=
-  { OrderDual.orderedAddCommGroup, OrderDual.normedAddCommGroup, OrderDual.lattice α with
+instance (priority := 100) OrderDual.instNormedLatticeAddCommGroup :
+    NormedLatticeAddCommGroup αᵒᵈ :=
+  { OrderDual.orderedAddCommGroup, OrderDual.normedAddCommGroup, OrderDual.instLattice α with
     solid := dual_solid (α := α) }
 
 theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ :=

5dc275ec

chore(Order): Make more arguments explicit (#11033)

Those lemmas have historically been very annoying to use in rw since all their arguments were implicit. One too many people complained about it on Zulip, so I'm changing them.

Downstream code broken by this change can fix it by adding appropriately many _s.

Also marks CauSeq.ext @[ext].

`Order.BoundedOrder`

top_sup_eq
sup_top_eq
bot_sup_eq
sup_bot_eq
top_inf_eq
inf_top_eq
bot_inf_eq
inf_bot_eq

`Order.Lattice`

sup_idem
sup_comm
sup_assoc
sup_left_idem
sup_right_idem
inf_idem
inf_comm
inf_assoc
inf_left_idem
inf_right_idem
sup_inf_left
sup_inf_right
inf_sup_left
inf_sup_right

`Order.MinMax`

max_min_distrib_left
max_min_distrib_right
min_max_distrib_left
min_max_distrib_right

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

0eaff363

Diff

@@ -100,7 +100,7 @@ theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖
   rw [← neg_inf]
   rw [abs]
   nth_rw 1 [← neg_neg b]
-  rwa [← neg_inf, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
+  rwa [← neg_inf, neg_le_neg_iff, inf_comm _ b, inf_comm _ a]
 #align dual_solid dual_solid
 
 -- see Note [lower instance priority]
@@ -125,7 +125,7 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
     _ ≤ |a - c| + |b - d| := by
       apply add_le_add
       · exact abs_inf_sub_inf_le_abs _ _ _
-      · rw [@inf_comm _ _ c, @inf_comm _ _ c]
+      · rw [inf_comm c, inf_comm c]
         exact abs_inf_sub_inf_le_abs _ _ _
 #align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_norm
 
@@ -139,7 +139,7 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
     _ ≤ |a - c| + |b - d| := by
       apply add_le_add
       · exact abs_sup_sub_sup_le_abs _ _ _
-      · rw [@sup_comm _ _ c, @sup_comm _ _ c]
+      · rw [sup_comm c, sup_comm c]
         exact abs_sup_sub_sup_le_abs _ _ _
 #align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_norm

5dc275ec

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -37,7 +37,7 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -/
 
 
--- porting note: this now exists as a global notation
+-- Porting note: this now exists as a global notation
 -- local notation "|" a "|" => abs a
 
 section SolidNorm

5dc275ec

chore: uneven spacing for ⟨ ⟩ (#10014)

This cleans up instances of

⟨ foo, bar⟩

and

⟨foo, bar ⟩

where spaces a on the inside one side, but not on the other side. Fixing this by removing the extra space.

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

909ee227

Diff

@@ -63,7 +63,7 @@ theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
 
 instance : HasSolidNorm ℝ := ⟨fun _ _ => id⟩
 
-instance : HasSolidNorm ℚ := ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le] ⟩
+instance : HasSolidNorm ℚ := ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le]⟩
 
 end SolidNorm

5dc275ec

refactor: Clean up posPart (#9740)

This changes the typeclass notation approach with plain functions.

Followup to #9553. Part of #9411

18eeff5e

Diff

@@ -91,7 +91,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α :
 
 variable {α : Type*} [NormedLatticeAddCommGroup α]
 
-open LatticeOrderedGroup LatticeOrderedCommGroup HasSolidNorm
+open HasSolidNorm
 
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ := by
   apply solid
@@ -197,28 +197,23 @@ theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z :=
     exact norm_sup_sub_sup_le_norm x y z
 #align lipschitz_with_sup_right lipschitzWith_sup_right
 
-theorem lipschitzWith_pos : LipschitzWith 1 (PosPart.pos : α → α) :=
+lemma lipschitzWith_posPart : LipschitzWith 1 (posPart : α → α) :=
   lipschitzWith_sup_right 0
-#align lipschitz_with_pos lipschitzWith_pos
-
-theorem continuous_pos : Continuous (PosPart.pos : α → α) :=
-  LipschitzWith.continuous lipschitzWith_pos
-#align continuous_pos continuous_pos
-
-theorem continuous_neg' : Continuous (NegPart.neg : α → α) := by
-  refine continuous_pos.comp <| @continuous_neg _ _ _ TopologicalAddGroup.toContinuousNeg
-  -- porting note: see the [Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/can't.20infer.20.60ContinuousNeg.60)
-#align continuous_neg' continuous_neg'
-
-theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0 ≤ x } := by
-  suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)} by
-    rw [this]
-    exact IsClosed.preimage continuous_neg' isClosed_singleton
-  ext1 x
-  simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq,
-    @neg_eq_zero_iff E _ _ (OrderedAddCommGroup.to_covariantClass_left_le E)]
-  -- porting note: I'm not sure why Lean couldn't synthesize this instance because it works with
-  -- `have : CovariantClass E E (· + ·) (· ≤ ·) := inferInstance`
+#align lipschitz_with_pos lipschitzWith_posPart
+
+lemma lipschitzWith_negPart : LipschitzWith 1 (negPart : α → α) := by
+  simpa [Function.comp] using lipschitzWith_posPart.comp LipschitzWith.id.neg
+
+lemma continuous_posPart : Continuous (posPart : α → α) := lipschitzWith_posPart.continuous
+#align continuous_pos continuous_posPart
+
+lemma continuous_negPart : Continuous (negPart : α → α) := lipschitzWith_negPart.continuous
+#align continuous_neg' continuous_negPart
+
+lemma isClosed_nonneg : IsClosed {x : α | 0 ≤ x} := by
+  have : {x : α | 0 ≤ x} = negPart ⁻¹' {0} := by ext; simp [negPart_eq_zero]
+  rw [this]
+  exact isClosed_singleton.preimage continuous_negPart
 #align is_closed_nonneg isClosed_nonneg
 
 theorem isClosed_le_of_isClosed_nonneg {G} [OrderedAddCommGroup G] [TopologicalSpace G]

5dc275ec

refactor: Multiplicativise abs (#9553)

The current design for abs is flawed:

The Abs notation typeclass has exactly two instances: one for [Neg α] [Sup α], one for [Inv α] [Sup α]. This means that:
- We can't write a meaningful hover for Abs.abs
- Fields have two Abs instances!
We have the multiplicative definition but:
- All the lemmas in Algebra.Order.Group.Abs are about the additive version.
- The only lemmas about the multiplicative version are in Algebra.Order.Group.PosPart, and they get additivised to duplicates of the lemmas in Algebra.Order.Group.Abs!

This PR changes the notation typeclass with two new definitions (related through to_additive): mabs and abs. abs inherits the |a| notation and mabs gets |a|ₘ instead.

The first half of Algebra.Order.Group.Abs gets multiplicativised. A later PR will multiplicativise the second half, and another one will deduplicate the lemmas in Algebra.Order.Group.PosPart.

Part of #9411.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

cc7c881a

Diff

@@ -95,10 +95,10 @@ open LatticeOrderedGroup LatticeOrderedCommGroup HasSolidNorm
 
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ := by
   apply solid
-  rw [abs_eq_sup_neg]
+  rw [abs]
   nth_rw 1 [← neg_neg a]
   rw [← neg_inf]
-  rw [abs_eq_sup_neg]
+  rw [abs]
   nth_rw 1 [← neg_neg b]
   rwa [← neg_inf, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
 #align dual_solid dual_solid
@@ -118,7 +118,7 @@ theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ :=
 theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖ := by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
   refine' le_trans (solid _) (norm_add_le |a - c| |b - d|)
-  rw [abs_of_nonneg (|a - c| + |b - d|) (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
+  rw [abs_of_nonneg (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊓ b - c ⊓ d| = |a ⊓ b - c ⊓ b + (c ⊓ b - c ⊓ d)| := by rw [sub_add_sub_cancel]
     _ ≤ |a ⊓ b - c ⊓ b| + |c ⊓ b - c ⊓ d| := (abs_add_le _ _)
@@ -132,7 +132,7 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ := by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
   refine' le_trans (solid _) (norm_add_le |a - c| |b - d|)
-  rw [abs_of_nonneg (|a - c| + |b - d|) (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
+  rw [abs_of_nonneg (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊔ b - c ⊔ d| = |a ⊔ b - c ⊔ b + (c ⊔ b - c ⊔ d)| := by rw [sub_add_sub_cancel]
     _ ≤ |a ⊔ b - c ⊔ b| + |c ⊔ b - c ⊔ d| := (abs_add_le _ _)
@@ -180,8 +180,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toTopologicalLattice : Topo
   TopologicalLattice.mk
 #align normed_lattice_add_comm_group_topological_lattice NormedLatticeAddCommGroup.toTopologicalLattice
 
-theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ :=
-  solid (LatticeOrderedCommGroup.abs_abs_sub_abs_le _ _)
+theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ := solid (abs_abs_sub_abs_le _ _)
 #align norm_abs_sub_abs norm_abs_sub_abs
 
 theorem norm_sup_sub_sup_le_norm (x y z : α) : ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖ :=

5dc275ec

chore: New file for lattice ordered groups (#9457)

Split Algebra.Order.LatticeGroup into two files:

Algebra.Order.Group.Lattice for general properties of lattice ordered groups
Algebra.Order.Group.PosPart for properties of the positive and negative parts

Note that the latter also contains properties of the absolute value. These will be moved to Algebra.Order.Group.Abs in a later PR.

Part of #9411

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

33c5d03b

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 -/
-import Mathlib.Topology.Order.Lattice
+import Mathlib.Algebra.Order.Group.PosPart
 import Mathlib.Analysis.Normed.Group.Basic
-import Mathlib.Algebra.Order.LatticeGroup
+import Mathlib.Topology.Order.Lattice
 
 #align_import analysis.normed.order.lattice from "leanprover-community/mathlib"@"5dc275ec639221ca4d5f56938eb966f6ad9bc89f"
 
@@ -97,10 +97,10 @@ theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖
   apply solid
   rw [abs_eq_sup_neg]
   nth_rw 1 [← neg_neg a]
-  rw [← neg_inf_eq_sup_neg]
+  rw [← neg_inf]
   rw [abs_eq_sup_neg]
   nth_rw 1 [← neg_neg b]
-  rwa [← neg_inf_eq_sup_neg, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
+  rwa [← neg_inf, neg_le_neg_iff, @inf_comm _ _ _ b, @inf_comm _ _ _ a]
 #align dual_solid dual_solid
 
 -- see Note [lower instance priority]

5dc275ec

fix(Analysis,Topology): fix names (#6938)

Rename:

tendsto_iff_norm_tendsto_one → tendsto_iff_norm_div_tendsto_zero;
tendsto_iff_norm_tendsto_zero → tendsto_iff_norm_sub_tendsto_zero;
tendsto_one_iff_norm_tendsto_one → tendsto_one_iff_norm_tendsto_zero;
Filter.Tendsto.continuous_of_equicontinuous_at → Filter.Tendsto.continuous_of_equicontinuousAt.

04d2f7d8

Diff

@@ -157,7 +157,7 @@ theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖ := by
 /-- Let `α` be a normed lattice ordered group. Then the infimum is jointly continuous.
 -/
 instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousInf α := by
-  refine' ⟨continuous_iff_continuousAt.2 fun q => tendsto_iff_norm_tendsto_zero.2 <| _⟩
+  refine' ⟨continuous_iff_continuousAt.2 fun q => tendsto_iff_norm_sub_tendsto_zero.2 <| _⟩
   have : ∀ p : α × α, ‖p.1 ⊓ p.2 - q.1 ⊓ q.2‖ ≤ ‖p.1 - q.1‖ + ‖p.2 - q.2‖ := fun _ =>
     norm_inf_sub_inf_le_add_norm _ _ _ _
   refine' squeeze_zero (fun e => norm_nonneg _) this _

5dc275ec

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

@@ -45,11 +45,11 @@ section SolidNorm
 /-- Let `α` be an `AddCommGroup` with a `Lattice` structure. A norm on `α` is *solid* if, for `a`
 and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
 -/
-class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop where
+class HasSolidNorm (α : Type*) [NormedAddCommGroup α] [Lattice α] : Prop where
   solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖
 #align has_solid_norm HasSolidNorm
 
-variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
+variable {α : Type*} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
 
 theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
   HasSolidNorm.solid h
@@ -73,7 +73,7 @@ respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say
 `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`. Then `α` is
 said to be a normed lattice ordered group.
 -/
-class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α, HasSolidNorm α
+class NormedLatticeAddCommGroup (α : Type*) extends NormedAddCommGroup α, Lattice α, HasSolidNorm α
   where
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
@@ -84,12 +84,12 @@ instance Real.normedLatticeAddCommGroup : NormedLatticeAddCommGroup ℝ where
 -- see Note [lower instance priority]
 /-- A normed lattice ordered group is an ordered additive commutative group
 -/
-instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α : Type _}
+instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α : Type*}
     [h : NormedLatticeAddCommGroup α] : OrderedAddCommGroup α :=
   { h with }
 #align normed_lattice_add_comm_group_to_ordered_add_comm_group NormedLatticeAddCommGroup.toOrderedAddCommGroup
 
-variable {α : Type _} [NormedLatticeAddCommGroup α]
+variable {α : Type*} [NormedLatticeAddCommGroup α]
 
 open LatticeOrderedGroup LatticeOrderedCommGroup HasSolidNorm
 
@@ -167,7 +167,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousI
 #align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf
 
 -- see Note [lower instance priority]
-instance (priority := 100) NormedLatticeAddCommGroup.continuousSup {α : Type _}
+instance (priority := 100) NormedLatticeAddCommGroup.continuousSup {α : Type*}
     [NormedLatticeAddCommGroup α] : ContinuousSup α :=
   OrderDual.continuousSup αᵒᵈ
 #align normed_lattice_add_comm_group_has_continuous_sup NormedLatticeAddCommGroup.continuousSup

5dc275ec

refactor(Algebra/Order/LatticeGroup): Non-commutative Lattice Groups (#6452)

Generalise results in Algebra/Order/LatticeGroup to the case where the group is non-commutative

Co-authored-by: Christopher Hoskin <christopher.hoskin@overleaf.com>

cdd51dd5

Diff

@@ -91,7 +91,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α :
 
 variable {α : Type _} [NormedLatticeAddCommGroup α]
 
-open LatticeOrderedCommGroup HasSolidNorm
+open LatticeOrderedGroup LatticeOrderedCommGroup HasSolidNorm
 
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ := by
   apply solid

5dc275ec

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) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
-
-! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 5dc275ec639221ca4d5f56938eb966f6ad9bc89f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Order.Lattice
 import Mathlib.Analysis.Normed.Group.Basic
 import Mathlib.Algebra.Order.LatticeGroup
 
+#align_import analysis.normed.order.lattice from "leanprover-community/mathlib"@"5dc275ec639221ca4d5f56938eb966f6ad9bc89f"
+
 /-!
 # Normed lattice ordered groups

5dc275ec

chore: cleanup whitespace (#5988)

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

12343aa5

Diff

@@ -220,7 +220,7 @@ theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0
     exact IsClosed.preimage continuous_neg' isClosed_singleton
   ext1 x
   simp only [Set.mem_preimage, Set.mem_singleton_iff, Set.mem_setOf_eq,
-    @neg_eq_zero_iff E _ _ (OrderedAddCommGroup.to_covariantClass_left_le E)  ]
+    @neg_eq_zero_iff E _ _ (OrderedAddCommGroup.to_covariantClass_left_le E)]
   -- porting note: I'm not sure why Lean couldn't synthesize this instance because it works with
   -- `have : CovariantClass E E (· + ·) (· ≤ ·) := inferInstance`
 #align is_closed_nonneg isClosed_nonneg

5dc275ec

fix: precedence of ⁺, ⁻ and abs (#5619)

6c1021b5

Diff

@@ -120,7 +120,7 @@ theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ :=
 
 theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖ := by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
-  refine' le_trans (solid _) (norm_add_le (|a - c|) (|b - d|))
+  refine' le_trans (solid _) (norm_add_le |a - c| |b - d|)
   rw [abs_of_nonneg (|a - c| + |b - d|) (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊓ b - c ⊓ d| = |a ⊓ b - c ⊓ b + (c ⊓ b - c ⊓ d)| := by rw [sub_add_sub_cancel]
@@ -134,7 +134,7 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
 
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ := by
   rw [← norm_abs_eq_norm (a - c), ← norm_abs_eq_norm (b - d)]
-  refine' le_trans (solid _) (norm_add_le (|a - c|) (|b - d|))
+  refine' le_trans (solid _) (norm_add_le |a - c| |b - d|)
   rw [abs_of_nonneg (|a - c| + |b - d|) (add_nonneg (abs_nonneg (a - c)) (abs_nonneg (b - d)))]
   calc
     |a ⊔ b - c ⊔ d| = |a ⊔ b - c ⊔ b + (c ⊔ b - c ⊔ d)| := by rw [sub_add_sub_cancel]

5dc275ec

chore: forward-port mathlib#18554 (#3982)

Match [#18554](https://github.com/leanprover-community/mathlib/pull/18554)

46235134

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 
 ! This file was ported from Lean 3 source module analysis.normed.order.lattice
-! leanprover-community/mathlib commit 17ef379e997badd73e5eabb4d38f11919ab3c4b3
+! leanprover-community/mathlib commit 5dc275ec639221ca4d5f56938eb966f6ad9bc89f
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -34,7 +34,7 @@ normed, lattice, ordered, group
 
 
 /-!
-### Normed lattice orderd groups
+### Normed lattice ordered groups
 
 Motivated by the theory of Banach Lattices, this section introduces normed lattice ordered groups.
 -/
@@ -43,24 +43,46 @@ Motivated by the theory of Banach Lattices, this section introduces normed latti
 -- porting note: this now exists as a global notation
 -- local notation "|" a "|" => abs a
 
+section SolidNorm
+
+/-- Let `α` be an `AddCommGroup` with a `Lattice` structure. A norm on `α` is *solid* if, for `a`
+and `b` in `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`.
+-/
+class HasSolidNorm (α : Type _) [NormedAddCommGroup α] [Lattice α] : Prop where
+  solid : ∀ ⦃x y : α⦄, |x| ≤ |y| → ‖x‖ ≤ ‖y‖
+#align has_solid_norm HasSolidNorm
+
+variable {α : Type _} [NormedAddCommGroup α] [Lattice α] [HasSolidNorm α]
+
+theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
+  HasSolidNorm.solid h
+#align norm_le_norm_of_abs_le_abs norm_le_norm_of_abs_le_abs
+
+/-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
+theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
+    LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r) := fun _ hx _ hxy =>
+  mem_ball_zero_iff.mpr ((HasSolidNorm.solid hxy).trans_lt (mem_ball_zero_iff.mp hx))
+#align lattice_ordered_add_comm_group.is_solid_ball LatticeOrderedAddCommGroup.isSolid_ball
+
+instance : HasSolidNorm ℝ := ⟨fun _ _ => id⟩
+
+instance : HasSolidNorm ℚ := ⟨fun _ _ _ => by simpa only [norm, ← Rat.cast_abs, Rat.cast_le] ⟩
+
+end SolidNorm
+
 /--
 Let `α` be a normed commutative group equipped with a partial order covariant with addition, with
 respect which `α` forms a lattice. Suppose that `α` is *solid*, that is to say, for `a` and `b` in
 `α`, with absolute values `|a|` and `|b|` respectively, `|a| ≤ |b|` implies `‖a‖ ≤ ‖b‖`. Then `α` is
 said to be a normed lattice ordered group.
 -/
-class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α where
+class NormedLatticeAddCommGroup (α : Type _) extends NormedAddCommGroup α, Lattice α, HasSolidNorm α
+  where
   add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
-  solid : ∀ a b : α, |a| ≤ |b| → ‖a‖ ≤ ‖b‖
 #align normed_lattice_add_comm_group NormedLatticeAddCommGroup
 
-theorem solid {α : Type _} [NormedLatticeAddCommGroup α] {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ :=
-  NormedLatticeAddCommGroup.solid a b h
-#align solid solid
-
 instance Real.normedLatticeAddCommGroup : NormedLatticeAddCommGroup ℝ where
   add_le_add_left _ _ h _ := add_le_add le_rfl h
-  solid _ _ := id
 
 -- see Note [lower instance priority]
 /-- A normed lattice ordered group is an ordered additive commutative group
@@ -72,7 +94,7 @@ instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α :
 
 variable {α : Type _} [NormedLatticeAddCommGroup α]
 
-open LatticeOrderedCommGroup
+open LatticeOrderedCommGroup HasSolidNorm
 
 theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ := by
   apply solid

17ef379e

chore: deal with a few convert porting notes (#3887)

ad67d70a

Diff

@@ -142,9 +142,8 @@ instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousI
   have : ∀ p : α × α, ‖p.1 ⊓ p.2 - q.1 ⊓ q.2‖ ≤ ‖p.1 - q.1‖ + ‖p.2 - q.2‖ := fun _ =>
     norm_inf_sub_inf_le_add_norm _ _ _ _
   refine' squeeze_zero (fun e => norm_nonneg _) this _
-  -- porting note: I wish `convert` were better at unification.
-  convert ((continuous_fst.tendsto q).sub <| tendsto_const_nhds (a := q.fst)).norm.add
-    ((continuous_snd.tendsto q).sub <| tendsto_const_nhds (a := q.snd)).norm
+  convert ((continuous_fst.tendsto q).sub <| tendsto_const_nhds).norm.add
+    ((continuous_snd.tendsto q).sub <| tendsto_const_nhds).norm
   simp
 #align normed_lattice_add_comm_group_has_continuous_inf NormedLatticeAddCommGroup.continuousInf

17ef379e

chore: bye-bye, solo bys! (#3825)

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

14167e48

Diff

@@ -194,8 +194,7 @@ theorem continuous_neg' : Continuous (NegPart.neg : α → α) := by
 #align continuous_neg' continuous_neg'
 
 theorem isClosed_nonneg {E} [NormedLatticeAddCommGroup E] : IsClosed { x : E | 0 ≤ x } := by
-  suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)}
-    by
+  suffices { x : E | 0 ≤ x } = NegPart.neg ⁻¹' {(0 : E)} by
     rw [this]
     exact IsClosed.preimage continuous_neg' isClosed_singleton
   ext1 x

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

@@ -108,7 +108,6 @@ theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ 
       · exact abs_inf_sub_inf_le_abs _ _ _
       · rw [@inf_comm _ _ c, @inf_comm _ _ c]
         exact abs_inf_sub_inf_le_abs _ _ _
-
 #align norm_inf_sub_inf_le_add_norm norm_inf_sub_inf_le_add_norm
 
 theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ := by
@@ -123,7 +122,6 @@ theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ 
       · exact abs_sup_sub_sup_le_abs _ _ _
       · rw [@sup_comm _ _ c, @sup_comm _ _ c]
         exact abs_sup_sub_sup_le_abs _ _ _
-
 #align norm_sup_sub_sup_le_add_norm norm_sup_sub_sup_le_add_norm
 
 theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖ := by

17ef379e

feat: port Analysis.Normed.Order.Lattice (#2851)

1d68cc90

`analysis.normed.order.lattice` ⟷ `Mathlib.Analysis.Normed.Order.Lattice`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

`Order.BoundedOrder`

`Order.Lattice`

`Order.MinMax`

Dependencies 10 + 527

analysis.normed.order.lattice ⟷ Mathlib.Analysis.Normed.Order.Lattice

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Order.BoundedOrder

Order.Lattice

Order.MinMax

Dependencies 10 + 527

`analysis.normed.order.lattice` ⟷ `Mathlib.Analysis.Normed.Order.Lattice`

`Order.BoundedOrder`

`Order.Lattice`

`Order.MinMax`