File: Mathlib/Analysis/Normed/Order/Lattice.lean

full_name: HasSolidNorm
code: /-- 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‖
goal: Prop

full_name: HasSolidNorm.solid
code: /-- 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‖
goal: |x| ≤ |y| → ‖x‖ ≤ ‖y‖

full_name: norm_le_norm_of_abs_le_abs
code: theorem norm_le_norm_of_abs_le_abs {a b : α} (h : |a| ≤ |b|) : ‖a‖ ≤ ‖b‖ 
goal: ‖a‖ ≤ ‖b‖

full_name: LatticeOrderedAddCommGroup.isSolid_ball
code: /-- 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) 
goal: LatticeOrderedAddCommGroup.IsSolid (Metric.ball 0 r)

full_name: instHasSolidNormReal
code: instance : HasSolidNorm ℝ 
goal: HasSolidNorm ℝ

full_name: instHasSolidNormRat
code: instance : HasSolidNorm ℚ 
goal: HasSolidNorm ℚ

full_name: NormedLatticeAddCommGroup
code: /--
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 α, HasSolidNorm α where
  add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
goal: Type u_1

full_name: NormedLatticeAddCommGroup.add_le_add_left
code: /--
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 α, HasSolidNorm α where
  add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
goal: a ≤ b → ∀ (c : α), c + a ≤ c + b

full_name: Real.normedLatticeAddCommGroup
code: instance Real.normedLatticeAddCommGroup : NormedLatticeAddCommGroup ℝ 
goal: NormedLatticeAddCommGroup ℝ

full_name: NormedLatticeAddCommGroup.toOrderedAddCommGroup
code: /-- A normed lattice ordered group is an ordered additive commutative group
-/
instance (priority := 100) NormedLatticeAddCommGroup.toOrderedAddCommGroup {α : Type*}
    [h : NormedLatticeAddCommGroup α] : OrderedAddCommGroup α 
goal: OrderedAddCommGroup α

full_name: dual_solid
code: theorem dual_solid (a b : α) (h : b ⊓ -b ≤ a ⊓ -a) : ‖a‖ ≤ ‖b‖ 
goal: ‖a‖ ≤ ‖b‖

full_name: OrderDual.instNormedLatticeAddCommGroup
code: /-- Let `α` be a normed lattice ordered group, then the order dual is also a
normed lattice ordered group.
-/
instance (priority := 100) OrderDual.instNormedLatticeAddCommGroup :
    NormedLatticeAddCommGroup αᵒᵈ 
goal: NormedLatticeAddCommGroup αᵒᵈ

full_name: norm_abs_eq_norm
code: theorem norm_abs_eq_norm (a : α) : ‖|a|‖ = ‖a‖ 
goal: ‖|a|‖ = ‖a‖

full_name: norm_inf_sub_inf_le_add_norm
code: theorem norm_inf_sub_inf_le_add_norm (a b c d : α) : ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖ 
goal: ‖a ⊓ b - c ⊓ d‖ ≤ ‖a - c‖ + ‖b - d‖

full_name: norm_sup_sub_sup_le_add_norm
code: theorem norm_sup_sub_sup_le_add_norm (a b c d : α) : ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖ 
goal: ‖a ⊔ b - c ⊔ d‖ ≤ ‖a - c‖ + ‖b - d‖

full_name: norm_inf_le_add
code: theorem norm_inf_le_add (x y : α) : ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖ 
goal: ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖

full_name: norm_sup_le_add
code: theorem norm_sup_le_add (x y : α) : ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖ 
goal: ‖x ⊔ y‖ ≤ ‖x‖ + ‖y‖

full_name: NormedLatticeAddCommGroup.continuousInf
code: /-- Let `α` be a normed lattice ordered group. Then the infimum is jointly continuous.
-/
instance (priority := 100) NormedLatticeAddCommGroup.continuousInf : ContinuousInf α 
goal: ContinuousInf α

full_name: NormedLatticeAddCommGroup.continuousSup
code: instance (priority := 100) NormedLatticeAddCommGroup.continuousSup {α : Type*}
    [NormedLatticeAddCommGroup α] : ContinuousSup α 
goal: ContinuousSup α

full_name: NormedLatticeAddCommGroup.toTopologicalLattice
code: /--
Let `α` be a normed lattice ordered group. Then `α` is a topological lattice in the norm topology.
-/
instance (priority := 100) NormedLatticeAddCommGroup.toTopologicalLattice : TopologicalLattice α 
goal: TopologicalLattice α

full_name: norm_abs_sub_abs
code: theorem norm_abs_sub_abs (a b : α) : ‖|a| - |b|‖ ≤ ‖a - b‖ 
goal: ‖|a| - |b|‖ ≤ ‖a - b‖

full_name: norm_sup_sub_sup_le_norm
code: theorem norm_sup_sub_sup_le_norm (x y z : α) : ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖ 
goal: ‖x ⊔ z - y ⊔ z‖ ≤ ‖x - y‖

full_name: norm_inf_sub_inf_le_norm
code: theorem norm_inf_sub_inf_le_norm (x y z : α) : ‖x ⊓ z - y ⊓ z‖ ≤ ‖x - y‖ 
goal: ‖x ⊓ z - y ⊓ z‖ ≤ ‖x - y‖

full_name: lipschitzWith_sup_right
code: theorem lipschitzWith_sup_right (z : α) : LipschitzWith 1 fun x => x ⊔ z 
goal: LipschitzWith 1 fun x => x ⊔ z

full_name: lipschitzWith_posPart
code: lemma lipschitzWith_posPart : LipschitzWith 1 (posPart : α → α) 
goal: LipschitzWith 1 posPart

full_name: lipschitzWith_negPart
code: lemma lipschitzWith_negPart : LipschitzWith 1 (negPart : α → α) 
goal: LipschitzWith 1 negPart

full_name: continuous_posPart
code: lemma continuous_posPart : Continuous (posPart : α → α) 
goal: Continuous posPart

full_name: continuous_negPart
code: lemma continuous_negPart : Continuous (negPart : α → α) 
goal: Continuous negPart

full_name: isClosed_nonneg
code: lemma isClosed_nonneg : IsClosed {x : α | 0 ≤ x} 
goal: IsClosed {x | 0 ≤ x}

full_name: isClosed_le_of_isClosed_nonneg
code: 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 } 
goal: IsClosed {p | p.1 ≤ p.2}

full_name: NormedLatticeAddCommGroup.orderClosedTopology
code: instance (priority := 100) NormedLatticeAddCommGroup.orderClosedTopology {E}
    [NormedLatticeAddCommGroup E] : OrderClosedTopology E 
goal: OrderClosedTopology E