File: Mathlib/Analysis/CstarAlgebra/Basic.lean

full_name: _aux_Mathlib_Analysis_CstarAlgebra_Basic___unexpand_Star_star_1
code: local postfix:max "⋆" => star
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_CstarAlgebra_Basic___macroRules_term_⋆_1»
code: local postfix:max "⋆" => star
goal: Lean.Macro

full_name: NormedStarGroup.norm_star
code: /-- A normed star group is a normed group with a compatible `star` which is isometric. -/
class NormedStarGroup (E : Type*) [SeminormedAddCommGroup E] [StarAddMonoid E] : Prop where
  norm_star : ∀ x : E, ‖x⋆‖ = ‖x‖
goal: ‖x⋆‖ = ‖x‖

full_name: NormedStarGroup
code: /-- A normed star group is a normed group with a compatible `star` which is isometric. -/
class NormedStarGroup (E : Type*) [SeminormedAddCommGroup E] [StarAddMonoid E] : Prop where
  norm_star : ∀ x : E, ‖x⋆‖ = ‖x‖
goal: Prop

full_name: nnnorm_star
code: @[simp]
theorem nnnorm_star (x : E) : ‖star x‖₊ = ‖x‖₊ 
goal: ‖x⋆‖₊ = ‖x‖₊

full_name: starNormedAddGroupHom
code: /-- The `star` map in a normed star group is a normed group homomorphism. -/
def starNormedAddGroupHom : NormedAddGroupHom E E 
goal: NormedAddGroupHom E E

full_name: star_isometry
code: /-- The `star` map in a normed star group is an isometry -/
theorem star_isometry : Isometry (star : E → E) 
goal: Isometry star

full_name: NormedStarGroup.to_continuousStar
code: instance (priority := 100) NormedStarGroup.to_continuousStar : ContinuousStar E 
goal: ContinuousStar E

full_name: RingHomIsometric.starRingEnd
code: instance RingHomIsometric.starRingEnd [NormedCommRing E] [StarRing E] [NormedStarGroup E] :
    RingHomIsometric (starRingEnd E) 
goal: RingHomIsometric (starRingEnd E)

full_name: CstarRing
code: /-- A C*-ring is a normed star ring that satisfies the stronger condition `‖x‖ ^ 2 ≤ ‖x⋆ * x‖`
for every `x`. Note that this condition actually implies equality, as is shown in
`norm_star_mul_self` below. -/
class CstarRing (E : Type*) [NonUnitalNormedRing E] [StarRing E] : Prop where
  norm_mul_self_le : ∀ x : E, ‖x‖ * ‖x‖ ≤ ‖x⋆ * x‖
goal: Prop

full_name: CstarRing.norm_mul_self_le
code: /-- A C*-ring is a normed star ring that satisfies the stronger condition `‖x‖ ^ 2 ≤ ‖x⋆ * x‖`
for every `x`. Note that this condition actually implies equality, as is shown in
`norm_star_mul_self` below. -/
class CstarRing (E : Type*) [NonUnitalNormedRing E] [StarRing E] : Prop where
  norm_mul_self_le : ∀ x : E, ‖x‖ * ‖x‖ ≤ ‖x⋆ * x‖
goal: ‖x‖ * ‖x‖ ≤ ‖x⋆ * x‖

full_name: instCstarRingReal
code: instance : CstarRing ℝ 
goal: CstarRing ℝ

full_name: CstarRing.to_normedStarGroup
code: /-- In a C*-ring, star preserves the norm. -/
instance (priority := 100) to_normedStarGroup : NormedStarGroup E 
goal: NormedStarGroup E

full_name: CstarRing.norm_star_mul_self
code: theorem norm_star_mul_self {x : E} : ‖x⋆ * x‖ = ‖x‖ * ‖x‖ 
goal: ‖x⋆ * x‖ = ‖x‖ * ‖x‖

full_name: CstarRing.norm_self_mul_star
code: theorem norm_self_mul_star {x : E} : ‖x * x⋆‖ = ‖x‖ * ‖x‖ 
goal: ‖x * x⋆‖ = ‖x‖ * ‖x‖

full_name: CstarRing.norm_star_mul_self'
code: theorem norm_star_mul_self' {x : E} : ‖x⋆ * x‖ = ‖x⋆‖ * ‖x‖ 
goal: ‖x⋆ * x‖ = ‖x⋆‖ * ‖x‖

full_name: CstarRing.nnnorm_self_mul_star
code: theorem nnnorm_self_mul_star {x : E} : ‖x * x⋆‖₊ = ‖x‖₊ * ‖x‖₊ 
goal: ‖x * x⋆‖₊ = ‖x‖₊ * ‖x‖₊

full_name: CstarRing.nnnorm_star_mul_self
code: theorem nnnorm_star_mul_self {x : E} : ‖x⋆ * x‖₊ = ‖x‖₊ * ‖x‖₊ 
goal: ‖x⋆ * x‖₊ = ‖x‖₊ * ‖x‖₊

full_name: CstarRing.star_mul_self_eq_zero_iff
code: @[simp]
theorem star_mul_self_eq_zero_iff (x : E) : x⋆ * x = 0 ↔ x = 0 
goal: x⋆ * x = 0 ↔ x = 0

full_name: CstarRing.star_mul_self_ne_zero_iff
code: theorem star_mul_self_ne_zero_iff (x : E) : x⋆ * x ≠ 0 ↔ x ≠ 0 
goal: x⋆ * x ≠ 0 ↔ x ≠ 0

full_name: CstarRing.mul_star_self_eq_zero_iff
code: @[simp]
theorem mul_star_self_eq_zero_iff (x : E) : x * x⋆ = 0 ↔ x = 0 
goal: x * x⋆ = 0 ↔ x = 0

full_name: CstarRing.mul_star_self_ne_zero_iff
code: theorem mul_star_self_ne_zero_iff (x : E) : x * x⋆ ≠ 0 ↔ x ≠ 0 
goal: x * x⋆ ≠ 0 ↔ x ≠ 0

full_name: Pi.starRing'
code: /-- This instance exists to short circuit type class resolution because of problems with
inference involving Π-types. -/
instance _root_.Pi.starRing' : StarRing (∀ i, R i) 
goal: StarRing ((i : ι) → R i)

full_name: Prod.cstarRing
code: instance _root_.Prod.cstarRing : CstarRing (R₁ × R₂) 
goal: CstarRing (R₁ × R₂)

full_name: Pi.cstarRing
code: instance _root_.Pi.cstarRing : CstarRing (∀ i, R i) 
goal: CstarRing ((i : ι) → R i)

full_name: Pi.cstarRing'
code: instance _root_.Pi.cstarRing' : CstarRing (ι → R₁) 
goal: CstarRing (ι → R₁)

full_name: CstarRing.norm_one
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem norm_one [Nontrivial E] : ‖(1 : E)‖ = 1 
goal: ‖1‖ = 1

full_name: CstarRing.instNormOneClassOfNontrivial
code: instance (priority := 100) [Nontrivial E] : NormOneClass E 
goal: NormOneClass E

full_name: CstarRing.norm_coe_unitary
code: theorem norm_coe_unitary [Nontrivial E] (U : unitary E) : ‖(U : E)‖ = 1 
goal: ‖↑U‖ = 1

full_name: CstarRing.norm_of_mem_unitary
code: @[simp]
theorem norm_of_mem_unitary [Nontrivial E] {U : E} (hU : U ∈ unitary E) : ‖U‖ = 1 
goal: ‖U‖ = 1

full_name: CstarRing.norm_coe_unitary_mul
code: @[simp]
theorem norm_coe_unitary_mul (U : unitary E) (A : E) : ‖(U : E) * A‖ = ‖A‖ 
goal: ‖↑U * A‖ = ‖A‖

full_name: CstarRing.norm_unitary_smul
code: @[simp]
theorem norm_unitary_smul (U : unitary E) (A : E) : ‖U • A‖ = ‖A‖ 
goal: ‖U • A‖ = ‖A‖

full_name: CstarRing.norm_mem_unitary_mul
code: theorem norm_mem_unitary_mul {U : E} (A : E) (hU : U ∈ unitary E) : ‖U * A‖ = ‖A‖ 
goal: ‖U * A‖ = ‖A‖

full_name: CstarRing.norm_mul_coe_unitary
code: @[simp]
theorem norm_mul_coe_unitary (A : E) (U : unitary E) : ‖A * U‖ = ‖A‖ 
goal: ‖A * ↑U‖ = ‖A‖

full_name: CstarRing.norm_mul_mem_unitary
code: theorem norm_mul_mem_unitary (A : E) {U : E} (hU : U ∈ unitary E) : ‖A * U‖ = ‖A‖ 
goal: ‖A * U‖ = ‖A‖

full_name: IsSelfAdjoint.nnnorm_pow_two_pow
code: theorem IsSelfAdjoint.nnnorm_pow_two_pow [NormedRing E] [StarRing E] [CstarRing E] {x : E}
    (hx : IsSelfAdjoint x) (n : ℕ) : ‖x ^ 2 ^ n‖₊ = ‖x‖₊ ^ 2 ^ n 
goal: ‖x ^ 2 ^ n‖₊ = ‖x‖₊ ^ 2 ^ n

full_name: selfAdjoint.nnnorm_pow_two_pow
code: theorem selfAdjoint.nnnorm_pow_two_pow [NormedRing E] [StarRing E] [CstarRing E] (x : selfAdjoint E)
    (n : ℕ) : ‖x ^ 2 ^ n‖₊ = ‖x‖₊ ^ 2 ^ n 
goal: ‖x ^ 2 ^ n‖₊ = ‖x‖₊ ^ 2 ^ n

full_name: starₗᵢ
code: /-- `star` bundled as a linear isometric equivalence -/
def starₗᵢ : E ≃ₗᵢ⋆[𝕜] E 
goal: E ≃ₗᵢ⋆[𝕜] E

full_name: coe_starₗᵢ
code: @[simp]
theorem coe_starₗᵢ : (starₗᵢ 𝕜 : E → E) = star 
goal: ⇑(starₗᵢ 𝕜) = star

full_name: starₗᵢ_apply
code: theorem starₗᵢ_apply {x : E} : starₗᵢ 𝕜 x = star x 
goal: (starₗᵢ 𝕜) x = x⋆

full_name: starₗᵢ_toContinuousLinearEquiv
code: @[simp]
theorem starₗᵢ_toContinuousLinearEquiv :
    (starₗᵢ 𝕜 : E ≃ₗᵢ⋆[𝕜] E).toContinuousLinearEquiv = (starL 𝕜 : E ≃L⋆[𝕜] E) 
goal: (starₗᵢ 𝕜).toContinuousLinearEquiv = starL 𝕜

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

full_name: StarSubalgebra.to_cstarRing
code: instance to_cstarRing {R A} [CommRing R] [StarRing R] [NormedRing A] [StarRing A] [CstarRing A]
    [Algebra R A] [StarModule R A] (S : StarSubalgebra R A) : CstarRing S 
goal: CstarRing ↥S