File: Mathlib/Analysis/Normed/Module/Basic.lean

full_name: NormedSpace.norm_smul_le
code: /-- A normed space over a normed field is a vector space endowed with a norm which satisfies the
equality `‖c • x‖ = ‖c‖ ‖x‖`. We require only `‖c • x‖ ≤ ‖c‖ ‖x‖` in the definition, then prove
`‖c • x‖ = ‖c‖ ‖x‖` in `norm_smul`.

Note that since this requires `SeminormedAddCommGroup` and not `NormedAddCommGroup`, this
typeclass can be used for "semi normed spaces" too, just as `Module` can be used for
"semi modules". -/
class NormedSpace (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [SeminormedAddCommGroup E]
    extends Module 𝕜 E where
  norm_smul_le : ∀ (a : 𝕜) (b : E), ‖a • b‖ ≤ ‖a‖ * ‖b‖
goal: ‖a • b‖ ≤ ‖a‖ * ‖b‖

full_name: NormedSpace
code: /-- A normed space over a normed field is a vector space endowed with a norm which satisfies the
equality `‖c • x‖ = ‖c‖ ‖x‖`. We require only `‖c • x‖ ≤ ‖c‖ ‖x‖` in the definition, then prove
`‖c • x‖ = ‖c‖ ‖x‖` in `norm_smul`.

Note that since this requires `SeminormedAddCommGroup` and not `NormedAddCommGroup`, this
typeclass can be used for "semi normed spaces" too, just as `Module` can be used for
"semi modules". -/
class NormedSpace (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [SeminormedAddCommGroup E]
    extends Module 𝕜 E where
  norm_smul_le : ∀ (a : 𝕜) (b : E), ‖a • b‖ ≤ ‖a‖ * ‖b‖
goal: Type (max u_6 u_7)

full_name: NormedSpace.boundedSMul
code: instance (priority := 100) NormedSpace.boundedSMul [NormedSpace 𝕜 E] : BoundedSMul 𝕜 E 
goal: BoundedSMul 𝕜 E

full_name: NormedField.toNormedSpace
code: instance NormedField.toNormedSpace : NormedSpace 𝕜 𝕜 
goal: NormedSpace 𝕜 𝕜

full_name: NormedField.to_boundedSMul
code: instance NormedField.to_boundedSMul : BoundedSMul 𝕜 𝕜 
goal: BoundedSMul 𝕜 𝕜

full_name: norm_zsmul
code: theorem norm_zsmul [NormedSpace 𝕜 E] (n : ℤ) (x : E) : ‖n • x‖ = ‖(n : 𝕜)‖ * ‖x‖ 
goal: ‖n • x‖ = ‖↑n‖ * ‖x‖

full_name: eventually_nhds_norm_smul_sub_lt
code: theorem eventually_nhds_norm_smul_sub_lt (c : 𝕜) (x : E) {ε : ℝ} (h : 0 < ε) :
    ∀ᶠ y in 𝓝 x, ‖c • (y - x)‖ < ε 
goal: ∀ᶠ (y : E) in 𝓝 x, ‖c • (y - x)‖ < ε

full_name: Filter.Tendsto.zero_smul_isBoundedUnder_le
code: theorem Filter.Tendsto.zero_smul_isBoundedUnder_le {f : α → 𝕜} {g : α → E} {l : Filter α}
    (hf : Tendsto f l (𝓝 0)) (hg : IsBoundedUnder (· ≤ ·) l (Norm.norm ∘ g)) :
    Tendsto (fun x => f x • g x) l (𝓝 0) 
goal: Filter.Tendsto (fun x => f x • g x) l (𝓝 0)

full_name: Filter.IsBoundedUnder.smul_tendsto_zero
code: theorem Filter.IsBoundedUnder.smul_tendsto_zero {f : α → 𝕜} {g : α → E} {l : Filter α}
    (hf : IsBoundedUnder (· ≤ ·) l (norm ∘ f)) (hg : Tendsto g l (𝓝 0)) :
    Tendsto (fun x => f x • g x) l (𝓝 0) 
goal: Filter.Tendsto (fun x => f x • g x) l (𝓝 0)

full_name: NormedSpace.discreteTopology_zmultiples
code: instance NormedSpace.discreteTopology_zmultiples
    {E : Type*} [NormedAddCommGroup E] [NormedSpace ℚ E] (e : E) :
    DiscreteTopology <| AddSubgroup.zmultiples e 
goal: DiscreteTopology ↥(AddSubgroup.zmultiples e)

full_name: ULift.normedSpace
code: instance ULift.normedSpace : NormedSpace 𝕜 (ULift E) 
goal: NormedSpace 𝕜 (ULift.{u_6, u_3} E)

full_name: Prod.normedSpace
code: /-- The product of two normed spaces is a normed space, with the sup norm. -/
instance Prod.normedSpace : NormedSpace 𝕜 (E × F) 
goal: NormedSpace 𝕜 (E × F)

full_name: Pi.normedSpace
code: /-- The product of finitely many normed spaces is a normed space, with the sup norm. -/
instance Pi.normedSpace {ι : Type*} {E : ι → Type*} [Fintype ι] [∀ i, SeminormedAddCommGroup (E i)]
    [∀ i, NormedSpace 𝕜 (E i)] : NormedSpace 𝕜 (∀ i, E i) 
goal: NormedSpace 𝕜 ((i : ι) → E i)

full_name: MulOpposite.instNormedSpace
code: instance MulOpposite.instNormedSpace : NormedSpace 𝕜 Eᵐᵒᵖ 
goal: NormedSpace 𝕜 Eᵐᵒᵖ

full_name: Submodule.normedSpace
code: /-- A subspace of a normed space is also a normed space, with the restriction of the norm. -/
instance Submodule.normedSpace {𝕜 R : Type*} [SMul 𝕜 R] [NormedField 𝕜] [Ring R] {E : Type*}
    [SeminormedAddCommGroup E] [NormedSpace 𝕜 E] [Module R E] [IsScalarTower 𝕜 R E]
    (s : Submodule R E) : NormedSpace 𝕜 s 
goal: NormedSpace 𝕜 ↥s

full_name: SubmoduleClass.toNormedSpace
code: instance (priority := 75) SubmoduleClass.toNormedSpace : NormedSpace 𝕜 s 
goal: NormedSpace 𝕜 ↥s

full_name: NormedSpace.induced
code: /-- A linear map from a `Module` to a `NormedSpace` induces a `NormedSpace` structure on the
domain, using the `SeminormedAddCommGroup.induced` norm.

See note [reducible non-instances] -/
abbrev NormedSpace.induced {F : Type*} (𝕜 E G : Type*) [NormedField 𝕜] [AddCommGroup E] [Module 𝕜 E]
    [SeminormedAddCommGroup G] [NormedSpace 𝕜 G] [FunLike F E G] [LinearMapClass F 𝕜 E G] (f : F) :
    @NormedSpace 𝕜 E _ (SeminormedAddCommGroup.induced E G f) 
goal: NormedSpace 𝕜 E

full_name: NormedSpace.toModule'
code: /-- While this may appear identical to `NormedSpace.toModule`, it contains an implicit argument
involving `NormedAddCommGroup.toSeminormedAddCommGroup` that typeclass inference has trouble
inferring.

Specifically, the following instance cannot be found without this `NormedSpace.toModule'`:
```lean
example
  (𝕜 ι : Type*) (E : ι → Type*)
  [NormedField 𝕜] [Π i, NormedAddCommGroup (E i)] [Π i, NormedSpace 𝕜 (E i)] :
  Π i, Module 𝕜 (E i) := by infer_instance
```

[This Zulip thread](https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/Typeclass.20resolution.20under.20binders/near/245151099)
gives some more context. -/
instance (priority := 100) NormedSpace.toModule' : Module 𝕜 F 
goal: Module 𝕜 F

full_name: NormedSpace.exists_lt_norm
code: /-- If `E` is a nontrivial normed space over a nontrivially normed field `𝕜`, then `E` is unbounded:
for any `c : ℝ`, there exists a vector `x : E` with norm strictly greater than `c`. -/
theorem NormedSpace.exists_lt_norm (c : ℝ) : ∃ x : E, c < ‖x‖ 
goal: ∃ x, c < ‖x‖

full_name: NormedSpace.unbounded_univ
code: protected theorem NormedSpace.unbounded_univ : ¬Bornology.IsBounded (univ : Set E) 
goal: ¬Bornology.IsBounded Set.univ

full_name: NormedSpace.cobounded_neBot
code: protected lemma NormedSpace.cobounded_neBot : NeBot (cobounded E) 
goal: (Bornology.cobounded E).NeBot

full_name: NontriviallyNormedField.cobounded_neBot
code: instance (priority := 100) NontriviallyNormedField.cobounded_neBot : NeBot (cobounded 𝕜) 
goal: (Bornology.cobounded 𝕜).NeBot

full_name: RealNormedSpace.cobounded_neBot
code: instance (priority := 80) RealNormedSpace.cobounded_neBot [NormedSpace ℝ E] :
    NeBot (cobounded E) 
goal: (Bornology.cobounded E).NeBot

full_name: NontriviallyNormedField.infinite
code: instance (priority := 80) NontriviallyNormedField.infinite : Infinite 𝕜 
goal: Infinite 𝕜

full_name: NormedSpace.noncompactSpace
code: /-- A normed vector space over an infinite normed field is a noncompact space.
This cannot be an instance because in order to apply it,
Lean would have to search for `NormedSpace 𝕜 E` with unknown `𝕜`.
We register this as an instance in two cases: `𝕜 = E` and `𝕜 = ℝ`. -/
protected theorem NormedSpace.noncompactSpace : NoncompactSpace E 
goal: NoncompactSpace E

full_name: NormedField.noncompactSpace
code: instance (priority := 100) NormedField.noncompactSpace : NoncompactSpace 𝕜 
goal: NoncompactSpace 𝕜

full_name: RealNormedSpace.noncompactSpace
code: instance (priority := 100) RealNormedSpace.noncompactSpace [NormedSpace ℝ E] : NoncompactSpace E 
goal: NoncompactSpace E

full_name: NormedAlgebra
code: /-- A normed algebra `𝕜'` over `𝕜` is normed module that is also an algebra.

See the implementation notes for `Algebra` for a discussion about non-unital algebras. Following
the strategy there, a non-unital *normed* algebra can be written as:
```lean
variable [NormedField 𝕜] [NonUnitalSeminormedRing 𝕜']
variable [NormedSpace 𝕜 𝕜'] [SMulCommClass 𝕜 𝕜' 𝕜'] [IsScalarTower 𝕜 𝕜' 𝕜']
```
-/
class NormedAlgebra (𝕜 : Type*) (𝕜' : Type*) [NormedField 𝕜] [SeminormedRing 𝕜'] extends
  Algebra 𝕜 𝕜' where
  norm_smul_le : ∀ (r : 𝕜) (x : 𝕜'), ‖r • x‖ ≤ ‖r‖ * ‖x‖
goal: Type (max u_6 u_7)

full_name: NormedAlgebra.norm_smul_le
code: /-- A normed algebra `𝕜'` over `𝕜` is normed module that is also an algebra.

See the implementation notes for `Algebra` for a discussion about non-unital algebras. Following
the strategy there, a non-unital *normed* algebra can be written as:
```lean
variable [NormedField 𝕜] [NonUnitalSeminormedRing 𝕜']
variable [NormedSpace 𝕜 𝕜'] [SMulCommClass 𝕜 𝕜' 𝕜'] [IsScalarTower 𝕜 𝕜' 𝕜']
```
-/
class NormedAlgebra (𝕜 : Type*) (𝕜' : Type*) [NormedField 𝕜] [SeminormedRing 𝕜'] extends
  Algebra 𝕜 𝕜' where
  norm_smul_le : ∀ (r : 𝕜) (x : 𝕜'), ‖r • x‖ ≤ ‖r‖ * ‖x‖
goal: ‖r • x‖ ≤ ‖r‖ * ‖x‖

full_name: NormedAlgebra.toNormedSpace
code: instance (priority := 100) NormedAlgebra.toNormedSpace : NormedSpace 𝕜 𝕜' 
goal: NormedSpace 𝕜 𝕜'

full_name: NormedAlgebra.toNormedSpace'
code: /-- While this may appear identical to `NormedAlgebra.toNormedSpace`, it contains an implicit
argument involving `NormedRing.toSeminormedRing` that typeclass inference has trouble inferring.

Specifically, the following instance cannot be found without this `NormedSpace.toModule'`:
```lean
example
  (𝕜 ι : Type*) (E : ι → Type*)
  [NormedField 𝕜] [Π i, NormedRing (E i)] [Π i, NormedAlgebra 𝕜 (E i)] :
  Π i, Module 𝕜 (E i) := by infer_instance
```

See `NormedSpace.toModule'` for a similar situation. -/
instance (priority := 100) NormedAlgebra.toNormedSpace' {𝕜'} [NormedRing 𝕜'] [NormedAlgebra 𝕜 𝕜'] :
    NormedSpace 𝕜 𝕜' 
goal: NormedSpace 𝕜 𝕜'

full_name: norm_algebraMap
code: theorem norm_algebraMap (x : 𝕜) : ‖algebraMap 𝕜 𝕜' x‖ = ‖x‖ * ‖(1 : 𝕜')‖ 
goal: ‖(algebraMap 𝕜 𝕜') x‖ = ‖x‖ * ‖1‖

full_name: nnnorm_algebraMap
code: theorem nnnorm_algebraMap (x : 𝕜) : ‖algebraMap 𝕜 𝕜' x‖₊ = ‖x‖₊ * ‖(1 : 𝕜')‖₊ 
goal: ‖(algebraMap 𝕜 𝕜') x‖₊ = ‖x‖₊ * ‖1‖₊

full_name: norm_algebraMap'
code: @[simp]
theorem norm_algebraMap' [NormOneClass 𝕜'] (x : 𝕜) : ‖algebraMap 𝕜 𝕜' x‖ = ‖x‖ 
goal: ‖(algebraMap 𝕜 𝕜') x‖ = ‖x‖

full_name: nnnorm_algebraMap'
code: @[simp]
theorem nnnorm_algebraMap' [NormOneClass 𝕜'] (x : 𝕜) : ‖algebraMap 𝕜 𝕜' x‖₊ = ‖x‖₊ 
goal: ‖(algebraMap 𝕜 𝕜') x‖₊ = ‖x‖₊

full_name: norm_algebraMap_nnreal
code: @[simp]
theorem norm_algebraMap_nnreal (x : ℝ≥0) : ‖algebraMap ℝ≥0 𝕜' x‖ = x 
goal: ‖(algebraMap ℝ≥0 𝕜') x‖ = ↑x

full_name: nnnorm_algebraMap_nnreal
code: @[simp]
theorem nnnorm_algebraMap_nnreal (x : ℝ≥0) : ‖algebraMap ℝ≥0 𝕜' x‖₊ = x 
goal: ‖(algebraMap ℝ≥0 𝕜') x‖₊ = x

full_name: algebraMap_isometry
code: /-- In a normed algebra, the inclusion of the base field in the extended field is an isometry. -/
theorem algebraMap_isometry [NormOneClass 𝕜'] : Isometry (algebraMap 𝕜 𝕜') 
goal: Isometry ⇑(algebraMap 𝕜 𝕜')

full_name: NormedAlgebra.id
code: instance NormedAlgebra.id : NormedAlgebra 𝕜 𝕜 
goal: NormedAlgebra 𝕜 𝕜

full_name: normedAlgebraRat
code: /-- Any normed characteristic-zero division ring that is a normed algebra over the reals is also a
normed algebra over the rationals.

Phrased another way, if `𝕜` is a normed algebra over the reals, then `AlgebraRat` respects that
norm. -/
instance normedAlgebraRat {𝕜} [NormedDivisionRing 𝕜] [CharZero 𝕜] [NormedAlgebra ℝ 𝕜] :
    NormedAlgebra ℚ 𝕜 
goal: NormedAlgebra ℚ 𝕜

full_name: PUnit.normedAlgebra
code: instance PUnit.normedAlgebra : NormedAlgebra 𝕜 PUnit 
goal: NormedAlgebra 𝕜 PUnit.{u_6 + 1}

full_name: instNormedAlgebraULift
code: instance : NormedAlgebra 𝕜 (ULift 𝕜') 
goal: NormedAlgebra 𝕜 (ULift.{u_6, u_2} 𝕜')

full_name: Prod.normedAlgebra
code: /-- The product of two normed algebras is a normed algebra, with the sup norm. -/
instance Prod.normedAlgebra {E F : Type*} [SeminormedRing E] [SeminormedRing F] [NormedAlgebra 𝕜 E]
    [NormedAlgebra 𝕜 F] : NormedAlgebra 𝕜 (E × F) 
goal: NormedAlgebra 𝕜 (E × F)

full_name: Pi.normedAlgebra
code: /-- The product of finitely many normed algebras is a normed algebra, with the sup norm. -/
instance Pi.normedAlgebra {ι : Type*} {E : ι → Type*} [Fintype ι] [∀ i, SeminormedRing (E i)]
    [∀ i, NormedAlgebra 𝕜 (E i)] : NormedAlgebra 𝕜 (∀ i, E i) 
goal: NormedAlgebra 𝕜 ((i : ι) → E i)

full_name: MulOpposite.instNormedAlgebra
code: instance MulOpposite.instNormedAlgebra {E : Type*} [SeminormedRing E] [NormedAlgebra 𝕜 E] :
    NormedAlgebra 𝕜 Eᵐᵒᵖ 
goal: NormedAlgebra 𝕜 Eᵐᵒᵖ

full_name: NormedAlgebra.induced
code: /-- A non-unital algebra homomorphism from an `Algebra` to a `NormedAlgebra` induces a
`NormedAlgebra` structure on the domain, using the `SeminormedRing.induced` norm.

See note [reducible non-instances] -/
abbrev NormedAlgebra.induced {F : Type*} (𝕜 R S : Type*) [NormedField 𝕜] [Ring R] [Algebra 𝕜 R]
    [SeminormedRing S] [NormedAlgebra 𝕜 S] [FunLike F R S] [NonUnitalAlgHomClass F 𝕜 R S]
    (f : F) :
    @NormedAlgebra 𝕜 R _ (SeminormedRing.induced R S f) 
goal: NormedAlgebra 𝕜 R

full_name: Subalgebra.toNormedAlgebra
code: instance Subalgebra.toNormedAlgebra {𝕜 A : Type*} [SeminormedRing A] [NormedField 𝕜]
    [NormedAlgebra 𝕜 A] (S : Subalgebra 𝕜 A) : NormedAlgebra 𝕜 S 
goal: NormedAlgebra 𝕜 ↥S

full_name: SubalgebraClass.toNormedAlgebra
code: instance (priority := 75) SubalgebraClass.toNormedAlgebra : NormedAlgebra 𝕜 s 
goal: NormedAlgebra 𝕜 ↥s

full_name: instSeminormedAddCommGroupRestrictScalars
code: instance [I : SeminormedAddCommGroup E] :
    SeminormedAddCommGroup (RestrictScalars 𝕜 𝕜' E) 
goal: SeminormedAddCommGroup (RestrictScalars 𝕜 𝕜' E)

full_name: instNormedAddCommGroupRestrictScalars
code: instance [I : NormedAddCommGroup E] :
    NormedAddCommGroup (RestrictScalars 𝕜 𝕜' E) 
goal: NormedAddCommGroup (RestrictScalars 𝕜 𝕜' E)

full_name: instNonUnitalSeminormedRingRestrictScalars
code: instance [I : NonUnitalSeminormedRing E] :
    NonUnitalSeminormedRing (RestrictScalars 𝕜 𝕜' E) 
goal: NonUnitalSeminormedRing (RestrictScalars 𝕜 𝕜' E)

full_name: instNonUnitalNormedRingRestrictScalars
code: instance [I : NonUnitalNormedRing E] :
    NonUnitalNormedRing (RestrictScalars 𝕜 𝕜' E) 
goal: NonUnitalNormedRing (RestrictScalars 𝕜 𝕜' E)

full_name: instSeminormedRingRestrictScalars
code: instance [I : SeminormedRing E] :
    SeminormedRing (RestrictScalars 𝕜 𝕜' E) 
goal: SeminormedRing (RestrictScalars 𝕜 𝕜' E)

full_name: instNormedRingRestrictScalars
code: instance [I : NormedRing E] :
    NormedRing (RestrictScalars 𝕜 𝕜' E) 
goal: NormedRing (RestrictScalars 𝕜 𝕜' E)

full_name: instNonUnitalSeminormedCommRingRestrictScalars
code: instance [I : NonUnitalSeminormedCommRing E] :
    NonUnitalSeminormedCommRing (RestrictScalars 𝕜 𝕜' E) 
goal: NonUnitalSeminormedCommRing (RestrictScalars 𝕜 𝕜' E)

full_name: instNonUnitalNormedCommRingRestrictScalars
code: instance [I : NonUnitalNormedCommRing E] :
    NonUnitalNormedCommRing (RestrictScalars 𝕜 𝕜' E) 
goal: NonUnitalNormedCommRing (RestrictScalars 𝕜 𝕜' E)

full_name: instSeminormedCommRingRestrictScalars
code: instance [I : SeminormedCommRing E] :
    SeminormedCommRing (RestrictScalars 𝕜 𝕜' E) 
goal: SeminormedCommRing (RestrictScalars 𝕜 𝕜' E)

full_name: instNormedCommRingRestrictScalars
code: instance [I : NormedCommRing E] :
    NormedCommRing (RestrictScalars 𝕜 𝕜' E) 
goal: NormedCommRing (RestrictScalars 𝕜 𝕜' E)

full_name: RestrictScalars.normedSpace
code: /-- If `E` is a normed space over `𝕜'` and `𝕜` is a normed algebra over `𝕜'`, then
`RestrictScalars.module` is additionally a `NormedSpace`. -/
instance RestrictScalars.normedSpace : NormedSpace 𝕜 (RestrictScalars 𝕜 𝕜' E) 
goal: NormedSpace 𝕜 (RestrictScalars 𝕜 𝕜' E)

full_name: Module.RestrictScalars.normedSpaceOrig
code: /-- The action of the original normed_field on `RestrictScalars 𝕜 𝕜' E`.
This is not an instance as it would be contrary to the purpose of `RestrictScalars`.
-/
def Module.RestrictScalars.normedSpaceOrig {𝕜 : Type*} {𝕜' : Type*} {E : Type*} [NormedField 𝕜']
    [SeminormedAddCommGroup E] [I : NormedSpace 𝕜' E] : NormedSpace 𝕜' (RestrictScalars 𝕜 𝕜' E) 
goal: NormedSpace 𝕜' (RestrictScalars 𝕜 𝕜' E)

full_name: NormedSpace.restrictScalars
code: /-- Warning: This declaration should be used judiciously.
Please consider using `IsScalarTower` and/or `RestrictScalars 𝕜 𝕜' E` instead.

This definition allows the `RestrictScalars.normedSpace` instance to be put directly on `E`
rather on `RestrictScalars 𝕜 𝕜' E`. This would be a very bad instance; both because `𝕜'` cannot be
inferred, and because it is likely to create instance diamonds.
-/
def NormedSpace.restrictScalars : NormedSpace 𝕜 E 
goal: NormedSpace 𝕜 E

full_name: RestrictScalars.normedAlgebra
code: /-- If `E` is a normed algebra over `𝕜'` and `𝕜` is a normed algebra over `𝕜'`, then
`RestrictScalars.module` is additionally a `NormedAlgebra`. -/
instance RestrictScalars.normedAlgebra : NormedAlgebra 𝕜 (RestrictScalars 𝕜 𝕜' E) 
goal: NormedAlgebra 𝕜 (RestrictScalars 𝕜 𝕜' E)

full_name: Module.RestrictScalars.normedAlgebraOrig
code: /-- The action of the original normed_field on `RestrictScalars 𝕜 𝕜' E`.
This is not an instance as it would be contrary to the purpose of `RestrictScalars`.
-/
def Module.RestrictScalars.normedAlgebraOrig {𝕜 : Type*} {𝕜' : Type*} {E : Type*} [NormedField 𝕜']
    [SeminormedRing E] [I : NormedAlgebra 𝕜' E] : NormedAlgebra 𝕜' (RestrictScalars 𝕜 𝕜' E) 
goal: NormedAlgebra 𝕜' (RestrictScalars 𝕜 𝕜' E)

full_name: NormedAlgebra.restrictScalars
code: /-- Warning: This declaration should be used judiciously.
Please consider using `IsScalarTower` and/or `RestrictScalars 𝕜 𝕜' E` instead.

This definition allows the `RestrictScalars.normedAlgebra` instance to be put directly on `E`
rather on `RestrictScalars 𝕜 𝕜' E`. This would be a very bad instance; both because `𝕜'` cannot be
inferred, and because it is likely to create instance diamonds.
-/
def NormedAlgebra.restrictScalars : NormedAlgebra 𝕜 E 
goal: NormedAlgebra 𝕜 E

full_name: SeminormedAddCommGroup.Core.norm_smul
code: /-- A structure encapsulating minimal axioms needed to defined a seminormed vector space, as found
in textbooks. This is meant to be used to easily define `SeminormedAddCommGroup E` instances from
scratch on a type with no preexisting distance or topology. -/
structure SeminormedAddCommGroup.Core (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [AddCommGroup E]
    [Norm E] [Module 𝕜 E] : Prop where
  norm_nonneg (x : E) : 0 ≤ ‖x‖
  norm_smul (c : 𝕜) (x : E) : ‖c • x‖ = ‖c‖ * ‖x‖
  norm_triangle (x y : E) : ‖x + y‖ ≤ ‖x‖ + ‖y‖
goal: ‖c • x‖ = ‖c‖ * ‖x‖

full_name: SeminormedAddCommGroup.Core.norm_nonneg
code: /-- A structure encapsulating minimal axioms needed to defined a seminormed vector space, as found
in textbooks. This is meant to be used to easily define `SeminormedAddCommGroup E` instances from
scratch on a type with no preexisting distance or topology. -/
structure SeminormedAddCommGroup.Core (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [AddCommGroup E]
    [Norm E] [Module 𝕜 E] : Prop where
  norm_nonneg (x : E) : 0 ≤ ‖x‖
  norm_smul (c : 𝕜) (x : E) : ‖c • x‖ = ‖c‖ * ‖x‖
  norm_triangle (x y : E) : ‖x + y‖ ≤ ‖x‖ + ‖y‖
goal: 0 ≤ ‖x‖

full_name: SeminormedAddCommGroup.Core
code: /-- A structure encapsulating minimal axioms needed to defined a seminormed vector space, as found
in textbooks. This is meant to be used to easily define `SeminormedAddCommGroup E` instances from
scratch on a type with no preexisting distance or topology. -/
structure SeminormedAddCommGroup.Core (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [AddCommGroup E]
    [Norm E] [Module 𝕜 E] : Prop where
  norm_nonneg (x : E) : 0 ≤ ‖x‖
  norm_smul (c : 𝕜) (x : E) : ‖c • x‖ = ‖c‖ * ‖x‖
  norm_triangle (x y : E) : ‖x + y‖ ≤ ‖x‖ + ‖y‖
goal: Prop

full_name: SeminormedAddCommGroup.Core.norm_triangle
code: /-- A structure encapsulating minimal axioms needed to defined a seminormed vector space, as found
in textbooks. This is meant to be used to easily define `SeminormedAddCommGroup E` instances from
scratch on a type with no preexisting distance or topology. -/
structure SeminormedAddCommGroup.Core (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [AddCommGroup E]
    [Norm E] [Module 𝕜 E] : Prop where
  norm_nonneg (x : E) : 0 ≤ ‖x‖
  norm_smul (c : 𝕜) (x : E) : ‖c • x‖ = ‖c‖ * ‖x‖
  norm_triangle (x y : E) : ‖x + y‖ ≤ ‖x‖ + ‖y‖
goal: ‖x + y‖ ≤ ‖x‖ + ‖y‖

full_name: PseudoMetricSpace.ofSeminormedAddCommGroupCore
code: /-- Produces a `PseudoMetricSpace E` instance from a `SeminormedAddCommGroup.Core`. Note that
if this is used to define an instance on a type, it also provides a new uniformity and
topology on the type. See note [reducible non-instances]. -/
abbrev PseudoMetricSpace.ofSeminormedAddCommGroupCore {𝕜 E : Type*} [NormedField 𝕜] [AddCommGroup E]
    [Norm E] [Module 𝕜 E] (core : SeminormedAddCommGroup.Core 𝕜 E) :
    PseudoMetricSpace E 
goal: PseudoMetricSpace E

full_name: PseudoEMetricSpace.ofSeminormedAddCommGroupCore
code: /-- Produces a `PseudoEMetricSpace E` instance from a `SeminormedAddCommGroup.Core`. Note that
if this is used to define an instance on a type, it also provides a new uniformity and
topology on the type. See note [reducible non-instances]. -/
abbrev PseudoEMetricSpace.ofSeminormedAddCommGroupCore {𝕜 E : Type*} [NormedField 𝕜]
    [AddCommGroup E] [Norm E] [Module 𝕜 E]
    (core : SeminormedAddCommGroup.Core 𝕜 E) : PseudoEMetricSpace E 
goal: PseudoEMetricSpace E

full_name: PseudoMetricSpace.ofSeminormedAddCommGroupCoreReplaceUniformity
code: /-- Produces a `PseudoEMetricSpace E` instance from a `SeminormedAddCommGroup.Core` on a type that
already has an existing uniform space structure. This requires a proof that the uniformity induced
by the norm is equal to the preexisting uniformity. See note [reducible non-instances]. -/
abbrev PseudoMetricSpace.ofSeminormedAddCommGroupCoreReplaceUniformity {𝕜 E : Type*} [NormedField 𝕜]
    [AddCommGroup E] [Norm E] [Module 𝕜 E] [U : UniformSpace E]
    (core : SeminormedAddCommGroup.Core 𝕜 E)
    (H : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace
        (self := PseudoEMetricSpace.ofSeminormedAddCommGroupCore core)]) :
    PseudoMetricSpace E 
goal: PseudoMetricSpace E

full_name: PseudoMetricSpace.ofSeminormedAddCommGroupCoreReplaceAll
code: /-- Produces a `PseudoEMetricSpace E` instance from a `SeminormedAddCommGroup.Core` on a type that
already has a preexisting uniform space structure and a preexisting bornology. This requires proofs
that the uniformity induced by the norm is equal to the preexisting uniformity, and likewise for
the bornology. See note [reducible non-instances]. -/
abbrev PseudoMetricSpace.ofSeminormedAddCommGroupCoreReplaceAll {𝕜 E : Type*} [NormedField 𝕜]
    [AddCommGroup E] [Norm E] [Module 𝕜 E] [U : UniformSpace E] [B : Bornology E]
    (core : SeminormedAddCommGroup.Core 𝕜 E)
    (HU : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace
      (self := PseudoEMetricSpace.ofSeminormedAddCommGroupCore core)])
    (HB : ∀ s : Set E, @IsBounded _ B s
      ↔ @IsBounded _ (PseudoMetricSpace.ofSeminormedAddCommGroupCore core).toBornology s) :
    PseudoMetricSpace E 
goal: PseudoMetricSpace E

full_name: SeminormedAddCommGroup.ofCore
code: /-- Produces a `SeminormedAddCommGroup E` instance from a `SeminormedAddCommGroup.Core`. Note that
if this is used to define an instance on a type, it also provides a new distance measure from the
norm.  it must therefore not be used on a type with a preexisting distance measure or topology.
See note [reducible non-instances]. -/
abbrev SeminormedAddCommGroup.ofCore {𝕜 : Type*} {E : Type*} [NormedField 𝕜] [AddCommGroup E]
    [Norm E] [Module 𝕜 E] (core : SeminormedAddCommGroup.Core 𝕜 E) : SeminormedAddCommGroup E 
goal: SeminormedAddCommGroup E

full_name: SeminormedAddCommGroup.ofCoreReplaceUniformity
code: /-- Produces a `SeminormedAddCommGroup E` instance from a `SeminormedAddCommGroup.Core` on a type
that already has an existing uniform space structure. This requires a proof that the uniformity
induced by the norm is equal to the preexisting uniformity. See note [reducible non-instances]. -/
abbrev SeminormedAddCommGroup.ofCoreReplaceUniformity {𝕜 : Type*} {E : Type*} [NormedField 𝕜]
    [AddCommGroup E] [Norm E] [Module 𝕜 E] [U : UniformSpace E]
    (core : SeminormedAddCommGroup.Core 𝕜 E)
    (H : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace
      (self := PseudoEMetricSpace.ofSeminormedAddCommGroupCore core)]) :
    SeminormedAddCommGroup E 
goal: SeminormedAddCommGroup E

full_name: SeminormedAddCommGroup.ofCoreReplaceAll
code: /-- Produces a `SeminormedAddCommGroup E` instance from a `SeminormedAddCommGroup.Core` on a type
that already has a preexisting uniform space structure and a preexisting bornology. This requires
proofs that the uniformity induced by the norm is equal to the preexisting uniformity, and likewise
for the bornology. See note [reducible non-instances]. -/
abbrev SeminormedAddCommGroup.ofCoreReplaceAll {𝕜 : Type*} {E : Type*} [NormedField 𝕜]
    [AddCommGroup E] [Norm E] [Module 𝕜 E] [U : UniformSpace E] [B : Bornology E]
    (core : SeminormedAddCommGroup.Core 𝕜 E)
    (HU : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace
      (self := PseudoEMetricSpace.ofSeminormedAddCommGroupCore core)])
    (HB : ∀ s : Set E, @IsBounded _ B s
      ↔ @IsBounded _ (PseudoMetricSpace.ofSeminormedAddCommGroupCore core).toBornology s) :
    SeminormedAddCommGroup E 
goal: SeminormedAddCommGroup E

full_name: NormedSpace.Core
code: /-- A structure encapsulating minimal axioms needed to defined a normed vector space, as found
in textbooks. This is meant to be used to easily define `NormedAddCommGroup E` and `NormedSpace E`
instances from scratch on a type with no preexisting distance or topology. -/
structure NormedSpace.Core (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [AddCommGroup E] [Module 𝕜 E]
    [Norm E] extends SeminormedAddCommGroup.Core 𝕜 E : Prop where
  norm_eq_zero_iff (x : E) : ‖x‖ = 0 ↔ x = 0
goal: Prop

full_name: NormedSpace.Core.norm_eq_zero_iff
code: /-- A structure encapsulating minimal axioms needed to defined a normed vector space, as found
in textbooks. This is meant to be used to easily define `NormedAddCommGroup E` and `NormedSpace E`
instances from scratch on a type with no preexisting distance or topology. -/
structure NormedSpace.Core (𝕜 : Type*) (E : Type*) [NormedField 𝕜] [AddCommGroup E] [Module 𝕜 E]
    [Norm E] extends SeminormedAddCommGroup.Core 𝕜 E : Prop where
  norm_eq_zero_iff (x : E) : ‖x‖ = 0 ↔ x = 0
goal: ‖x‖ = 0 ↔ x = 0

full_name: NormedAddCommGroup.ofCore
code: /-- Produces a `NormedAddCommGroup E` instance from a `NormedSpace.Core`. Note that if this is
used to define an instance on a type, it also provides a new distance measure from the norm.
it must therefore not be used on a type with a preexisting distance measure.
See note [reducible non-instances]. -/
abbrev NormedAddCommGroup.ofCore (core : NormedSpace.Core 𝕜 E) : NormedAddCommGroup E 
goal: NormedAddCommGroup E

full_name: NormedAddCommGroup.ofCoreReplaceUniformity
code: /-- Produces a `NormedAddCommGroup E` instance from a `NormedAddCommGroup.Core` on a type
that already has an existing uniform space structure. This requires a proof that the uniformity
induced by the norm is equal to the preexisting uniformity. See note [reducible non-instances]. -/
abbrev NormedAddCommGroup.ofCoreReplaceUniformity [U : UniformSpace E] (core : NormedSpace.Core 𝕜 E)
    (H : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace
      (self := PseudoEMetricSpace.ofSeminormedAddCommGroupCore core.toCore)]) :
    NormedAddCommGroup E 
goal: NormedAddCommGroup E

full_name: NormedAddCommGroup.ofCoreReplaceAll
code: /-- Produces a `NormedAddCommGroup E` instance from a `NormedAddCommGroup.Core` on a type
that already has a preexisting uniform space structure and a preexisting bornology. This requires
proofs that the uniformity induced by the norm is equal to the preexisting uniformity, and likewise
for the bornology. See note [reducible non-instances]. -/
abbrev NormedAddCommGroup.ofCoreReplaceAll [U : UniformSpace E] [B : Bornology E]
    (core : NormedSpace.Core 𝕜 E)
    (HU : 𝓤[U] = 𝓤[PseudoEMetricSpace.toUniformSpace
      (self := PseudoEMetricSpace.ofSeminormedAddCommGroupCore core.toCore)])
    (HB : ∀ s : Set E, @IsBounded _ B s
      ↔ @IsBounded _ (PseudoMetricSpace.ofSeminormedAddCommGroupCore core.toCore).toBornology s) :
    NormedAddCommGroup E 
goal: NormedAddCommGroup E

full_name: NormedSpace.ofCore
code: /-- Produces a `NormedSpace 𝕜 E` instance from a `NormedSpace.Core`. This is meant to be used
on types where the `NormedAddCommGroup E` instance has also been defined using `core`.
See note [reducible non-instances]. -/
abbrev NormedSpace.ofCore {𝕜 : Type*} {E : Type*} [NormedField 𝕜] [SeminormedAddCommGroup E]
    [Module 𝕜 E] (core : NormedSpace.Core 𝕜 E) : NormedSpace 𝕜 E 
goal: NormedSpace 𝕜 E