File: Mathlib/Analysis/Normed/Algebra/Unitization.lean

full_name: Unitization.splitMul
code: /-- Given `(k, a) : Unitization 𝕜 A`, the second coordinate of `Unitization.splitMul (k, a)` is
the natural representation of `Unitization 𝕜 A` on `A` given by multiplication on the left in
`A →L[𝕜] A`; note that this is not just `NonUnitalAlgHom.Lmul` for a few reasons: (a) that would
either be `A` acting on `A`, or (b) `Unitization 𝕜 A` acting on `Unitization 𝕜 A`, and (c) that's a
`NonUnitalAlgHom` but here we need an `AlgHom`. In addition, the first coordinate of
`Unitization.splitMul (k, a)` should just be `k`. See `Unitization.splitMul_apply` also. -/
def splitMul : Unitization 𝕜 A →ₐ[𝕜] 𝕜 × (A →L[𝕜] A) 
goal: Unitization 𝕜 A →ₐ[𝕜] 𝕜 × (A →L[𝕜] A)

full_name: Unitization.splitMul_apply
code: @[simp]
theorem splitMul_apply (x : Unitization 𝕜 A) :
    splitMul 𝕜 A x = (x.fst, algebraMap 𝕜 (A →L[𝕜] A) x.fst + mul 𝕜 A x.snd) 
goal: (Unitization.splitMul 𝕜 A) x = (x.fst, (algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (ContinuousLinearMap.mul 𝕜 A) x.snd)

full_name: Unitization.splitMul_injective_of_clm_mul_injective
code: /-- this lemma establishes that if `ContinuousLinearMap.mul 𝕜 A` is injective, then so is
`Unitization.splitMul 𝕜 A`. When `A` is a `RegularNormedAlgebra`, then
`ContinuousLinearMap.mul 𝕜 A` is an isometry, and is therefore automatically injective. -/
theorem splitMul_injective_of_clm_mul_injective
    (h : Function.Injective (mul 𝕜 A)) :
    Function.Injective (splitMul 𝕜 A) 
goal: Function.Injective ⇑(Unitization.splitMul 𝕜 A)

full_name: Unitization.splitMul_injective
code: /-- In a `RegularNormedAlgebra`, the map `Unitization.splitMul 𝕜 A` is injective.
We will use this to pull back the norm from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A`. -/
theorem splitMul_injective : Function.Injective (splitMul 𝕜 A) 
goal: Function.Injective ⇑(Unitization.splitMul 𝕜 A)

full_name: Unitization.normedRingAux
code: /-- Pull back the normed ring structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
algebra homomorphism `Unitization.splitMul 𝕜 A`. This does not give us the desired topology,
uniformity or bornology on `Unitization 𝕜 A` (which we want to agree with `Prod`), so we only use
it as a local instance to build the real one. -/
noncomputable abbrev normedRingAux : NormedRing (Unitization 𝕜 A) 
goal: NormedRing (Unitization 𝕜 A)

full_name: Unitization.normedAlgebraAux
code: /-- Pull back the normed algebra structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
algebra homomorphism `Unitization.splitMul 𝕜 A`. This uses the wrong `NormedRing` instance (i.e.,
`Unitization.normedRingAux`), so we only use it as a local instance to build the real one. -/
noncomputable abbrev normedAlgebraAux : NormedAlgebra 𝕜 (Unitization 𝕜 A) 
goal: NormedAlgebra 𝕜 (Unitization 𝕜 A)

full_name: Unitization.norm_def
code: theorem norm_def (x : Unitization 𝕜 A) : ‖x‖ = ‖splitMul 𝕜 A x‖ 
goal: ‖x‖ = ‖(Unitization.splitMul 𝕜 A) x‖

full_name: Unitization.nnnorm_def
code: theorem nnnorm_def (x : Unitization 𝕜 A) : ‖x‖₊ = ‖splitMul 𝕜 A x‖₊ 
goal: ‖x‖₊ = ‖(Unitization.splitMul 𝕜 A) x‖₊

full_name: Unitization.norm_eq_sup
code: /-- This is often the more useful lemma to rewrite the norm as opposed to `Unitization.norm_def`. -/
theorem norm_eq_sup (x : Unitization 𝕜 A) :
    ‖x‖ = ‖x.fst‖ ⊔ ‖algebraMap 𝕜 (A →L[𝕜] A) x.fst + mul 𝕜 A x.snd‖ 
goal: ‖x‖ = ‖x.fst‖ ⊔ ‖(algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (ContinuousLinearMap.mul 𝕜 A) x.snd‖

full_name: Unitization.nnnorm_eq_sup
code: /-- This is often the more useful lemma to rewrite the norm as opposed to
`Unitization.nnnorm_def`. -/
theorem nnnorm_eq_sup (x : Unitization 𝕜 A) :
    ‖x‖₊ = ‖x.fst‖₊ ⊔ ‖algebraMap 𝕜 (A →L[𝕜] A) x.fst + mul 𝕜 A x.snd‖₊ 
goal: ‖x‖₊ = ‖x.fst‖₊ ⊔ ‖(algebraMap 𝕜 (A →L[𝕜] A)) x.fst + (ContinuousLinearMap.mul 𝕜 A) x.snd‖₊

full_name: Unitization.lipschitzWith_addEquiv
code: theorem lipschitzWith_addEquiv :
    LipschitzWith 2 (Unitization.addEquiv 𝕜 A) 
goal: LipschitzWith 2 ⇑(Unitization.addEquiv 𝕜 A)

full_name: Unitization.antilipschitzWith_addEquiv
code: theorem antilipschitzWith_addEquiv :
    AntilipschitzWith 2 (addEquiv 𝕜 A) 
goal: AntilipschitzWith 2 ⇑(Unitization.addEquiv 𝕜 A)

full_name: Unitization.uniformity_eq_aux
code: theorem uniformity_eq_aux :
    𝓤[instUniformSpaceProd.comap <| addEquiv 𝕜 A] = 𝓤 (Unitization 𝕜 A) 
goal: uniformity (Unitization 𝕜 A) = uniformity (Unitization 𝕜 A)

full_name: Unitization.cobounded_eq_aux
code: theorem cobounded_eq_aux :
    @cobounded _ (Bornology.induced <| addEquiv 𝕜 A) = cobounded (Unitization 𝕜 A) 
goal: Bornology.cobounded (Unitization 𝕜 A) = Bornology.cobounded (Unitization 𝕜 A)

full_name: Unitization.instUniformSpace
code: /-- The uniformity on `Unitization 𝕜 A` is inherited from `𝕜 × A`. -/
instance instUniformSpace : UniformSpace (Unitization 𝕜 A) 
goal: UniformSpace (Unitization 𝕜 A)

full_name: Unitization.uniformEquivProd
code: /-- The natural equivalence between `Unitization 𝕜 A` and `𝕜 × A` as a uniform equivalence. -/
def uniformEquivProd : (Unitization 𝕜 A) ≃ᵤ (𝕜 × A) 
goal: Unitization 𝕜 A ≃ᵤ 𝕜 × A

full_name: Unitization.instBornology
code: /-- The bornology on `Unitization 𝕜 A` is inherited from `𝕜 × A`. -/
instance instBornology : Bornology (Unitization 𝕜 A) 
goal: Bornology (Unitization 𝕜 A)

full_name: Unitization.uniformEmbedding_addEquiv
code: theorem uniformEmbedding_addEquiv : UniformEmbedding (addEquiv 𝕜 A) 
goal: UniformEmbedding ⇑(Unitization.addEquiv 𝕜 A)

full_name: Unitization.instCompleteSpace
code: /-- `Unitization 𝕜 A` is complete whenever `𝕜` and `A` are also.  -/
instance instCompleteSpace [CompleteSpace 𝕜] [CompleteSpace A] :
    CompleteSpace (Unitization 𝕜 A) 
goal: CompleteSpace (Unitization 𝕜 A)

full_name: Unitization.instMetricSpace
code: /-- Pull back the metric structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
algebra homomorphism `Unitization.splitMul 𝕜 A`, but replace the bornology and the uniformity so
that they coincide with `𝕜 × A`. -/
noncomputable instance instMetricSpace : MetricSpace (Unitization 𝕜 A) 
goal: MetricSpace (Unitization 𝕜 A)

full_name: Unitization.instNormedRing
code: /-- Pull back the normed ring structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
algebra homomorphism `Unitization.splitMul 𝕜 A`. -/
noncomputable instance instNormedRing : NormedRing (Unitization 𝕜 A) 
goal: NormedRing (Unitization 𝕜 A)

full_name: Unitization.instNormedAlgebra
code: /-- Pull back the normed algebra structure from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A` using the
algebra homomorphism `Unitization.splitMul 𝕜 A`. -/
instance instNormedAlgebra : NormedAlgebra 𝕜 (Unitization 𝕜 A) 
goal: NormedAlgebra 𝕜 (Unitization 𝕜 A)

full_name: Unitization.instNormOneClass
code: instance instNormOneClass : NormOneClass (Unitization 𝕜 A) 
goal: NormOneClass (Unitization 𝕜 A)

full_name: Unitization.norm_inr
code: lemma norm_inr (a : A) : ‖(a : Unitization 𝕜 A)‖ = ‖a‖ 
goal: ‖↑a‖ = ‖a‖

full_name: Unitization.nnnorm_inr
code: lemma nnnorm_inr (a : A) : ‖(a : Unitization 𝕜 A)‖₊ = ‖a‖₊ 
goal: ‖↑a‖₊ = ‖a‖₊

full_name: Unitization.isometry_inr
code: lemma isometry_inr : Isometry ((↑) : A → Unitization 𝕜 A) 
goal: Isometry Unitization.inr

full_name: Unitization.dist_inr
code: lemma dist_inr (a b : A) : dist (a : Unitization 𝕜 A) (b : Unitization 𝕜 A) = dist a b 
goal: dist ↑a ↑b = dist a b

full_name: Unitization.nndist_inr
code: lemma nndist_inr (a b : A) : nndist (a : Unitization 𝕜 A) (b : Unitization 𝕜 A) = nndist a b 
goal: nndist ↑a ↑b = nndist a b