File: Mathlib/Analysis/CstarAlgebra/Multiplier.lean

full_name: DoubleCentralizer.central
code: /-- The type of *double centralizers*, also known as the *multiplier algebra* and denoted by
`𝓜(𝕜, A)`, of a non-unital normed algebra.

If `x : 𝓜(𝕜, A)`, then `x.fst` and `x.snd` are what is usually referred to as $L$ and $R$. -/
structure DoubleCentralizer (𝕜 : Type u) (A : Type v) [NontriviallyNormedField 𝕜]
    [NonUnitalNormedRing A] [NormedSpace 𝕜 A] [SMulCommClass 𝕜 A A] [IsScalarTower 𝕜 A A] extends
    (A →L[𝕜] A) × (A →L[𝕜] A) where
  /-- The centrality condition that the maps linear maps intertwine one another. -/
  central : ∀ x y : A, snd x * y = x * fst y
goal: self.toProd.2 x * y = x * self.toProd.1 y

full_name: DoubleCentralizer
code: /-- The type of *double centralizers*, also known as the *multiplier algebra* and denoted by
`𝓜(𝕜, A)`, of a non-unital normed algebra.

If `x : 𝓜(𝕜, A)`, then `x.fst` and `x.snd` are what is usually referred to as $L$ and $R$. -/
structure DoubleCentralizer (𝕜 : Type u) (A : Type v) [NontriviallyNormedField 𝕜]
    [NonUnitalNormedRing A] [NormedSpace 𝕜 A] [SMulCommClass 𝕜 A A] [IsScalarTower 𝕜 A A] extends
    (A →L[𝕜] A) × (A →L[𝕜] A) where
  /-- The centrality condition that the maps linear maps intertwine one another. -/
  central : ∀ x y : A, snd x * y = x * fst y
goal: Type v

full_name: MultiplierAlgebra.«_aux_Mathlib_Analysis_CstarAlgebra_Multiplier___macroRules_MultiplierAlgebra_term𝓜(_,_)_1»
code: @[inherit_doc]
scoped[MultiplierAlgebra] notation "𝓜(" 𝕜 ", " A ")" => DoubleCentralizer 𝕜 A
goal: Lean.Macro

full_name: MultiplierAlgebra._aux_Mathlib_Analysis_CstarAlgebra_Multiplier___unexpand_DoubleCentralizer_1
code: @[inherit_doc]
scoped[MultiplierAlgebra] notation "𝓜(" 𝕜 ", " A ")" => DoubleCentralizer 𝕜 A
goal: Lean.PrettyPrinter.Unexpander

full_name: DoubleCentralizer.ext
code: @[ext]
lemma DoubleCentralizer.ext (𝕜 : Type u) (A : Type v) [NontriviallyNormedField 𝕜]
    [NonUnitalNormedRing A] [NormedSpace 𝕜 A] [SMulCommClass 𝕜 A A] [IsScalarTower 𝕜 A A]
    (a b : 𝓜(𝕜, A)) (h : a.toProd = b.toProd) : a = b 
goal: a = b

full_name: DoubleCentralizer.range_toProd
code: theorem range_toProd :
    Set.range toProd = { lr : (A →L[𝕜] A) × (A →L[𝕜] A) | ∀ x y, lr.2 x * y = x * lr.1 y } 
goal: Set.range DoubleCentralizer.toProd = {lr | ∀ (x y : A), lr.2 x * y = x * lr.1 y}

full_name: DoubleCentralizer.instAdd
code: instance instAdd : Add 𝓜(𝕜, A) 
goal: Add 𝓜(𝕜, A)

full_name: DoubleCentralizer.instZero
code: instance instZero : Zero 𝓜(𝕜, A) 
goal: Zero 𝓜(𝕜, A)

full_name: DoubleCentralizer.instNeg
code: instance instNeg : Neg 𝓜(𝕜, A) 
goal: Neg 𝓜(𝕜, A)

full_name: DoubleCentralizer.instSub
code: instance instSub : Sub 𝓜(𝕜, A) 
goal: Sub 𝓜(𝕜, A)

full_name: DoubleCentralizer.instSMul
code: instance instSMul : SMul S 𝓜(𝕜, A) 
goal: SMul S 𝓜(𝕜, A)

full_name: DoubleCentralizer.smul_toProd
code: @[simp]
theorem smul_toProd (s : S) (a : 𝓜(𝕜, A)) : (s • a).toProd = s • a.toProd 
goal: (s • a).toProd = s • a.toProd

full_name: DoubleCentralizer.smul_fst
code: theorem smul_fst (s : S) (a : 𝓜(𝕜, A)) : (s • a).fst = s • a.fst 
goal: (s • a).toProd.1 = s • a.toProd.1

full_name: DoubleCentralizer.smul_snd
code: theorem smul_snd (s : S) (a : 𝓜(𝕜, A)) : (s • a).snd = s • a.snd 
goal: (s • a).toProd.2 = s • a.toProd.2

full_name: DoubleCentralizer.instIsScalarTower
code: instance instIsScalarTower [SMul S T] [IsScalarTower S T A] : IsScalarTower S T 𝓜(𝕜, A) 
goal: IsScalarTower S T 𝓜(𝕜, A)

full_name: DoubleCentralizer.instSMulCommClass
code: instance instSMulCommClass [SMulCommClass S T A] : SMulCommClass S T 𝓜(𝕜, A) 
goal: SMulCommClass S T 𝓜(𝕜, A)

full_name: DoubleCentralizer.instIsCentralScalar
code: instance instIsCentralScalar {R : Type*} [Semiring R] [Module R A] [SMulCommClass 𝕜 R A]
    [ContinuousConstSMul R A] [IsScalarTower R A A] [SMulCommClass R A A] [Module Rᵐᵒᵖ A]
    [IsCentralScalar R A] : IsCentralScalar R 𝓜(𝕜, A) 
goal: IsCentralScalar R 𝓜(𝕜, A)

full_name: DoubleCentralizer.instOne
code: instance instOne : One 𝓜(𝕜, A) 
goal: One 𝓜(𝕜, A)

full_name: DoubleCentralizer.instMul
code: instance instMul : Mul 𝓜(𝕜, A) 
goal: Mul 𝓜(𝕜, A)

full_name: DoubleCentralizer.instNatCast
code: instance instNatCast : NatCast 𝓜(𝕜, A) 
goal: NatCast 𝓜(𝕜, A)

full_name: DoubleCentralizer.instIntCast
code: instance instIntCast : IntCast 𝓜(𝕜, A) 
goal: IntCast 𝓜(𝕜, A)

full_name: DoubleCentralizer.instPow
code: instance instPow : Pow 𝓜(𝕜, A) ℕ 
goal: Pow 𝓜(𝕜, A) ℕ

full_name: DoubleCentralizer.instInhabited
code: instance instInhabited : Inhabited 𝓜(𝕜, A) 
goal: Inhabited 𝓜(𝕜, A)

full_name: DoubleCentralizer.add_toProd
code: @[simp]
theorem add_toProd (a b : 𝓜(𝕜, A)) : (a + b).toProd = a.toProd + b.toProd 
goal: (a + b).toProd = a.toProd + b.toProd

full_name: DoubleCentralizer.zero_toProd
code: @[simp]
theorem zero_toProd : (0 : 𝓜(𝕜, A)).toProd = 0 
goal: DoubleCentralizer.toProd 0 = 0

full_name: DoubleCentralizer.neg_toProd
code: @[simp]
theorem neg_toProd (a : 𝓜(𝕜, A)) : (-a).toProd = -a.toProd 
goal: (-a).toProd = -a.toProd

full_name: DoubleCentralizer.sub_toProd
code: @[simp]
theorem sub_toProd (a b : 𝓜(𝕜, A)) : (a - b).toProd = a.toProd - b.toProd 
goal: (a - b).toProd = a.toProd - b.toProd

full_name: DoubleCentralizer.one_toProd
code: @[simp]
theorem one_toProd : (1 : 𝓜(𝕜, A)).toProd = 1 
goal: DoubleCentralizer.toProd 1 = 1

full_name: DoubleCentralizer.natCast_toProd
code: @[simp]
theorem natCast_toProd (n : ℕ) : (n : 𝓜(𝕜, A)).toProd = n 
goal: (↑n).toProd = ↑n

full_name: DoubleCentralizer.intCast_toProd
code: @[simp]
theorem intCast_toProd (n : ℤ) : (n : 𝓜(𝕜, A)).toProd = n 
goal: (↑n).toProd = ↑n

full_name: DoubleCentralizer.pow_toProd
code: @[simp]
theorem pow_toProd (n : ℕ) (a : 𝓜(𝕜, A)) : (a ^ n).toProd = a.toProd ^ n 
goal: (a ^ n).toProd = a.toProd ^ n

full_name: DoubleCentralizer.add_fst
code: theorem add_fst (a b : 𝓜(𝕜, A)) : (a + b).fst = a.fst + b.fst 
goal: (a + b).toProd.1 = a.toProd.1 + b.toProd.1

full_name: DoubleCentralizer.add_snd
code: theorem add_snd (a b : 𝓜(𝕜, A)) : (a + b).snd = a.snd + b.snd 
goal: (a + b).toProd.2 = a.toProd.2 + b.toProd.2

full_name: DoubleCentralizer.zero_fst
code: theorem zero_fst : (0 : 𝓜(𝕜, A)).fst = 0 
goal: (DoubleCentralizer.toProd 0).1 = 0

full_name: DoubleCentralizer.zero_snd
code: theorem zero_snd : (0 : 𝓜(𝕜, A)).snd = 0 
goal: (DoubleCentralizer.toProd 0).2 = 0

full_name: DoubleCentralizer.neg_fst
code: theorem neg_fst (a : 𝓜(𝕜, A)) : (-a).fst = -a.fst 
goal: (-a).toProd.1 = -a.toProd.1

full_name: DoubleCentralizer.neg_snd
code: theorem neg_snd (a : 𝓜(𝕜, A)) : (-a).snd = -a.snd 
goal: (-a).toProd.2 = -a.toProd.2

full_name: DoubleCentralizer.sub_fst
code: theorem sub_fst (a b : 𝓜(𝕜, A)) : (a - b).fst = a.fst - b.fst 
goal: (a - b).toProd.1 = a.toProd.1 - b.toProd.1

full_name: DoubleCentralizer.sub_snd
code: theorem sub_snd (a b : 𝓜(𝕜, A)) : (a - b).snd = a.snd - b.snd 
goal: (a - b).toProd.2 = a.toProd.2 - b.toProd.2

full_name: DoubleCentralizer.one_fst
code: theorem one_fst : (1 : 𝓜(𝕜, A)).fst = 1 
goal: (DoubleCentralizer.toProd 1).1 = 1

full_name: DoubleCentralizer.one_snd
code: theorem one_snd : (1 : 𝓜(𝕜, A)).snd = 1 
goal: (DoubleCentralizer.toProd 1).2 = 1

full_name: DoubleCentralizer.mul_fst
code: @[simp]
theorem mul_fst (a b : 𝓜(𝕜, A)) : (a * b).fst = a.fst * b.fst 
goal: (a * b).toProd.1 = a.toProd.1 * b.toProd.1

full_name: DoubleCentralizer.mul_snd
code: @[simp]
theorem mul_snd (a b : 𝓜(𝕜, A)) : (a * b).snd = b.snd * a.snd 
goal: (a * b).toProd.2 = b.toProd.2 * a.toProd.2

full_name: DoubleCentralizer.natCast_fst
code: theorem natCast_fst (n : ℕ) : (n : 𝓜(𝕜, A)).fst = n 
goal: (↑n).toProd.1 = ↑n

full_name: DoubleCentralizer.natCast_snd
code: theorem natCast_snd (n : ℕ) : (n : 𝓜(𝕜, A)).snd = n 
goal: (↑n).toProd.2 = ↑n

full_name: DoubleCentralizer.intCast_fst
code: theorem intCast_fst (n : ℤ) : (n : 𝓜(𝕜, A)).fst = n 
goal: (↑n).toProd.1 = ↑n

full_name: DoubleCentralizer.intCast_snd
code: theorem intCast_snd (n : ℤ) : (n : 𝓜(𝕜, A)).snd = n 
goal: (↑n).toProd.2 = ↑n

full_name: DoubleCentralizer.pow_fst
code: theorem pow_fst (n : ℕ) (a : 𝓜(𝕜, A)) : (a ^ n).fst = a.fst ^ n 
goal: (a ^ n).toProd.1 = a.toProd.1 ^ n

full_name: DoubleCentralizer.pow_snd
code: theorem pow_snd (n : ℕ) (a : 𝓜(𝕜, A)) : (a ^ n).snd = a.snd ^ n 
goal: (a ^ n).toProd.2 = a.toProd.2 ^ n

full_name: DoubleCentralizer.toProdMulOpposite
code: /-- The natural injection from `DoubleCentralizer.toProd` except the second coordinate inherits
`MulOpposite.op`. The ring structure on `𝓜(𝕜, A)` is the pullback under this map. -/
def toProdMulOpposite : 𝓜(𝕜, A) → (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ 
goal: 𝓜(𝕜, A) → (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ

full_name: DoubleCentralizer.toProdMulOpposite_injective
code: theorem toProdMulOpposite_injective :
    Function.Injective (toProdMulOpposite : 𝓜(𝕜, A) → (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ) 
goal: Function.Injective DoubleCentralizer.toProdMulOpposite

full_name: DoubleCentralizer.range_toProdMulOpposite
code: theorem range_toProdMulOpposite :
    Set.range toProdMulOpposite =
      { lr : (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ | ∀ x y, unop lr.2 x * y = x * lr.1 y } 
goal: Set.range DoubleCentralizer.toProdMulOpposite = {lr | ∀ (x y : A), (MulOpposite.unop lr.2) x * y = x * lr.1 y}

full_name: DoubleCentralizer.instRing
code: /-- The ring structure is inherited as the pullback under the injective map
`DoubleCentralizer.toProdMulOpposite : 𝓜(𝕜, A) → (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ` -/
instance instRing : Ring 𝓜(𝕜, A) 
goal: Ring 𝓜(𝕜, A)

full_name: DoubleCentralizer.toProdHom
code: /-- The canonical map `DoubleCentralizer.toProd` as an additive group homomorphism. -/
@[simps]
def toProdHom : 𝓜(𝕜, A) →+ (A →L[𝕜] A) × (A →L[𝕜] A) 
goal: 𝓜(𝕜, A) →+ (A →L[𝕜] A) × (A →L[𝕜] A)

full_name: DoubleCentralizer.toProdHom_apply
code: /-- The canonical map `DoubleCentralizer.toProd` as an additive group homomorphism. -/
@[simps]
def toProdHom : 𝓜(𝕜, A) →+ (A →L[𝕜] A) × (A →L[𝕜] A) 
goal: DoubleCentralizer.toProdHom self = self.toProd

full_name: DoubleCentralizer.toProdMulOppositeHom
code: /-- The canonical map `DoubleCentralizer.toProdMulOpposite` as a ring homomorphism. -/
@[simps]
def toProdMulOppositeHom : 𝓜(𝕜, A) →+* (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ 
goal: 𝓜(𝕜, A) →+* (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ

full_name: DoubleCentralizer.toProdMulOppositeHom_apply
code: /-- The canonical map `DoubleCentralizer.toProdMulOpposite` as a ring homomorphism. -/
@[simps]
def toProdMulOppositeHom : 𝓜(𝕜, A) →+* (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ 
goal: ∀ (a : 𝓜(𝕜, A)), DoubleCentralizer.toProdMulOppositeHom a = a.toProdMulOpposite

full_name: DoubleCentralizer.instModule
code: /-- The module structure is inherited as the pullback under the additive group monomorphism
`DoubleCentralizer.toProd : 𝓜(𝕜, A) →+ (A →L[𝕜] A) × (A →L[𝕜] A)` -/
instance instModule {S : Type*} [Semiring S] [Module S A] [SMulCommClass 𝕜 S A]
    [ContinuousConstSMul S A] [IsScalarTower S A A] [SMulCommClass S A A] : Module S 𝓜(𝕜, A) 
goal: Module S 𝓜(𝕜, A)

full_name: DoubleCentralizer.instAlgebra
code: instance instAlgebra : Algebra 𝕜 𝓜(𝕜, A) 
goal: Algebra 𝕜 𝓜(𝕜, A)

full_name: DoubleCentralizer.algebraMap_toProd
code: @[simp]
theorem algebraMap_toProd (k : 𝕜) : (algebraMap 𝕜 𝓜(𝕜, A) k).toProd = algebraMap 𝕜 _ k 
goal: ((algebraMap 𝕜 𝓜(𝕜, A)) k).toProd = (algebraMap 𝕜 ((A →L[𝕜] A) × (A →L[𝕜] A))) k

full_name: DoubleCentralizer.algebraMap_fst
code: theorem algebraMap_fst (k : 𝕜) : (algebraMap 𝕜 𝓜(𝕜, A) k).fst = algebraMap 𝕜 _ k 
goal: ((algebraMap 𝕜 𝓜(𝕜, A)) k).toProd.1 = (algebraMap 𝕜 (A →L[𝕜] A)) k

full_name: DoubleCentralizer.algebraMap_snd
code: theorem algebraMap_snd (k : 𝕜) : (algebraMap 𝕜 𝓜(𝕜, A) k).snd = algebraMap 𝕜 _ k 
goal: ((algebraMap 𝕜 𝓜(𝕜, A)) k).toProd.2 = (algebraMap 𝕜 (A →L[𝕜] A)) k

full_name: DoubleCentralizer.instStar
code: /-- The star operation on `a : 𝓜(𝕜, A)` is given by
`(star a).toProd = (star ∘ a.snd ∘ star, star ∘ a.fst ∘ star)`. -/
instance instStar : Star 𝓜(𝕜, A) 
goal: Star 𝓜(𝕜, A)

full_name: DoubleCentralizer.star_fst
code: @[simp]
theorem star_fst (a : 𝓜(𝕜, A)) (b : A) : (star a).fst b = star (a.snd (star b)) 
goal: (star a).toProd.1 b = star (a.toProd.2 (star b))

full_name: DoubleCentralizer.star_snd
code: @[simp]
theorem star_snd (a : 𝓜(𝕜, A)) (b : A) : (star a).snd b = star (a.fst (star b)) 
goal: (star a).toProd.2 b = star (a.toProd.1 (star b))

full_name: DoubleCentralizer.instStarAddMonoid
code: instance instStarAddMonoid : StarAddMonoid 𝓜(𝕜, A) 
goal: StarAddMonoid 𝓜(𝕜, A)

full_name: DoubleCentralizer.instStarRing
code: instance instStarRing : StarRing 𝓜(𝕜, A) 
goal: StarRing 𝓜(𝕜, A)

full_name: DoubleCentralizer.instStarModule
code: instance instStarModule : StarModule 𝕜 𝓜(𝕜, A) 
goal: StarModule 𝕜 𝓜(𝕜, A)

full_name: DoubleCentralizer.coe
code: /-- The natural coercion of `A` into `𝓜(𝕜, A)` given by sending `a : A` to the pair of linear
maps `Lₐ Rₐ : A →L[𝕜] A` given by left- and right-multiplication by `a`, respectively.

Warning: if `A = 𝕜`, then this is a coercion which is not definitionally equal to the
`algebraMap 𝕜 𝓜(𝕜, 𝕜)` coercion, but these are propositionally equal. See
`DoubleCentralizer.coe_eq_algebraMap` below. -/
-- Porting note: added `noncomputable`; IR check does not recognise `ContinuousLinearMap.mul`
@[coe]
protected noncomputable def coe (a : A) : 𝓜(𝕜, A) 
goal: 𝓜(𝕜, A)

full_name: DoubleCentralizer.instCoeTC
code: /-- The natural coercion of `A` into `𝓜(𝕜, A)` given by sending `a : A` to the pair of linear
maps `Lₐ Rₐ : A →L[𝕜] A` given by left- and right-multiplication by `a`, respectively.

Warning: if `A = 𝕜`, then this is a coercion which is not definitionally equal to the
`algebraMap 𝕜 𝓜(𝕜, 𝕜)` coercion, but these are propositionally equal. See
`DoubleCentralizer.coe_eq_algebraMap` below. -/
noncomputable instance : CoeTC A 𝓜(𝕜, A) 
goal: CoeTC A 𝓜(𝕜, A)

full_name: DoubleCentralizer.coe_fst
code: @[simp, norm_cast]
theorem coe_fst (a : A) : (a : 𝓜(𝕜, A)).fst = ContinuousLinearMap.mul 𝕜 A a 
goal: (↑𝕜 a).toProd.1 = (ContinuousLinearMap.mul 𝕜 A) a

full_name: DoubleCentralizer.coe_snd
code: @[simp, norm_cast]
theorem coe_snd (a : A) : (a : 𝓜(𝕜, A)).snd = (ContinuousLinearMap.mul 𝕜 A).flip a 
goal: (↑𝕜 a).toProd.2 = (ContinuousLinearMap.mul 𝕜 A).flip a

full_name: DoubleCentralizer.coe_eq_algebraMap
code: theorem coe_eq_algebraMap : (DoubleCentralizer.coe 𝕜 : 𝕜 → 𝓜(𝕜, 𝕜)) = algebraMap 𝕜 𝓜(𝕜, 𝕜) 
goal: ↑𝕜 = ⇑(algebraMap 𝕜 𝓜(𝕜, 𝕜))

full_name: DoubleCentralizer.coeHom_apply
code: /-- The coercion of an algebra into its multiplier algebra as a non-unital star algebra
homomorphism. -/
@[simps]
noncomputable def coeHom [StarRing 𝕜] [StarRing A] [StarModule 𝕜 A] [NormedStarGroup A] :
    A →⋆ₙₐ[𝕜] 𝓜(𝕜, A) 
goal: DoubleCentralizer.coeHom a = ↑𝕜 a

full_name: DoubleCentralizer.coeHom
code: /-- The coercion of an algebra into its multiplier algebra as a non-unital star algebra
homomorphism. -/
@[simps]
noncomputable def coeHom [StarRing 𝕜] [StarRing A] [StarModule 𝕜 A] [NormedStarGroup A] :
    A →⋆ₙₐ[𝕜] 𝓜(𝕜, A) 
goal: A →⋆ₙₐ[𝕜] 𝓜(𝕜, A)

full_name: DoubleCentralizer.instNormedRing
code: /-- The normed group structure is inherited as the pullback under the ring monomorphism
`DoubleCentralizer.toProdMulOppositeHom : 𝓜(𝕜, A) →+* (A →L[𝕜] A) × (A →L[𝕜] A)ᵐᵒᵖ`. -/
noncomputable instance : NormedRing 𝓜(𝕜, A) 
goal: NormedRing 𝓜(𝕜, A)

full_name: DoubleCentralizer.norm_def
code: theorem norm_def (a : 𝓜(𝕜, A)) : ‖a‖ = ‖toProdHom a‖ 
goal: ‖a‖ = ‖DoubleCentralizer.toProdHom a‖

full_name: DoubleCentralizer.nnnorm_def
code: theorem nnnorm_def (a : 𝓜(𝕜, A)) : ‖a‖₊ = ‖toProdHom a‖₊ 
goal: ‖a‖₊ = ‖DoubleCentralizer.toProdHom a‖₊

full_name: DoubleCentralizer.norm_def'
code: theorem norm_def' (a : 𝓜(𝕜, A)) : ‖a‖ = ‖toProdMulOppositeHom a‖ 
goal: ‖a‖ = ‖DoubleCentralizer.toProdMulOppositeHom a‖

full_name: DoubleCentralizer.nnnorm_def'
code: theorem nnnorm_def' (a : 𝓜(𝕜, A)) : ‖a‖₊ = ‖toProdMulOppositeHom a‖₊ 
goal: ‖a‖₊ = ‖DoubleCentralizer.toProdMulOppositeHom a‖₊

full_name: DoubleCentralizer.instNormedSpace
code: instance instNormedSpace : NormedSpace 𝕜 𝓜(𝕜, A) 
goal: NormedSpace 𝕜 𝓜(𝕜, A)

full_name: DoubleCentralizer.instNormedAlgebra
code: instance instNormedAlgebra : NormedAlgebra 𝕜 𝓜(𝕜, A) 
goal: NormedAlgebra 𝕜 𝓜(𝕜, A)

full_name: DoubleCentralizer.uniformEmbedding_toProdMulOpposite
code: theorem uniformEmbedding_toProdMulOpposite : UniformEmbedding (@toProdMulOpposite 𝕜 A _ _ _ _ _) 
goal: UniformEmbedding DoubleCentralizer.toProdMulOpposite

full_name: DoubleCentralizer.instCompleteSpace
code: instance [CompleteSpace A] : CompleteSpace 𝓜(𝕜, A) 
goal: CompleteSpace 𝓜(𝕜, A)

full_name: DoubleCentralizer.norm_fst_eq_snd
code: /-- For `a : 𝓜(𝕜, A)`, the norms of `a.fst` and `a.snd` coincide, and hence these
also coincide with `‖a‖` which is `max (‖a.fst‖) (‖a.snd‖)`. -/
theorem norm_fst_eq_snd (a : 𝓜(𝕜, A)) : ‖a.fst‖ = ‖a.snd‖ 
goal: ‖a.toProd.1‖ = ‖a.toProd.2‖

full_name: DoubleCentralizer.nnnorm_fst_eq_snd
code: theorem nnnorm_fst_eq_snd (a : 𝓜(𝕜, A)) : ‖a.fst‖₊ = ‖a.snd‖₊ 
goal: ‖a.toProd.1‖₊ = ‖a.toProd.2‖₊

full_name: DoubleCentralizer.norm_fst
code: @[simp]
theorem norm_fst (a : 𝓜(𝕜, A)) : ‖a.fst‖ = ‖a‖ 
goal: ‖a.toProd.1‖ = ‖a‖

full_name: DoubleCentralizer.norm_snd
code: @[simp]
theorem norm_snd (a : 𝓜(𝕜, A)) : ‖a.snd‖ = ‖a‖ 
goal: ‖a.toProd.2‖ = ‖a‖

full_name: DoubleCentralizer.nnnorm_fst
code: @[simp]
theorem nnnorm_fst (a : 𝓜(𝕜, A)) : ‖a.fst‖₊ = ‖a‖₊ 
goal: ‖a.toProd.1‖₊ = ‖a‖₊

full_name: DoubleCentralizer.nnnorm_snd
code: @[simp]
theorem nnnorm_snd (a : 𝓜(𝕜, A)) : ‖a.snd‖₊ = ‖a‖₊ 
goal: ‖a.toProd.2‖₊ = ‖a‖₊

full_name: DoubleCentralizer.instCstarRing
code: instance instCstarRing : CstarRing 𝓜(𝕜, A) 
goal: CstarRing 𝓜(𝕜, A)