File: Mathlib/Analysis/Normed/Group/Quotient.lean

full_name: normOnQuotient
code: /-- The definition of the norm on the quotient by an additive subgroup. -/
noncomputable instance normOnQuotient (S : AddSubgroup M) : Norm (M ⧸ S) 
goal: Norm (M ⧸ S)

full_name: AddSubgroup.quotient_norm_eq
code: theorem AddSubgroup.quotient_norm_eq {S : AddSubgroup M} (x : M ⧸ S) :
    ‖x‖ = sInf (norm '' { m : M | (m : M ⧸ S) = x }) 
goal: ‖x‖ = sInf (norm '' {m | ↑m = x})

full_name: QuotientAddGroup.norm_eq_infDist
code: theorem QuotientAddGroup.norm_eq_infDist {S : AddSubgroup M} (x : M ⧸ S) :
    ‖x‖ = infDist 0 { m : M | (m : M ⧸ S) = x } 
goal: ‖x‖ = Metric.infDist 0 {m | ↑m = x}

full_name: QuotientAddGroup.norm_mk
code: /-- An alternative definition of the norm on the quotient group: the norm of `((x : M) : M ⧸ S)` is
equal to the distance from `x` to `S`. -/
theorem QuotientAddGroup.norm_mk {S : AddSubgroup M} (x : M) :
    ‖(x : M ⧸ S)‖ = infDist x S 
goal: ‖↑x‖ = Metric.infDist x ↑S

full_name: image_norm_nonempty
code: theorem image_norm_nonempty {S : AddSubgroup M} (x : M ⧸ S) :
    (norm '' { m | mk' S m = x }).Nonempty 
goal: (norm '' {m | (QuotientAddGroup.mk' S) m = x}).Nonempty

full_name: bddBelow_image_norm
code: theorem bddBelow_image_norm (s : Set M) : BddBelow (norm '' s) 
goal: BddBelow (norm '' s)

full_name: isGLB_quotient_norm
code: theorem isGLB_quotient_norm {S : AddSubgroup M} (x : M ⧸ S) :
    IsGLB (norm '' { m | mk' S m = x }) (‖x‖) 
goal: IsGLB (norm '' {m | (QuotientAddGroup.mk' S) m = x}) ‖x‖

full_name: quotient_norm_neg
code: /-- The norm on the quotient satisfies `‖-x‖ = ‖x‖`. -/
theorem quotient_norm_neg {S : AddSubgroup M} (x : M ⧸ S) : ‖-x‖ = ‖x‖ 
goal: ‖-x‖ = ‖x‖

full_name: quotient_norm_sub_rev
code: theorem quotient_norm_sub_rev {S : AddSubgroup M} (x y : M ⧸ S) : ‖x - y‖ = ‖y - x‖ 
goal: ‖x - y‖ = ‖y - x‖

full_name: quotient_norm_mk_le
code: /-- The norm of the projection is smaller or equal to the norm of the original element. -/
theorem quotient_norm_mk_le (S : AddSubgroup M) (m : M) : ‖mk' S m‖ ≤ ‖m‖ 
goal: ‖(QuotientAddGroup.mk' S) m‖ ≤ ‖m‖

full_name: quotient_norm_mk_le'
code: /-- The norm of the projection is smaller or equal to the norm of the original element. -/
theorem quotient_norm_mk_le' (S : AddSubgroup M) (m : M) : ‖(m : M ⧸ S)‖ ≤ ‖m‖ 
goal: ‖↑m‖ ≤ ‖m‖

full_name: quotient_norm_mk_eq
code: /-- The norm of the image under the natural morphism to the quotient. -/
theorem quotient_norm_mk_eq (S : AddSubgroup M) (m : M) :
    ‖mk' S m‖ = sInf ((‖m + ·‖) '' S) 
goal: ‖(QuotientAddGroup.mk' S) m‖ = sInf ((fun x => ‖m + x‖) '' ↑S)

full_name: quotient_norm_nonneg
code: /-- The quotient norm is nonnegative. -/
theorem quotient_norm_nonneg (S : AddSubgroup M) (x : M ⧸ S) : 0 ≤ ‖x‖ 
goal: 0 ≤ ‖x‖

full_name: norm_mk_nonneg
code: /-- The quotient norm is nonnegative. -/
theorem norm_mk_nonneg (S : AddSubgroup M) (m : M) : 0 ≤ ‖mk' S m‖ 
goal: 0 ≤ ‖(QuotientAddGroup.mk' S) m‖

full_name: quotient_norm_eq_zero_iff
code: /-- The norm of the image of `m : M` in the quotient by `S` is zero if and only if `m` belongs
to the closure of `S`. -/
theorem quotient_norm_eq_zero_iff (S : AddSubgroup M) (m : M) :
    ‖mk' S m‖ = 0 ↔ m ∈ closure (S : Set M) 
goal: ‖(QuotientAddGroup.mk' S) m‖ = 0 ↔ m ∈ closure ↑S

full_name: QuotientAddGroup.norm_lt_iff
code: theorem QuotientAddGroup.norm_lt_iff {S : AddSubgroup M} {x : M ⧸ S} {r : ℝ} :
    ‖x‖ < r ↔ ∃ m : M, ↑m = x ∧ ‖m‖ < r 
goal: ‖x‖ < r ↔ ∃ m, ↑m = x ∧ ‖m‖ < r

full_name: norm_mk_lt
code: /-- For any `x : M ⧸ S` and any `0 < ε`, there is `m : M` such that `mk' S m = x`
and `‖m‖ < ‖x‖ + ε`. -/
theorem norm_mk_lt {S : AddSubgroup M} (x : M ⧸ S) {ε : ℝ} (hε : 0 < ε) :
    ∃ m : M, mk' S m = x ∧ ‖m‖ < ‖x‖ + ε 
goal: ∃ m, (QuotientAddGroup.mk' S) m = x ∧ ‖m‖ < ‖x‖ + ε

full_name: norm_mk_lt'
code: /-- For any `m : M` and any `0 < ε`, there is `s ∈ S` such that `‖m + s‖ < ‖mk' S m‖ + ε`. -/
theorem norm_mk_lt' (S : AddSubgroup M) (m : M) {ε : ℝ} (hε : 0 < ε) :
    ∃ s ∈ S, ‖m + s‖ < ‖mk' S m‖ + ε 
goal: ∃ s ∈ S, ‖m + s‖ < ‖(QuotientAddGroup.mk' S) m‖ + ε

full_name: quotient_norm_add_le
code: /-- The quotient norm satisfies the triangle inequality. -/
theorem quotient_norm_add_le (S : AddSubgroup M) (x y : M ⧸ S) : ‖x + y‖ ≤ ‖x‖ + ‖y‖ 
goal: ‖x + y‖ ≤ ‖x‖ + ‖y‖

full_name: norm_mk_zero
code: /-- The quotient norm of `0` is `0`. -/
theorem norm_mk_zero (S : AddSubgroup M) : ‖(0 : M ⧸ S)‖ = 0 
goal: ‖0‖ = 0

full_name: norm_mk_eq_zero
code: /-- If `(m : M)` has norm equal to `0` in `M ⧸ S` for a closed subgroup `S` of `M`, then
`m ∈ S`. -/
theorem norm_mk_eq_zero (S : AddSubgroup M) (hS : IsClosed (S : Set M)) (m : M)
    (h : ‖mk' S m‖ = 0) : m ∈ S 
goal: m ∈ S

full_name: quotient_nhd_basis
code: theorem quotient_nhd_basis (S : AddSubgroup M) :
    (𝓝 (0 : M ⧸ S)).HasBasis (fun ε ↦ 0 < ε) fun ε ↦ { x | ‖x‖ < ε } 
goal: (𝓝 0).HasBasis (fun ε => 0 < ε) fun ε => {x | ‖x‖ < ε}

full_name: AddSubgroup.seminormedAddCommGroupQuotient
code: /-- The seminormed group structure on the quotient by an additive subgroup. -/
noncomputable instance AddSubgroup.seminormedAddCommGroupQuotient (S : AddSubgroup M) :
    SeminormedAddCommGroup (M ⧸ S) 
goal: SeminormedAddCommGroup (M ⧸ S)

full_name: AddSubgroup.normedAddCommGroupQuotient
code: /-- The quotient in the category of normed groups. -/
noncomputable instance AddSubgroup.normedAddCommGroupQuotient (S : AddSubgroup M)
    [IsClosed (S : Set M)] : NormedAddCommGroup (M ⧸ S) 
goal: NormedAddCommGroup (M ⧸ S)

full_name: AddSubgroup.normedMk
code: /-- The morphism from a seminormed group to the quotient by a subgroup. -/
noncomputable def normedMk (S : AddSubgroup M) : NormedAddGroupHom M (M ⧸ S) 
goal: NormedAddGroupHom M (M ⧸ S)

full_name: AddSubgroup.normedMk.apply
code: /-- `S.normedMk` agrees with `QuotientAddGroup.mk' S`. -/
@[simp]
theorem normedMk.apply (S : AddSubgroup M) (m : M) : normedMk S m = QuotientAddGroup.mk' S m 
goal: S.normedMk m = (QuotientAddGroup.mk' S) m

full_name: AddSubgroup.surjective_normedMk
code: /-- `S.normedMk` is surjective. -/
theorem surjective_normedMk (S : AddSubgroup M) : Function.Surjective (normedMk S) 
goal: Function.Surjective ⇑S.normedMk

full_name: AddSubgroup.ker_normedMk
code: /-- The kernel of `S.normedMk` is `S`. -/
theorem ker_normedMk (S : AddSubgroup M) : S.normedMk.ker = S 
goal: S.normedMk.ker = S

full_name: AddSubgroup.norm_normedMk_le
code: /-- The operator norm of the projection is at most `1`. -/
theorem norm_normedMk_le (S : AddSubgroup M) : ‖S.normedMk‖ ≤ 1 
goal: ‖S.normedMk‖ ≤ 1

full_name: QuotientAddGroup.norm_lift_apply_le
code: theorem _root_.QuotientAddGroup.norm_lift_apply_le {S : AddSubgroup M} (f : NormedAddGroupHom M N)
    (hf : ∀ x ∈ S, f x = 0) (x : M ⧸ S) : ‖lift S f.toAddMonoidHom hf x‖ ≤ ‖f‖ * ‖x‖ 
goal: ‖(QuotientAddGroup.lift S f.toAddMonoidHom hf) x‖ ≤ ‖f‖ * ‖x‖

full_name: AddSubgroup.norm_normedMk
code: /-- The operator norm of the projection is `1` if the subspace is not dense. -/
theorem norm_normedMk (S : AddSubgroup M) (h : (S.topologicalClosure : Set M) ≠ univ) :
    ‖S.normedMk‖ = 1 
goal: ‖S.normedMk‖ = 1

full_name: AddSubgroup.norm_trivial_quotient_mk
code: /-- The operator norm of the projection is `0` if the subspace is dense. -/
theorem norm_trivial_quotient_mk (S : AddSubgroup M)
    (h : (S.topologicalClosure : Set M) = Set.univ) : ‖S.normedMk‖ = 0 
goal: ‖S.normedMk‖ = 0

full_name: NormedAddGroupHom.IsQuotient.surjective
code: /-- `IsQuotient f`, for `f : M ⟶ N` means that `N` is isomorphic to the quotient of `M`
by the kernel of `f`. -/
structure IsQuotient (f : NormedAddGroupHom M N) : Prop where
  protected surjective : Function.Surjective f
  protected norm : ∀ x, ‖f x‖ = sInf ((fun m => ‖x + m‖) '' f.ker)
goal: Function.Surjective ⇑f

full_name: NormedAddGroupHom.IsQuotient
code: /-- `IsQuotient f`, for `f : M ⟶ N` means that `N` is isomorphic to the quotient of `M`
by the kernel of `f`. -/
structure IsQuotient (f : NormedAddGroupHom M N) : Prop where
  protected surjective : Function.Surjective f
  protected norm : ∀ x, ‖f x‖ = sInf ((fun m => ‖x + m‖) '' f.ker)
goal: Prop

full_name: NormedAddGroupHom.IsQuotient.norm
code: /-- `IsQuotient f`, for `f : M ⟶ N` means that `N` is isomorphic to the quotient of `M`
by the kernel of `f`. -/
structure IsQuotient (f : NormedAddGroupHom M N) : Prop where
  protected surjective : Function.Surjective f
  protected norm : ∀ x, ‖f x‖ = sInf ((fun m => ‖x + m‖) '' f.ker)
goal: ‖f x‖ = sInf ((fun m => ‖x + m‖) '' ↑f.ker)

full_name: NormedAddGroupHom.lift
code: /-- Given `f : NormedAddGroupHom M N` such that `f s = 0` for all `s ∈ S`, where,
`S : AddSubgroup M` is closed, the induced morphism `NormedAddGroupHom (M ⧸ S) N`. -/
noncomputable def lift {N : Type*} [SeminormedAddCommGroup N] (S : AddSubgroup M)
    (f : NormedAddGroupHom M N) (hf : ∀ s ∈ S, f s = 0) : NormedAddGroupHom (M ⧸ S) N 
goal: NormedAddGroupHom (M ⧸ S) N

full_name: NormedAddGroupHom.lift_mk
code: theorem lift_mk {N : Type*} [SeminormedAddCommGroup N] (S : AddSubgroup M)
    (f : NormedAddGroupHom M N) (hf : ∀ s ∈ S, f s = 0) (m : M) :
    lift S f hf (S.normedMk m) = f m 
goal: (NormedAddGroupHom.lift S f hf) (S.normedMk m) = f m

full_name: NormedAddGroupHom.lift_unique
code: theorem lift_unique {N : Type*} [SeminormedAddCommGroup N] (S : AddSubgroup M)
    (f : NormedAddGroupHom M N) (hf : ∀ s ∈ S, f s = 0) (g : NormedAddGroupHom (M ⧸ S) N)
    (h : g.comp S.normedMk = f) : g = lift S f hf 
goal: g = NormedAddGroupHom.lift S f hf

full_name: NormedAddGroupHom.isQuotientQuotient
code: /-- `S.normedMk` satisfies `IsQuotient`. -/
theorem isQuotientQuotient (S : AddSubgroup M) : IsQuotient S.normedMk 
goal: S.normedMk.IsQuotient

full_name: NormedAddGroupHom.IsQuotient.norm_lift
code: theorem IsQuotient.norm_lift {f : NormedAddGroupHom M N} (hquot : IsQuotient f) {ε : ℝ} (hε : 0 < ε)
    (n : N) : ∃ m : M, f m = n ∧ ‖m‖ < ‖n‖ + ε 
goal: ∃ m, f m = n ∧ ‖m‖ < ‖n‖ + ε

full_name: NormedAddGroupHom.IsQuotient.norm_le
code: theorem IsQuotient.norm_le {f : NormedAddGroupHom M N} (hquot : IsQuotient f) (m : M) :
    ‖f m‖ ≤ ‖m‖ 
goal: ‖f m‖ ≤ ‖m‖

full_name: NormedAddGroupHom.norm_lift_le
code: theorem norm_lift_le {N : Type*} [SeminormedAddCommGroup N] (S : AddSubgroup M)
    (f : NormedAddGroupHom M N) (hf : ∀ s ∈ S, f s = 0) :
    ‖lift S f hf‖ ≤ ‖f‖ 
goal: ‖NormedAddGroupHom.lift S f hf‖ ≤ ‖f‖

full_name: NormedAddGroupHom.lift_norm_le
code: theorem lift_norm_le {N : Type*} [SeminormedAddCommGroup N] (S : AddSubgroup M)
    (f : NormedAddGroupHom M N) (hf : ∀ s ∈ S, f s = 0) {c : ℝ≥0} (fb : ‖f‖ ≤ c) :
    ‖lift S f hf‖ ≤ c 
goal: ‖NormedAddGroupHom.lift S f hf‖ ≤ ↑c

full_name: NormedAddGroupHom.lift_normNoninc
code: theorem lift_normNoninc {N : Type*} [SeminormedAddCommGroup N] (S : AddSubgroup M)
    (f : NormedAddGroupHom M N) (hf : ∀ s ∈ S, f s = 0) (fb : f.NormNoninc) :
    (lift S f hf).NormNoninc 
goal: (NormedAddGroupHom.lift S f hf).NormNoninc

full_name: Submodule.Quotient.seminormedAddCommGroup
code: instance Submodule.Quotient.seminormedAddCommGroup : SeminormedAddCommGroup (M ⧸ S) 
goal: SeminormedAddCommGroup (M ⧸ S)

full_name: Submodule.Quotient.normedAddCommGroup
code: instance Submodule.Quotient.normedAddCommGroup [hS : IsClosed (S : Set M)] :
    NormedAddCommGroup (M ⧸ S) 
goal: NormedAddCommGroup (M ⧸ S)

full_name: Submodule.Quotient.completeSpace
code: instance Submodule.Quotient.completeSpace [CompleteSpace M] : CompleteSpace (M ⧸ S) 
goal: CompleteSpace (M ⧸ S)

full_name: Submodule.Quotient.norm_mk_lt
code: /-- For any `x : M ⧸ S` and any `0 < ε`, there is `m : M` such that `Submodule.Quotient.mk m = x`
and `‖m‖ < ‖x‖ + ε`. -/
nonrec theorem Submodule.Quotient.norm_mk_lt {S : Submodule R M} (x : M ⧸ S) {ε : ℝ} (hε : 0 < ε) :
    ∃ m : M, Submodule.Quotient.mk m = x ∧ ‖m‖ < ‖x‖ + ε 
goal: ∃ m, Submodule.Quotient.mk m = x ∧ ‖m‖ < ‖x‖ + ε

full_name: Submodule.Quotient.norm_mk_le
code: theorem Submodule.Quotient.norm_mk_le (m : M) : ‖(Submodule.Quotient.mk m : M ⧸ S)‖ ≤ ‖m‖ 
goal: ‖Submodule.Quotient.mk m‖ ≤ ‖m‖

full_name: Submodule.Quotient.instBoundedSMul
code: instance Submodule.Quotient.instBoundedSMul (𝕜 : Type*)
    [SeminormedCommRing 𝕜] [Module 𝕜 M] [BoundedSMul 𝕜 M] [SMul 𝕜 R] [IsScalarTower 𝕜 R M] :
    BoundedSMul 𝕜 (M ⧸ S) 
goal: BoundedSMul 𝕜 (M ⧸ S)

full_name: Submodule.Quotient.normedSpace
code: instance Submodule.Quotient.normedSpace (𝕜 : Type*) [NormedField 𝕜] [NormedSpace 𝕜 M] [SMul 𝕜 R]
    [IsScalarTower 𝕜 R M] : NormedSpace 𝕜 (M ⧸ S) 
goal: NormedSpace 𝕜 (M ⧸ S)

full_name: Ideal.Quotient.norm_mk_lt
code: nonrec theorem Ideal.Quotient.norm_mk_lt {I : Ideal R} (x : R ⧸ I) {ε : ℝ} (hε : 0 < ε) :
    ∃ r : R, Ideal.Quotient.mk I r = x ∧ ‖r‖ < ‖x‖ + ε 
goal: ∃ r, (Ideal.Quotient.mk I) r = x ∧ ‖r‖ < ‖x‖ + ε

full_name: Ideal.Quotient.norm_mk_le
code: theorem Ideal.Quotient.norm_mk_le (r : R) : ‖Ideal.Quotient.mk I r‖ ≤ ‖r‖ 
goal: ‖(Ideal.Quotient.mk I) r‖ ≤ ‖r‖

full_name: Ideal.Quotient.semiNormedCommRing
code: instance Ideal.Quotient.semiNormedCommRing : SeminormedCommRing (R ⧸ I) 
goal: SeminormedCommRing (R ⧸ I)

full_name: Ideal.Quotient.normedCommRing
code: instance Ideal.Quotient.normedCommRing [IsClosed (I : Set R)] : NormedCommRing (R ⧸ I) 
goal: NormedCommRing (R ⧸ I)

full_name: Ideal.Quotient.normedAlgebra
code: instance Ideal.Quotient.normedAlgebra [NormedAlgebra 𝕜 R] : NormedAlgebra 𝕜 (R ⧸ I) 
goal: NormedAlgebra 𝕜 (R ⧸ I)