File: Mathlib/Algebra/Star/Subalgebra.lean

full_name: StarSubalgebra.star_mem'
code: /-- A *-subalgebra is a subalgebra of a *-algebra which is closed under *. -/
structure StarSubalgebra (R : Type u) (A : Type v) [CommSemiring R] [StarRing R] [Semiring A]
  [StarRing A] [Algebra R A] [StarModule R A] extends Subalgebra R A : Type v where
  /-- The `carrier` is closed under the `star` operation. -/
  star_mem' {a} : a ∈ carrier → star a ∈ carrier
goal: a ∈ self.carrier → star a ∈ self.carrier

full_name: StarSubalgebra
code: /-- A *-subalgebra is a subalgebra of a *-algebra which is closed under *. -/
structure StarSubalgebra (R : Type u) (A : Type v) [CommSemiring R] [StarRing R] [Semiring A]
  [StarRing A] [Algebra R A] [StarModule R A] extends Subalgebra R A : Type v where
  /-- The `carrier` is closed under the `star` operation. -/
  star_mem' {a} : a ∈ carrier → star a ∈ carrier
goal: Type v

full_name: StarSubalgebra.setLike
code: instance setLike : SetLike (StarSubalgebra R A) A 
goal: SetLike (StarSubalgebra R A) A

full_name: StarSubalgebra.starMemClass
code: instance starMemClass : StarMemClass (StarSubalgebra R A) A 
goal: StarMemClass (StarSubalgebra R A) A

full_name: StarSubalgebra.subsemiringClass
code: instance subsemiringClass : SubsemiringClass (StarSubalgebra R A) A 
goal: SubsemiringClass (StarSubalgebra R A) A

full_name: StarSubalgebra.smulMemClass
code: instance smulMemClass : SMulMemClass (StarSubalgebra R A) R A 
goal: SMulMemClass (StarSubalgebra R A) R A

full_name: StarSubalgebra.subringClass
code: instance subringClass {R A} [CommRing R] [StarRing R] [Ring A] [StarRing A] [Algebra R A]
    [StarModule R A] : SubringClass (StarSubalgebra R A) A 
goal: SubringClass (StarSubalgebra R A) A

full_name: StarSubalgebra.starRing
code: instance starRing (s : StarSubalgebra R A) : StarRing s 
goal: StarRing ↥s

full_name: StarSubalgebra.algebra
code: instance algebra (s : StarSubalgebra R A) : Algebra R s 
goal: Algebra R ↥s

full_name: StarSubalgebra.starModule
code: instance starModule (s : StarSubalgebra R A) : StarModule R s 
goal: StarModule R ↥s

full_name: StarSubalgebra.mem_carrier
code: @[simp, nolint simpNF] -- porting note (#10618): `simpNF` says `simp` can prove this, but it can't
theorem mem_carrier {s : StarSubalgebra R A} {x : A} : x ∈ s.carrier ↔ x ∈ s 
goal: x ∈ s.carrier ↔ x ∈ s

full_name: StarSubalgebra.ext
code: @[ext]
theorem ext {S T : StarSubalgebra R A} (h : ∀ x : A, x ∈ S ↔ x ∈ T) : S = T 
goal: S = T

full_name: StarSubalgebra.coe_mk
code: @[simp]
lemma coe_mk (S : Subalgebra R A) (h) : ((⟨S, h⟩ : StarSubalgebra R A) : Set A) = S 
goal: ↑{ toSubalgebra := S, star_mem' := h } = ↑S

full_name: StarSubalgebra.mem_toSubalgebra
code: @[simp]
theorem mem_toSubalgebra {S : StarSubalgebra R A} {x} : x ∈ S.toSubalgebra ↔ x ∈ S 
goal: x ∈ S.toSubalgebra ↔ x ∈ S

full_name: StarSubalgebra.coe_toSubalgebra
code: @[simp]
theorem coe_toSubalgebra (S : StarSubalgebra R A) : (S.toSubalgebra : Set A) = S 
goal: ↑S.toSubalgebra = ↑S

full_name: StarSubalgebra.toSubalgebra_injective
code: theorem toSubalgebra_injective :
    Function.Injective (toSubalgebra : StarSubalgebra R A → Subalgebra R A) 
goal: Function.Injective StarSubalgebra.toSubalgebra

full_name: StarSubalgebra.toSubalgebra_inj
code: theorem toSubalgebra_inj {S U : StarSubalgebra R A} : S.toSubalgebra = U.toSubalgebra ↔ S = U 
goal: S.toSubalgebra = U.toSubalgebra ↔ S = U

full_name: StarSubalgebra.toSubalgebra_le_iff
code: theorem toSubalgebra_le_iff {S₁ S₂ : StarSubalgebra R A} :
    S₁.toSubalgebra ≤ S₂.toSubalgebra ↔ S₁ ≤ S₂ 
goal: S₁.toSubalgebra ≤ S₂.toSubalgebra ↔ S₁ ≤ S₂

full_name: StarSubalgebra.copy
code: /-- Copy of a star subalgebra with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (S : StarSubalgebra R A) (s : Set A) (hs : s = ↑S) : StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: StarSubalgebra.coe_copy
code: @[simp]
theorem coe_copy (S : StarSubalgebra R A) (s : Set A) (hs : s = ↑S) : (S.copy s hs : Set A) = s 
goal: ↑(S.copy s hs) = s

full_name: StarSubalgebra.copy_eq
code: theorem copy_eq (S : StarSubalgebra R A) (s : Set A) (hs : s = ↑S) : S.copy s hs = S 
goal: S.copy s hs = S

full_name: StarSubalgebra.algebraMap_mem
code: theorem algebraMap_mem (r : R) : algebraMap R A r ∈ S 
goal: (algebraMap R A) r ∈ S

full_name: StarSubalgebra.rangeS_le
code: theorem rangeS_le : (algebraMap R A).rangeS ≤ S.toSubalgebra.toSubsemiring 
goal: (algebraMap R A).rangeS ≤ S.toSubsemiring

full_name: StarSubalgebra.range_subset
code: theorem range_subset : Set.range (algebraMap R A) ⊆ S 
goal: Set.range ⇑(algebraMap R A) ⊆ ↑S

full_name: StarSubalgebra.range_le
code: theorem range_le : Set.range (algebraMap R A) ≤ S 
goal: Set.range ⇑(algebraMap R A) ≤ ↑S

full_name: StarSubalgebra.smul_mem
code: protected theorem smul_mem {x : A} (hx : x ∈ S) (r : R) : r • x ∈ S 
goal: r • x ∈ S

full_name: StarSubalgebra.subtype
code: /-- Embedding of a subalgebra into the algebra. -/
def subtype : S →⋆ₐ[R] A 
goal: ↥S →⋆ₐ[R] A

full_name: StarSubalgebra.coe_subtype
code: @[simp]
theorem coe_subtype : (S.subtype : S → A) = Subtype.val 
goal: ⇑S.subtype = Subtype.val

full_name: StarSubalgebra.subtype_apply
code: theorem subtype_apply (x : S) : S.subtype x = (x : A) 
goal: S.subtype x = ↑x

full_name: StarSubalgebra.toSubalgebra_subtype
code: @[simp]
theorem toSubalgebra_subtype : S.toSubalgebra.val = S.subtype.toAlgHom 
goal: S.val = S.subtype.toAlgHom

full_name: StarSubalgebra.inclusion
code: /-- The inclusion map between `StarSubalgebra`s given by `Subtype.map id` as a `StarAlgHom`. -/
@[simps]
def inclusion {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) : S₁ →⋆ₐ[R] S₂ 
goal: ↥S₁ →⋆ₐ[R] ↥S₂

full_name: StarSubalgebra.inclusion_apply
code: /-- The inclusion map between `StarSubalgebra`s given by `Subtype.map id` as a `StarAlgHom`. -/
@[simps]
def inclusion {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) : S₁ →⋆ₐ[R] S₂ 
goal: ∀ (a : ↥S₁), (StarSubalgebra.inclusion h) a = Subtype.map id h a

full_name: StarSubalgebra.inclusion_injective
code: theorem inclusion_injective {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) :
    Function.Injective <| inclusion h 
goal: Function.Injective ⇑(StarSubalgebra.inclusion h)

full_name: StarSubalgebra.subtype_comp_inclusion
code: @[simp]
theorem subtype_comp_inclusion {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) :
    S₂.subtype.comp (inclusion h) = S₁.subtype 
goal: S₂.subtype.comp (StarSubalgebra.inclusion h) = S₁.subtype

full_name: StarSubalgebra.map
code: /-- Transport a star subalgebra via a star algebra homomorphism. -/
def map (f : A →⋆ₐ[R] B) (S : StarSubalgebra R A) : StarSubalgebra R B 
goal: StarSubalgebra R B

full_name: StarSubalgebra.map_mono
code: theorem map_mono {S₁ S₂ : StarSubalgebra R A} {f : A →⋆ₐ[R] B} : S₁ ≤ S₂ → S₁.map f ≤ S₂.map f 
goal: S₁ ≤ S₂ → StarSubalgebra.map f S₁ ≤ StarSubalgebra.map f S₂

full_name: StarSubalgebra.map_injective
code: theorem map_injective {f : A →⋆ₐ[R] B} (hf : Function.Injective f) : Function.Injective (map f) 
goal: Function.Injective (StarSubalgebra.map f)

full_name: StarSubalgebra.map_id
code: @[simp]
theorem map_id (S : StarSubalgebra R A) : S.map (StarAlgHom.id R A) = S 
goal: StarSubalgebra.map (StarAlgHom.id R A) S = S

full_name: StarSubalgebra.map_map
code: theorem map_map (S : StarSubalgebra R A) (g : B →⋆ₐ[R] C) (f : A →⋆ₐ[R] B) :
    (S.map f).map g = S.map (g.comp f) 
goal: StarSubalgebra.map g (StarSubalgebra.map f S) = StarSubalgebra.map (g.comp f) S

full_name: StarSubalgebra.mem_map
code: @[simp]
theorem mem_map {S : StarSubalgebra R A} {f : A →⋆ₐ[R] B} {y : B} :
    y ∈ map f S ↔ ∃ x ∈ S, f x = y 
goal: y ∈ StarSubalgebra.map f S ↔ ∃ x ∈ S, f x = y

full_name: StarSubalgebra.map_toSubalgebra
code: theorem map_toSubalgebra {S : StarSubalgebra R A} {f : A →⋆ₐ[R] B} :
    (S.map f).toSubalgebra = S.toSubalgebra.map f.toAlgHom 
goal: (StarSubalgebra.map f S).toSubalgebra = Subalgebra.map f.toAlgHom S.toSubalgebra

full_name: StarSubalgebra.coe_map
code: @[simp]
theorem coe_map (S : StarSubalgebra R A) (f : A →⋆ₐ[R] B) : (S.map f : Set B) = f '' S 
goal: ↑(StarSubalgebra.map f S) = ⇑f '' ↑S

full_name: StarSubalgebra.comap
code: /-- Preimage of a star subalgebra under a star algebra homomorphism. -/
def comap (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B) : StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: StarSubalgebra.map_le_iff_le_comap
code: theorem map_le_iff_le_comap {S : StarSubalgebra R A} {f : A →⋆ₐ[R] B} {U : StarSubalgebra R B} :
    map f S ≤ U ↔ S ≤ comap f U 
goal: StarSubalgebra.map f S ≤ U ↔ S ≤ StarSubalgebra.comap f U

full_name: StarSubalgebra.gc_map_comap
code: theorem gc_map_comap (f : A →⋆ₐ[R] B) : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (StarSubalgebra.map f) (StarSubalgebra.comap f)

full_name: StarSubalgebra.comap_mono
code: theorem comap_mono {S₁ S₂ : StarSubalgebra R B} {f : A →⋆ₐ[R] B} :
    S₁ ≤ S₂ → S₁.comap f ≤ S₂.comap f 
goal: S₁ ≤ S₂ → StarSubalgebra.comap f S₁ ≤ StarSubalgebra.comap f S₂

full_name: StarSubalgebra.comap_injective
code: theorem comap_injective {f : A →⋆ₐ[R] B} (hf : Function.Surjective f) :
    Function.Injective (comap f) 
goal: Function.Injective (StarSubalgebra.comap f)

full_name: StarSubalgebra.comap_id
code: @[simp]
theorem comap_id (S : StarSubalgebra R A) : S.comap (StarAlgHom.id R A) = S 
goal: StarSubalgebra.comap (StarAlgHom.id R A) S = S

full_name: StarSubalgebra.comap_comap
code: theorem comap_comap (S : StarSubalgebra R C) (g : B →⋆ₐ[R] C) (f : A →⋆ₐ[R] B) :
    (S.comap g).comap f = S.comap (g.comp f) 
goal: StarSubalgebra.comap f (StarSubalgebra.comap g S) = StarSubalgebra.comap (g.comp f) S

full_name: StarSubalgebra.mem_comap
code: @[simp]
theorem mem_comap (S : StarSubalgebra R B) (f : A →⋆ₐ[R] B) (x : A) : x ∈ S.comap f ↔ f x ∈ S 
goal: x ∈ StarSubalgebra.comap f S ↔ f x ∈ S

full_name: StarSubalgebra.coe_comap
code: @[simp, norm_cast]
theorem coe_comap (S : StarSubalgebra R B) (f : A →⋆ₐ[R] B) :
    (S.comap f : Set A) = f ⁻¹' (S : Set B) 
goal: ↑(StarSubalgebra.comap f S) = ⇑f ⁻¹' ↑S

full_name: StarSubalgebra.centralizer
code: /-- The centralizer, or commutant, of the star-closure of a set as a star subalgebra. -/
def centralizer (s : Set A) : StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: StarSubalgebra.coe_centralizer
code: @[simp, norm_cast]
theorem coe_centralizer (s : Set A) : (centralizer R s : Set A) = (s ∪ star s).centralizer 
goal: ↑(StarSubalgebra.centralizer R s) = (s ∪ star s).centralizer

full_name: StarSubalgebra.mem_centralizer_iff
code: theorem mem_centralizer_iff {s : Set A} {z : A} :
    z ∈ centralizer R s ↔ ∀ g ∈ s, g * z = z * g ∧ star g * z = z * star g 
goal: z ∈ StarSubalgebra.centralizer R s ↔ ∀ g ∈ s, g * z = z * g ∧ star g * z = z * star g

full_name: StarSubalgebra.centralizer_le
code: theorem centralizer_le (s t : Set A) (h : s ⊆ t) : centralizer R t ≤ centralizer R s 
goal: StarSubalgebra.centralizer R t ≤ StarSubalgebra.centralizer R s

full_name: Subalgebra.involutiveStar
code: /-- The pointwise `star` of a subalgebra is a subalgebra. -/
instance involutiveStar : InvolutiveStar (Subalgebra R A) 
goal: InvolutiveStar (Subalgebra R A)

full_name: Subalgebra.mem_star_iff
code: @[simp]
theorem mem_star_iff (S : Subalgebra R A) (x : A) : x ∈ star S ↔ star x ∈ S 
goal: x ∈ star S ↔ star x ∈ S

full_name: Subalgebra.star_mem_star_iff
code: theorem star_mem_star_iff (S : Subalgebra R A) (x : A) : star x ∈ star S ↔ x ∈ S 
goal: star x ∈ star S ↔ x ∈ S

full_name: Subalgebra.coe_star
code: @[simp]
theorem coe_star (S : Subalgebra R A) : ((star S : Subalgebra R A) : Set A) = star (S : Set A) 
goal: ↑(star S) = star ↑S

full_name: Subalgebra.star_mono
code: theorem star_mono : Monotone (star : Subalgebra R A → Subalgebra R A) 
goal: Monotone star

full_name: Subalgebra.star_adjoin_comm
code: /-- The star operation on `Subalgebra` commutes with `Algebra.adjoin`. -/
theorem star_adjoin_comm (s : Set A) : star (Algebra.adjoin R s) = Algebra.adjoin R (star s) 
goal: star (Algebra.adjoin R s) = Algebra.adjoin R (star s)

full_name: Subalgebra.starClosure
code: /-- The `StarSubalgebra` obtained from `S : Subalgebra R A` by taking the smallest subalgebra
containing both `S` and `star S`. -/
@[simps!]
def starClosure (S : Subalgebra R A) : StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: Subalgebra.starClosure_carrier
code: /-- The `StarSubalgebra` obtained from `S : Subalgebra R A` by taking the smallest subalgebra
containing both `S` and `star S`. -/
@[simps!]
def starClosure (S : Subalgebra R A) : StarSubalgebra R A 
goal: ↑S.starClosure = ⋂ t, ⋂ (_ : Set.range ⇑(algebraMap R A) ⊆ ↑t ∧ ↑S ⊆ ↑t ∧ star ↑S ⊆ ↑t), ↑t

full_name: Subalgebra.starClosure_toSubalgebra
code: theorem starClosure_toSubalgebra (S : Subalgebra R A) : S.starClosure.toSubalgebra = S ⊔ star S 
goal: S.starClosure.toSubalgebra = S ⊔ star S

full_name: Subalgebra.starClosure_le
code: theorem starClosure_le {S₁ : Subalgebra R A} {S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂.toSubalgebra) :
    S₁.starClosure ≤ S₂ 
goal: S₁.starClosure ≤ S₂

full_name: Subalgebra.starClosure_le_iff
code: theorem starClosure_le_iff {S₁ : Subalgebra R A} {S₂ : StarSubalgebra R A} :
    S₁.starClosure ≤ S₂ ↔ S₁ ≤ S₂.toSubalgebra 
goal: S₁.starClosure ≤ S₂ ↔ S₁ ≤ S₂.toSubalgebra

full_name: StarAlgebra.adjoin
code: /-- The minimal star subalgebra that contains `s`. -/
@[simps!]
def adjoin (s : Set A) : StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: StarAlgebra.adjoin_carrier
code: /-- The minimal star subalgebra that contains `s`. -/
@[simps!]
def adjoin (s : Set A) : StarSubalgebra R A 
goal: ↑(StarAlgebra.adjoin R s) = ⋂ t, ⋂ (_ : Set.range ⇑(algebraMap R A) ⊆ ↑t ∧ s ⊆ ↑t ∧ star s ⊆ ↑t), ↑t

full_name: StarAlgebra.adjoin_eq_starClosure_adjoin
code: theorem adjoin_eq_starClosure_adjoin (s : Set A) : adjoin R s = (Algebra.adjoin R s).starClosure 
goal: StarAlgebra.adjoin R s = (Algebra.adjoin R s).starClosure

full_name: StarAlgebra.adjoin_toSubalgebra
code: theorem adjoin_toSubalgebra (s : Set A) :
    (adjoin R s).toSubalgebra = Algebra.adjoin R (s ∪ star s) 
goal: (StarAlgebra.adjoin R s).toSubalgebra = Algebra.adjoin R (s ∪ star s)

full_name: StarAlgebra.subset_adjoin
code: @[aesop safe 20 apply (rule_sets := [SetLike])]
theorem subset_adjoin (s : Set A) : s ⊆ adjoin R s 
goal: s ⊆ ↑(StarAlgebra.adjoin R s)

full_name: StarAlgebra.star_subset_adjoin
code: theorem star_subset_adjoin (s : Set A) : star s ⊆ adjoin R s 
goal: star s ⊆ ↑(StarAlgebra.adjoin R s)

full_name: StarAlgebra.self_mem_adjoin_singleton
code: theorem self_mem_adjoin_singleton (x : A) : x ∈ adjoin R ({x} : Set A) 
goal: x ∈ StarAlgebra.adjoin R {x}

full_name: StarAlgebra.star_self_mem_adjoin_singleton
code: theorem star_self_mem_adjoin_singleton (x : A) : star x ∈ adjoin R ({x} : Set A) 
goal: star x ∈ StarAlgebra.adjoin R {x}

full_name: StarAlgebra.gc
code: protected theorem gc : GaloisConnection (adjoin R : Set A → StarSubalgebra R A) (↑) 
goal: GaloisConnection (StarAlgebra.adjoin R) SetLike.coe

full_name: StarAlgebra.gi
code: /-- Galois insertion between `adjoin` and `coe`. -/
protected def gi : GaloisInsertion (adjoin R : Set A → StarSubalgebra R A) (↑) 
goal: GaloisInsertion (StarAlgebra.adjoin R) SetLike.coe

full_name: StarAlgebra.adjoin_le
code: theorem adjoin_le {S : StarSubalgebra R A} {s : Set A} (hs : s ⊆ S) : adjoin R s ≤ S 
goal: StarAlgebra.adjoin R s ≤ S

full_name: StarAlgebra.adjoin_le_iff
code: theorem adjoin_le_iff {S : StarSubalgebra R A} {s : Set A} : adjoin R s ≤ S ↔ s ⊆ S 
goal: StarAlgebra.adjoin R s ≤ S ↔ s ⊆ ↑S

full_name: StarAlgebra.adjoin_eq
code: lemma adjoin_eq (S : StarSubalgebra R A) : adjoin R (S : Set A) = S 
goal: StarAlgebra.adjoin R ↑S = S

full_name: StarAlgebra.adjoin_eq_span
code: lemma adjoin_eq_span (s : Set A) :
    Subalgebra.toSubmodule (adjoin R s).toSubalgebra = span R (Submonoid.closure (s ∪ star s)) 
goal: Subalgebra.toSubmodule (StarAlgebra.adjoin R s).toSubalgebra = Submodule.span R ↑(Submonoid.closure (s ∪ star s))

full_name: Subalgebra.starClosure_eq_adjoin
code: theorem _root_.Subalgebra.starClosure_eq_adjoin (S : Subalgebra R A) :
    S.starClosure = adjoin R (S : Set A) 
goal: S.starClosure = StarAlgebra.adjoin R ↑S

full_name: StarAlgebra.adjoin_induction
code: /-- If some predicate holds for all `x ∈ (s : Set A)` and this predicate is closed under the
`algebraMap`, addition, multiplication and star operations, then it holds for `a ∈ adjoin R s`. -/
@[elab_as_elim]
theorem adjoin_induction {s : Set A} {p : A → Prop} {a : A} (h : a ∈ adjoin R s)
    (mem : ∀ x : A, x ∈ s → p x) (algebraMap : ∀ r : R, p (algebraMap R A r))
    (add : ∀ x y : A, p x → p y → p (x + y)) (mul : ∀ x y : A, p x → p y → p (x * y))
    (star : ∀ x : A, p x → p (star x)) : p a 
goal: p a

full_name: StarAlgebra.adjoin_induction₂
code: @[elab_as_elim]
theorem adjoin_induction₂ {s : Set A} {p : A → A → Prop} {a b : A} (ha : a ∈ adjoin R s)
    (hb : b ∈ adjoin R s) (Hs : ∀ x : A, x ∈ s → ∀ y : A, y ∈ s → p x y)
    (Halg : ∀ r₁ r₂ : R, p (algebraMap R A r₁) (algebraMap R A r₂))
    (Halg_left : ∀ (r : R) (x : A), x ∈ s → p (algebraMap R A r) x)
    (Halg_right : ∀ (r : R) (x : A), x ∈ s → p x (algebraMap R A r))
    (Hadd_left : ∀ x₁ x₂ y : A, p x₁ y → p x₂ y → p (x₁ + x₂) y)
    (Hadd_right : ∀ x y₁ y₂ : A, p x y₁ → p x y₂ → p x (y₁ + y₂))
    (Hmul_left : ∀ x₁ x₂ y : A, p x₁ y → p x₂ y → p (x₁ * x₂) y)
    (Hmul_right : ∀ x y₁ y₂ : A, p x y₁ → p x y₂ → p x (y₁ * y₂))
    (Hstar : ∀ x y : A, p x y → p (star x) (star y)) (Hstar_left : ∀ x y : A, p x y → p (star x) y)
    (Hstar_right : ∀ x y : A, p x y → p x (star y)) : p a b 
goal: p a b

full_name: StarAlgebra.adjoin_induction'
code: /-- The difference with `StarSubalgebra.adjoin_induction` is that this acts on the subtype. -/
@[elab_as_elim]
theorem adjoin_induction' {s : Set A} {p : adjoin R s → Prop} (a : adjoin R s)
    (mem : ∀ (x) (h : x ∈ s), p ⟨x, subset_adjoin R s h⟩) (algebraMap : ∀ r, p (algebraMap R _ r))
    (add : ∀ x y, p x → p y → p (x + y)) (mul : ∀ x y, p x → p y → p (x * y))
    (star : ∀ x, p x → p (star x)) : p a 
goal: p a

full_name: StarAlgebra.adjoinCommSemiringOfComm
code: /-- If all elements of `s : Set A` commute pairwise and also commute pairwise with elements of
`star s`, then `StarSubalgebra.adjoin R s` is commutative. See note [reducible non-instances]. -/
abbrev adjoinCommSemiringOfComm {s : Set A}
    (hcomm : ∀ a : A, a ∈ s → ∀ b : A, b ∈ s → a * b = b * a)
    (hcomm_star : ∀ a : A, a ∈ s → ∀ b : A, b ∈ s → a * star b = star b * a) :
    CommSemiring (adjoin R s) 
goal: CommSemiring ↥(StarAlgebra.adjoin R s)

full_name: StarAlgebra.adjoinCommRingOfComm
code: /-- If all elements of `s : Set A` commute pairwise and also commute pairwise with elements of
`star s`, then `StarSubalgebra.adjoin R s` is commutative. See note [reducible non-instances]. -/
abbrev adjoinCommRingOfComm (R : Type u) {A : Type v} [CommRing R] [StarRing R] [Ring A]
    [Algebra R A] [StarRing A] [StarModule R A] {s : Set A}
    (hcomm : ∀ a : A, a ∈ s → ∀ b : A, b ∈ s → a * b = b * a)
    (hcomm_star : ∀ a : A, a ∈ s → ∀ b : A, b ∈ s → a * star b = star b * a) :
    CommRing (adjoin R s) 
goal: CommRing ↥(StarAlgebra.adjoin R s)

full_name: StarAlgebra.adjoinCommSemiringOfIsStarNormal
code: /-- The star subalgebra `StarSubalgebra.adjoin R {x}` generated by a single `x : A` is commutative
if `x` is normal. -/
instance adjoinCommSemiringOfIsStarNormal (x : A) [IsStarNormal x] :
    CommSemiring (adjoin R ({x} : Set A)) 
goal: CommSemiring ↥(StarAlgebra.adjoin R {x})

full_name: StarAlgebra.adjoinCommRingOfIsStarNormal
code: /-- The star subalgebra `StarSubalgebra.adjoin R {x}` generated by a single `x : A` is commutative
if `x` is normal. -/
instance adjoinCommRingOfIsStarNormal (R : Type u) {A : Type v} [CommRing R] [StarRing R] [Ring A]
    [Algebra R A] [StarRing A] [StarModule R A] (x : A) [IsStarNormal x] :
    CommRing (adjoin R ({x} : Set A)) 
goal: CommRing ↥(StarAlgebra.adjoin R {x})

full_name: StarSubalgebra.completeLattice
code: instance completeLattice : CompleteLattice (StarSubalgebra R A) 
goal: CompleteLattice (StarSubalgebra R A)

full_name: StarSubalgebra.inhabited
code: instance inhabited : Inhabited (StarSubalgebra R A) 
goal: Inhabited (StarSubalgebra R A)

full_name: StarSubalgebra.coe_top
code: @[simp]
theorem coe_top : (↑(⊤ : StarSubalgebra R A) : Set A) = Set.univ 
goal: ↑⊤ = Set.univ

full_name: StarSubalgebra.mem_top
code: @[simp]
theorem mem_top {x : A} : x ∈ (⊤ : StarSubalgebra R A) 
goal: x ∈ ⊤

full_name: StarSubalgebra.top_toSubalgebra
code: @[simp]
theorem top_toSubalgebra : (⊤ : StarSubalgebra R A).toSubalgebra = ⊤ 
goal: ⊤.toSubalgebra = ⊤

full_name: StarSubalgebra.toSubalgebra_eq_top
code: @[simp]
theorem toSubalgebra_eq_top {S : StarSubalgebra R A} : S.toSubalgebra = ⊤ ↔ S = ⊤ 
goal: S.toSubalgebra = ⊤ ↔ S = ⊤

full_name: StarSubalgebra.mem_sup_left
code: theorem mem_sup_left {S T : StarSubalgebra R A} : ∀ {x : A}, x ∈ S → x ∈ S ⊔ T 
goal: x ∈ S → x ∈ S ⊔ T

full_name: StarSubalgebra.mem_sup_right
code: theorem mem_sup_right {S T : StarSubalgebra R A} : ∀ {x : A}, x ∈ T → x ∈ S ⊔ T 
goal: x ∈ T → x ∈ S ⊔ T

full_name: StarSubalgebra.mul_mem_sup
code: theorem mul_mem_sup {S T : StarSubalgebra R A} {x y : A} (hx : x ∈ S) (hy : y ∈ T) :
    x * y ∈ S ⊔ T 
goal: x * y ∈ S ⊔ T

full_name: StarSubalgebra.map_sup
code: theorem map_sup (f : A →⋆ₐ[R] B) (S T : StarSubalgebra R A) : map f (S ⊔ T) = map f S ⊔ map f T 
goal: StarSubalgebra.map f (S ⊔ T) = StarSubalgebra.map f S ⊔ StarSubalgebra.map f T

full_name: StarSubalgebra.coe_inf
code: @[simp, norm_cast]
theorem coe_inf (S T : StarSubalgebra R A) : (↑(S ⊓ T) : Set A) = (S : Set A) ∩ T 
goal: ↑(S ⊓ T) = ↑S ∩ ↑T

full_name: StarSubalgebra.mem_inf
code: @[simp]
theorem mem_inf {S T : StarSubalgebra R A} {x : A} : x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T 
goal: x ∈ S ⊓ T ↔ x ∈ S ∧ x ∈ T

full_name: StarSubalgebra.inf_toSubalgebra
code: @[simp]
theorem inf_toSubalgebra (S T : StarSubalgebra R A) :
    (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra 
goal: (S ⊓ T).toSubalgebra = S.toSubalgebra ⊓ T.toSubalgebra

full_name: StarSubalgebra.coe_sInf
code: @[simp, norm_cast]
theorem coe_sInf (S : Set (StarSubalgebra R A)) : (↑(sInf S) : Set A) = ⋂ s ∈ S, ↑s 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: StarSubalgebra.mem_sInf
code: theorem mem_sInf {S : Set (StarSubalgebra R A)} {x : A} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p 
goal: x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p

full_name: StarSubalgebra.sInf_toSubalgebra
code: @[simp]
theorem sInf_toSubalgebra (S : Set (StarSubalgebra R A)) :
    (sInf S).toSubalgebra = sInf (StarSubalgebra.toSubalgebra '' S) 
goal: (sInf S).toSubalgebra = sInf (StarSubalgebra.toSubalgebra '' S)

full_name: StarSubalgebra.coe_iInf
code: @[simp, norm_cast]
theorem coe_iInf {ι : Sort*} {S : ι → StarSubalgebra R A} : (↑(⨅ i, S i) : Set A) = ⋂ i, S i 
goal: ↑(⨅ i, S i) = ⋂ i, ↑(S i)

full_name: StarSubalgebra.mem_iInf
code: theorem mem_iInf {ι : Sort*} {S : ι → StarSubalgebra R A} {x : A} :
    (x ∈ ⨅ i, S i) ↔ ∀ i, x ∈ S i 
goal: x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i

full_name: StarSubalgebra.iInf_toSubalgebra
code: @[simp]
theorem iInf_toSubalgebra {ι : Sort*} (S : ι → StarSubalgebra R A) :
    (⨅ i, S i).toSubalgebra = ⨅ i, (S i).toSubalgebra 
goal: (⨅ i, S i).toSubalgebra = ⨅ i, (S i).toSubalgebra

full_name: StarSubalgebra.bot_toSubalgebra
code: theorem bot_toSubalgebra : (⊥ : StarSubalgebra R A).toSubalgebra = ⊥ 
goal: ⊥.toSubalgebra = ⊥

full_name: StarSubalgebra.mem_bot
code: theorem mem_bot {x : A} : x ∈ (⊥ : StarSubalgebra R A) ↔ x ∈ Set.range (algebraMap R A) 
goal: x ∈ ⊥ ↔ x ∈ Set.range ⇑(algebraMap R A)

full_name: StarSubalgebra.coe_bot
code: @[simp]
theorem coe_bot : ((⊥ : StarSubalgebra R A) : Set A) = Set.range (algebraMap R A) 
goal: ↑⊥ = Set.range ⇑(algebraMap R A)

full_name: StarSubalgebra.eq_top_iff
code: theorem eq_top_iff {S : StarSubalgebra R A} : S = ⊤ ↔ ∀ x : A, x ∈ S 
goal: S = ⊤ ↔ ∀ (x : A), x ∈ S

full_name: StarAlgHom.equalizer
code: /-- The equalizer of two star `R`-algebra homomorphisms. -/
def equalizer : StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: StarAlgHom.mem_equalizer
code: @[simp]
theorem mem_equalizer (x : A) : x ∈ StarAlgHom.equalizer f g ↔ f x = g x 
goal: x ∈ StarAlgHom.equalizer f g ↔ f x = g x

full_name: StarAlgHom.adjoin_le_equalizer
code: theorem adjoin_le_equalizer {s : Set A} (h : s.EqOn f g) : adjoin R s ≤ StarAlgHom.equalizer f g 
goal: StarAlgebra.adjoin R s ≤ StarAlgHom.equalizer f g

full_name: StarAlgHom.ext_of_adjoin_eq_top
code: theorem ext_of_adjoin_eq_top {s : Set A} (h : adjoin R s = ⊤) ⦃f g : F⦄ (hs : s.EqOn f g) : f = g 
goal: f = g

full_name: StarAlgHom.map_adjoin
code: theorem map_adjoin (f : A →⋆ₐ[R] B) (s : Set A) :
    map f (adjoin R s) = adjoin R (f '' s) 
goal: StarSubalgebra.map f (StarAlgebra.adjoin R s) = StarAlgebra.adjoin R (⇑f '' s)

full_name: StarAlgHom.ext_adjoin
code: theorem ext_adjoin {s : Set A} [FunLike F (adjoin R s) B]
    [AlgHomClass F R (adjoin R s) B] [StarAlgHomClass F R (adjoin R s) B] {f g : F}
    (h : ∀ x : adjoin R s, (x : A) ∈ s → f x = g x) : f = g 
goal: f = g

full_name: StarAlgHom.ext_adjoin_singleton
code: theorem ext_adjoin_singleton {a : A} [FunLike F (adjoin R ({a} : Set A)) B]
    [AlgHomClass F R (adjoin R ({a} : Set A)) B] [StarAlgHomClass F R (adjoin R ({a} : Set A)) B]
    {f g : F} (h : f ⟨a, self_mem_adjoin_singleton R a⟩ = g ⟨a, self_mem_adjoin_singleton R a⟩) :
    f = g 
goal: f = g

full_name: StarAlgHom.range
code: /-- Range of a `StarAlgHom` as a star subalgebra. -/
protected def range
    (φ : A →⋆ₐ[R] B) : StarSubalgebra R B 
goal: StarSubalgebra R B

full_name: StarAlgHom.range_eq_map_top
code: theorem range_eq_map_top (φ : A →⋆ₐ[R] B) : φ.range = (⊤ : StarSubalgebra R A).map φ 
goal: φ.range = StarSubalgebra.map φ ⊤

full_name: StarAlgHom.codRestrict
code: /-- Restriction of the codomain of a `StarAlgHom` to a star subalgebra containing the range. -/
protected def codRestrict (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B) (hf : ∀ x, f x ∈ S) :
    A →⋆ₐ[R] S 
goal: A →⋆ₐ[R] ↥S

full_name: StarAlgHom.coe_codRestrict
code: @[simp]
theorem coe_codRestrict (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B) (hf : ∀ x, f x ∈ S) (x : A) :
    ↑(f.codRestrict S hf x) = f x 
goal: ↑((f.codRestrict S hf) x) = f x

full_name: StarAlgHom.subtype_comp_codRestrict
code: @[simp]
theorem subtype_comp_codRestrict (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B)
    (hf : ∀ x : A, f x ∈ S) : S.subtype.comp (f.codRestrict S hf) = f 
goal: S.subtype.comp (f.codRestrict S hf) = f

full_name: StarAlgHom.injective_codRestrict
code: theorem injective_codRestrict (f : A →⋆ₐ[R] B) (S : StarSubalgebra R B) (hf : ∀ x : A, f x ∈ S) :
    Function.Injective (StarAlgHom.codRestrict f S hf) ↔ Function.Injective f 
goal: Function.Injective ⇑(f.codRestrict S hf) ↔ Function.Injective ⇑f

full_name: StarAlgHom.rangeRestrict
code: /-- Restriction of the codomain of a `StarAlgHom` to its range. -/
def rangeRestrict (f : A →⋆ₐ[R] B) : A →⋆ₐ[R] f.range 
goal: A →⋆ₐ[R] ↥f.range

full_name: StarAlgEquiv.ofInjective_apply
code: /-- The `StarAlgEquiv` onto the range corresponding to an injective `StarAlgHom`. -/
@[simps]
noncomputable def _root_.StarAlgEquiv.ofInjective (f : A →⋆ₐ[R] B)
    (hf : Function.Injective f) : A ≃⋆ₐ[R] f.range 
goal: (StarAlgEquiv.ofInjective f hf) a = f.rangeRestrict a

full_name: StarAlgEquiv.ofInjective_symm_apply
code: /-- The `StarAlgEquiv` onto the range corresponding to an injective `StarAlgHom`. -/
@[simps]
noncomputable def _root_.StarAlgEquiv.ofInjective (f : A →⋆ₐ[R] B)
    (hf : Function.Injective f) : A ≃⋆ₐ[R] f.range 
goal: ∀ (a : ↥(↑f).range), (StarAlgEquiv.ofInjective f hf).symm a = (AlgEquiv.ofInjective (↑f) hf).invFun a

full_name: StarAlgEquiv.ofInjective
code: /-- The `StarAlgEquiv` onto the range corresponding to an injective `StarAlgHom`. -/
@[simps]
noncomputable def _root_.StarAlgEquiv.ofInjective (f : A →⋆ₐ[R] B)
    (hf : Function.Injective f) : A ≃⋆ₐ[R] f.range 
goal: A ≃⋆ₐ[R] ↥f.range

full_name: StarAlgHom.restrictScalars
code: @[simps!]
def StarAlgHom.restrictScalars (f : A →⋆ₐ[S] B) : A →⋆ₐ[R] B 
goal: A →⋆ₐ[R] B

full_name: StarAlgHom.restrictScalars_apply
code: @[simps!]
def StarAlgHom.restrictScalars (f : A →⋆ₐ[S] B) : A →⋆ₐ[R] B 
goal: ∀ (a : A), (StarAlgHom.restrictScalars R f) a = f a

full_name: StarAlgHom.restrictScalars_injective
code: theorem StarAlgHom.restrictScalars_injective :
    Function.Injective (StarAlgHom.restrictScalars R : (A →⋆ₐ[S] B) → A →⋆ₐ[R] B) 
goal: Function.Injective (StarAlgHom.restrictScalars R)

full_name: StarAlgEquiv.restrictScalars_apply
code: @[simps]
def StarAlgEquiv.restrictScalars (f : A ≃⋆ₐ[S] B) : A ≃⋆ₐ[R] B 
goal: (StarAlgEquiv.restrictScalars R f) a = f a

full_name: StarAlgEquiv.restrictScalars
code: @[simps]
def StarAlgEquiv.restrictScalars (f : A ≃⋆ₐ[S] B) : A ≃⋆ₐ[R] B 
goal: A ≃⋆ₐ[R] B

full_name: StarAlgEquiv.restrictScalars_symm_apply
code: @[simps]
def StarAlgEquiv.restrictScalars (f : A ≃⋆ₐ[S] B) : A ≃⋆ₐ[R] B 
goal: ∀ (a : B), (StarAlgEquiv.restrictScalars R f).symm a = f.invFun a

full_name: StarAlgEquiv.restrictScalars_injective
code: theorem StarAlgEquiv.restrictScalars_injective :
    Function.Injective (StarAlgEquiv.restrictScalars R : (A ≃⋆ₐ[S] B) → A ≃⋆ₐ[R] B) 
goal: Function.Injective (StarAlgEquiv.restrictScalars R)