File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

full_name: Subalgebra.toNonUnitalSubalgebra
code: /-- Turn a `Subalgebra` into a `NonUnitalSubalgebra` by forgetting that it contains `1`. -/
def Subalgebra.toNonUnitalSubalgebra (S : Subalgebra R A) : NonUnitalSubalgebra R A 
goal: NonUnitalSubalgebra R A

full_name: Subalgebra.one_mem_toNonUnitalSubalgebra
code: theorem Subalgebra.one_mem_toNonUnitalSubalgebra (S : Subalgebra R A) :
    (1 : A) ∈ S.toNonUnitalSubalgebra 
goal: 1 ∈ S.toNonUnitalSubalgebra

full_name: NonUnitalSubalgebra.toSubalgebra
code: /-- Turn a non-unital subalgebra containing `1` into a subalgebra. -/
def NonUnitalSubalgebra.toSubalgebra (S : NonUnitalSubalgebra R A) (h1 : (1 : A) ∈ S) :
    Subalgebra R A 
goal: Subalgebra R A

full_name: Subalgebra.toNonUnitalSubalgebra_toSubalgebra
code: theorem Subalgebra.toNonUnitalSubalgebra_toSubalgebra (S : Subalgebra R A) :
    S.toNonUnitalSubalgebra.toSubalgebra S.one_mem = S 
goal: S.toNonUnitalSubalgebra.toSubalgebra ⋯ = S

full_name: NonUnitalSubalgebra.toSubalgebra_toNonUnitalSubalgebra
code: theorem NonUnitalSubalgebra.toSubalgebra_toNonUnitalSubalgebra (S : NonUnitalSubalgebra R A)
    (h1 : (1 : A) ∈ S) : (NonUnitalSubalgebra.toSubalgebra S h1).toNonUnitalSubalgebra = S 
goal: (S.toSubalgebra h1).toNonUnitalSubalgebra = S

full_name: Algebra.adjoin_nonUnitalSubalgebra_eq_span
code: lemma Algebra.adjoin_nonUnitalSubalgebra_eq_span (s : NonUnitalSubalgebra R A) :
    Subalgebra.toSubmodule (adjoin R (s : Set A)) = span R {1} ⊔ s.toSubmodule 
goal: Subalgebra.toSubmodule (Algebra.adjoin R ↑s) = Submodule.span R {1} ⊔ s.toSubmodule

full_name: NonUnitalAlgebra.adjoin_le_algebra_adjoin
code: lemma NonUnitalAlgebra.adjoin_le_algebra_adjoin (s : Set A) :
    adjoin R s ≤ (Algebra.adjoin R s).toNonUnitalSubalgebra 
goal: NonUnitalAlgebra.adjoin R s ≤ (Algebra.adjoin R s).toNonUnitalSubalgebra

full_name: Algebra.adjoin_nonUnitalSubalgebra
code: lemma Algebra.adjoin_nonUnitalSubalgebra (s : Set A) :
    adjoin R (NonUnitalAlgebra.adjoin R s : Set A) = adjoin R s 
goal: Algebra.adjoin R ↑(NonUnitalAlgebra.adjoin R s) = Algebra.adjoin R s

full_name: Unitization.lift_range_le
code: theorem lift_range_le {f : A →ₙₐ[R] C} {S : Subalgebra R C} :
    (lift f).range ≤ S ↔ NonUnitalAlgHom.range f ≤ S.toNonUnitalSubalgebra 
goal: (Unitization.lift f).range ≤ S ↔ NonUnitalAlgHom.range f ≤ S.toNonUnitalSubalgebra

full_name: Unitization.lift_range
code: theorem lift_range (f : A →ₙₐ[R] C) :
    (lift f).range = Algebra.adjoin R (NonUnitalAlgHom.range f : Set C) 
goal: (Unitization.lift f).range = Algebra.adjoin R ↑(NonUnitalAlgHom.range f)

full_name: NonUnitalSubalgebra.unitization
code: /-- The natural `R`-algebra homomorphism from the unitization of a non-unital subalgebra into
the algebra containing it. -/
def unitization : Unitization R s →ₐ[R] A 
goal: Unitization R ↥s →ₐ[R] A

full_name: NonUnitalSubalgebra.unitization_apply
code: @[simp]
theorem unitization_apply (x : Unitization R s) :
    unitization s x = algebraMap R A x.fst + x.snd 
goal: (NonUnitalSubalgebra.unitization s) x = (algebraMap R A) x.fst + ↑x.snd

full_name: NonUnitalSubalgebra.unitization_range
code: theorem unitization_range : (unitization s).range = Algebra.adjoin R (s : Set A) 
goal: (NonUnitalSubalgebra.unitization s).range = Algebra.adjoin R ↑s

full_name: AlgHomClass.unitization_injective'
code: /-- A sufficient condition for injectivity of `NonUnitalSubalgebra.unitization` when the scalars
are a commutative ring. When the scalars are a field, one should use the more natural
`NonUnitalStarSubalgebra.unitization_injective` whose hypothesis is easier to verify. -/
theorem _root_.AlgHomClass.unitization_injective' {F R S A : Type*} [CommRing R] [Ring A]
    [Algebra R A] [SetLike S A] [hSA : NonUnitalSubringClass S A] [hSRA : SMulMemClass S R A]
    (s : S) (h : ∀ r, r ≠ 0 → algebraMap R A r ∉ s)
    [FunLike F (Unitization R s) A] [AlgHomClass F R (Unitization R s) A]
    (f : F) (hf : ∀ x : s, f x = x) : Function.Injective f 
goal: Function.Injective ⇑f

full_name: AlgHomClass.unitization_injective
code: /-- This is a generic version which allows us to prove both
`NonUnitalSubalgebra.unitization_injective` and `NonUnitalStarSubalgebra.unitization_injective`. -/
theorem _root_.AlgHomClass.unitization_injective {F R S A : Type*} [Field R] [Ring A]
    [Algebra R A] [SetLike S A] [hSA : NonUnitalSubringClass S A] [hSRA : SMulMemClass S R A]
    (s : S) (h1 : 1 ∉ s) [FunLike F (Unitization R s) A] [AlgHomClass F R (Unitization R s) A]
    (f : F) (hf : ∀ x : s, f x = x) : Function.Injective f 
goal: Function.Injective ⇑f

full_name: NonUnitalSubalgebra.unitization_injective
code: theorem unitization_injective (h1 : (1 : A) ∉ s) : Function.Injective (unitization s) 
goal: Function.Injective ⇑(NonUnitalSubalgebra.unitization s)

full_name: NonUnitalSubalgebra.unitizationAlgEquiv
code: /-- If a `NonUnitalSubalgebra` over a field does not contain `1`, then its unitization is
isomorphic to its `Algebra.adjoin`. -/
@[simps! apply_coe]
noncomputable def unitizationAlgEquiv (h1 : (1 : A) ∉ s) :
    Unitization R s ≃ₐ[R] Algebra.adjoin R (s : Set A) 
goal: Unitization R ↥s ≃ₐ[R] ↥(Algebra.adjoin R ↑s)

full_name: NonUnitalSubalgebra.unitizationAlgEquiv_apply_coe
code: /-- If a `NonUnitalSubalgebra` over a field does not contain `1`, then its unitization is
isomorphic to its `Algebra.adjoin`. -/
@[simps! apply_coe]
noncomputable def unitizationAlgEquiv (h1 : (1 : A) ∉ s) :
    Unitization R s ≃ₐ[R] Algebra.adjoin R (s : Set A) 
goal: ↑((NonUnitalSubalgebra.unitizationAlgEquiv s h1) a) = (algebraMap R A) a.fst + ↑a.snd

full_name: Subsemiring.toNonUnitalSubsemiring
code: /-- Turn a `Subsemiring` into a `NonUnitalSubsemiring` by forgetting that it contains `1`. -/
def Subsemiring.toNonUnitalSubsemiring (S : Subsemiring R) : NonUnitalSubsemiring R 
goal: NonUnitalSubsemiring R

full_name: Subsemiring.one_mem_toNonUnitalSubsemiring
code: theorem Subsemiring.one_mem_toNonUnitalSubsemiring (S : Subsemiring R) :
    (1 : R) ∈ S.toNonUnitalSubsemiring 
goal: 1 ∈ S.toNonUnitalSubsemiring

full_name: NonUnitalSubsemiring.toSubsemiring
code: /-- Turn a non-unital subsemiring containing `1` into a subsemiring. -/
def NonUnitalSubsemiring.toSubsemiring (S : NonUnitalSubsemiring R) (h1 : (1 : R) ∈ S) :
    Subsemiring R 
goal: Subsemiring R

full_name: Subsemiring.toNonUnitalSubsemiring_toSubsemiring
code: theorem Subsemiring.toNonUnitalSubsemiring_toSubsemiring (S : Subsemiring R) :
    S.toNonUnitalSubsemiring.toSubsemiring S.one_mem = S 
goal: S.toNonUnitalSubsemiring.toSubsemiring ⋯ = S

full_name: NonUnitalSubsemiring.toSubsemiring_toNonUnitalSubsemiring
code: theorem NonUnitalSubsemiring.toSubsemiring_toNonUnitalSubsemiring (S : NonUnitalSubsemiring R)
    (h1 : (1 : R) ∈ S) : (NonUnitalSubsemiring.toSubsemiring S h1).toNonUnitalSubsemiring = S 
goal: (S.toSubsemiring h1).toNonUnitalSubsemiring = S

full_name: NonUnitalSubsemiring.unitization
code: /-- The natural `ℕ`-algebra homomorphism from the unitization of a non-unital subsemiring to
its `Subsemiring.closure`. -/
def unitization : Unitization ℕ s →ₐ[ℕ] R 
goal: Unitization ℕ ↥s →ₐ[ℕ] R

full_name: NonUnitalSubsemiring.unitization_apply
code: @[simp]
theorem unitization_apply (x : Unitization ℕ s) : unitization s x = x.fst + x.snd 
goal: (NonUnitalSubsemiring.unitization s) x = ↑x.fst + ↑x.snd

full_name: NonUnitalSubsemiring.unitization_range
code: theorem unitization_range :
    (unitization s).range = subalgebraOfSubsemiring (Subsemiring.closure s) 
goal: (NonUnitalSubsemiring.unitization s).range = subalgebraOfSubsemiring (Subsemiring.closure ↑s)

full_name: Subring.toNonUnitalSubring
code: /-- Turn a `Subring` into a `NonUnitalSubring` by forgetting that it contains `1`. -/
def Subring.toNonUnitalSubring (S : Subring R) : NonUnitalSubring R 
goal: NonUnitalSubring R

full_name: Subring.one_mem_toNonUnitalSubring
code: theorem Subring.one_mem_toNonUnitalSubring (S : Subring R) : (1 : R) ∈ S.toNonUnitalSubring 
goal: 1 ∈ S.toNonUnitalSubring

full_name: NonUnitalSubring.toSubring
code: /-- Turn a non-unital subring containing `1` into a subring. -/
def NonUnitalSubring.toSubring (S : NonUnitalSubring R) (h1 : (1 : R) ∈ S) : Subring R 
goal: Subring R

full_name: Subring.toNonUnitalSubring_toSubring
code: theorem Subring.toNonUnitalSubring_toSubring (S : Subring R) :
    S.toNonUnitalSubring.toSubring S.one_mem = S 
goal: S.toNonUnitalSubring.toSubring ⋯ = S

full_name: NonUnitalSubring.toSubring_toNonUnitalSubring
code: theorem NonUnitalSubring.toSubring_toNonUnitalSubring (S : NonUnitalSubring R) (h1 : (1 : R) ∈ S) :
    (NonUnitalSubring.toSubring S h1).toNonUnitalSubring = S 
goal: (S.toSubring h1).toNonUnitalSubring = S

full_name: NonUnitalSubring.unitization
code: /-- The natural `ℤ`-algebra homomorphism from the unitization of a non-unital subring to
its `Subring.closure`. -/
def unitization : Unitization ℤ s →ₐ[ℤ] R 
goal: Unitization ℤ ↥s →ₐ[ℤ] R

full_name: NonUnitalSubring.unitization_apply
code: @[simp]
theorem unitization_apply (x : Unitization ℤ s) : unitization s x = x.fst + x.snd 
goal: (NonUnitalSubring.unitization s) x = ↑x.fst + ↑x.snd

full_name: NonUnitalSubring.unitization_range
code: theorem unitization_range :
    (unitization s).range = subalgebraOfSubring (Subring.closure s) 
goal: (NonUnitalSubring.unitization s).range = subalgebraOfSubring (Subring.closure ↑s)

full_name: StarSubalgebra.toNonUnitalStarSubalgebra
code: /-- Turn a `StarSubalgebra` into a `NonUnitalStarSubalgebra` by forgetting that it contains `1`. -/
def StarSubalgebra.toNonUnitalStarSubalgebra (S : StarSubalgebra R A) :
    NonUnitalStarSubalgebra R A 
goal: NonUnitalStarSubalgebra R A

full_name: StarSubalgebra.one_mem_toNonUnitalStarSubalgebra
code: theorem StarSubalgebra.one_mem_toNonUnitalStarSubalgebra (S : StarSubalgebra R A) :
    (1 : A) ∈ S.toNonUnitalStarSubalgebra 
goal: 1 ∈ S.toNonUnitalStarSubalgebra

full_name: NonUnitalStarSubalgebra.toStarSubalgebra
code: /-- Turn a non-unital star subalgebra containing `1` into a `StarSubalgebra`. -/
def NonUnitalStarSubalgebra.toStarSubalgebra (S : NonUnitalStarSubalgebra R A) (h1 : (1 : A) ∈ S) :
    StarSubalgebra R A 
goal: StarSubalgebra R A

full_name: StarSubalgebra.toNonUnitalStarSubalgebra_toStarSubalgebra
code: theorem StarSubalgebra.toNonUnitalStarSubalgebra_toStarSubalgebra (S : StarSubalgebra R A) :
    S.toNonUnitalStarSubalgebra.toStarSubalgebra S.one_mem' = S 
goal: S.toNonUnitalStarSubalgebra.toStarSubalgebra ⋯ = S

full_name: NonUnitalStarSubalgebra.toStarSubalgebra_toNonUnitalStarSubalgebra
code: theorem NonUnitalStarSubalgebra.toStarSubalgebra_toNonUnitalStarSubalgebra
    (S : NonUnitalStarSubalgebra R A) (h1 : (1 : A) ∈ S) :
    (S.toStarSubalgebra h1).toNonUnitalStarSubalgebra = S 
goal: (S.toStarSubalgebra h1).toNonUnitalStarSubalgebra = S

full_name: StarAlgebra.adjoin_nonUnitalStarSubalgebra_eq_span
code: lemma StarAlgebra.adjoin_nonUnitalStarSubalgebra_eq_span (s : NonUnitalStarSubalgebra R A) :
    Subalgebra.toSubmodule (adjoin R (s : Set A)).toSubalgebra = span R {1} ⊔ s.toSubmodule 
goal: Subalgebra.toSubmodule (StarAlgebra.adjoin R ↑s).toSubalgebra = Submodule.span R {1} ⊔ s.toSubmodule

full_name: NonUnitalStarAlgebra.adjoin_le_starAlgebra_adjoin
code: lemma NonUnitalStarAlgebra.adjoin_le_starAlgebra_adjoin (s : Set A) :
    adjoin R s ≤ (StarAlgebra.adjoin R s).toNonUnitalStarSubalgebra 
goal: NonUnitalStarAlgebra.adjoin R s ≤ (StarAlgebra.adjoin R s).toNonUnitalStarSubalgebra

full_name: StarAlgebra.adjoin_nonUnitalStarSubalgebra
code: lemma StarAlgebra.adjoin_nonUnitalStarSubalgebra (s : Set A) :
    adjoin R (NonUnitalStarAlgebra.adjoin R s : Set A) = adjoin R s 
goal: StarAlgebra.adjoin R ↑(NonUnitalStarAlgebra.adjoin R s) = StarAlgebra.adjoin R s

full_name: Unitization.starLift_range_le
code: theorem starLift_range_le
    {f : A →⋆ₙₐ[R] C} {S : StarSubalgebra R C} :
    (starLift f).range ≤ S ↔ NonUnitalStarAlgHom.range f ≤ S.toNonUnitalStarSubalgebra 
goal: (Unitization.starLift f).range ≤ S ↔ NonUnitalStarAlgHom.range f ≤ S.toNonUnitalStarSubalgebra

full_name: Unitization.starLift_range
code: theorem starLift_range (f : A →⋆ₙₐ[R] C) :
    (starLift f).range = StarAlgebra.adjoin R (NonUnitalStarAlgHom.range f : Set C) 
goal: (Unitization.starLift f).range = StarAlgebra.adjoin R ↑(NonUnitalStarAlgHom.range f)

full_name: NonUnitalStarSubalgebra.unitization
code: /-- The natural star `R`-algebra homomorphism from the unitization of a non-unital star subalgebra
to its `StarAlgebra.adjoin`. -/
def unitization : Unitization R s →⋆ₐ[R] A 
goal: Unitization R ↥s →⋆ₐ[R] A

full_name: NonUnitalStarSubalgebra.unitization_apply
code: @[simp]
theorem unitization_apply (x : Unitization R s) : unitization s x = algebraMap R A x.fst + x.snd 
goal: (NonUnitalStarSubalgebra.unitization s) x = (algebraMap R A) x.fst + ↑x.snd

full_name: NonUnitalStarSubalgebra.unitization_range
code: theorem unitization_range : (unitization s).range = StarAlgebra.adjoin R s 
goal: (NonUnitalStarSubalgebra.unitization s).range = StarAlgebra.adjoin R ↑s

full_name: NonUnitalStarSubalgebra.unitization_injective
code: theorem unitization_injective (h1 : (1 : A) ∉ s) : Function.Injective (unitization s) 
goal: Function.Injective ⇑(NonUnitalStarSubalgebra.unitization s)

full_name: NonUnitalStarSubalgebra.unitizationStarAlgEquiv_apply_coe
code: /-- If a `NonUnitalStarSubalgebra` over a field does not contain `1`, then its unitization is
isomorphic to its `StarAlgebra.adjoin`. -/
@[simps! apply_coe]
noncomputable def unitizationStarAlgEquiv (h1 : (1 : A) ∉ s) :
    Unitization R s ≃⋆ₐ[R] StarAlgebra.adjoin R (s : Set A) 
goal: ↑((NonUnitalStarSubalgebra.unitizationStarAlgEquiv s h1) a) = (algebraMap R A) a.fst + ↑a.snd

full_name: NonUnitalStarSubalgebra.unitizationStarAlgEquiv
code: /-- If a `NonUnitalStarSubalgebra` over a field does not contain `1`, then its unitization is
isomorphic to its `StarAlgebra.adjoin`. -/
@[simps! apply_coe]
noncomputable def unitizationStarAlgEquiv (h1 : (1 : A) ∉ s) :
    Unitization R s ≃⋆ₐ[R] StarAlgebra.adjoin R (s : Set A) 
goal: Unitization R ↥s ≃⋆ₐ[R] ↥(StarAlgebra.adjoin R ↑s)