Morphisms of star algebras #
THIS FILE IS SYNCHRONIZED WITH MATHLIB4. Any changes to this file require a corresponding PR to mathlib4.
This file defines morphisms between R
-algebras (unital or non-unital) A
and B
where both
A
and B
are equipped with a star
operation. These morphisms, namely star_alg_hom
and
non_unital_star_alg_hom
are direct extensions of their non-star
red counterparts with a field
map_star
which guarantees they preserve the star operation. We keep the type classes as generic
as possible, in keeping with the definition of non_unital_alg_hom
in the non-unital case. In this
file, we only assume has_star
unless we want to talk about the zero map as a
non_unital_star_alg_hom
, in which case we need star_add_monoid
. Note that the scalar ring R
is not required to have a star operation, nor do we need star_ring
or star_module
structures on
A
and B
.
As with non_unital_alg_hom
, in the non-unital case the multiplications are not assumed to be
associative or unital, or even to be compatible with the scalar actions. In a typical application,
the operations will satisfy compatibility conditions making them into algebras (albeit possibly
non-associative and/or non-unital) but such conditions are not required here for the definitions.
The primary impetus for defining these types is that they constitute the morphisms in the categories
of unital C⋆-algebras (with star_alg_hom
s) and of C⋆-algebras (with non_unital_star_alg_hom
s).
TODO: add star_alg_equiv
.
Main definitions #
Tags #
non-unital, algebra, morphism, star
Non-unital star algebra homomorphisms #
- to_fun : A → B
- map_smul' : ∀ (m : R) (x : A), self.to_fun (m • x) = m • self.to_fun x
- map_zero' : self.to_fun 0 = 0
- map_add' : ∀ (x y : A), self.to_fun (x + y) = self.to_fun x + self.to_fun y
- map_mul' : ∀ (x y : A), self.to_fun (x * y) = self.to_fun x * self.to_fun y
- map_star' : ∀ (a : A), self.to_fun (has_star.star a) = has_star.star (self.to_fun a)
A non-unital ⋆-algebra homomorphism is a non-unital algebra homomorphism between
non-unital R
-algebras A
and B
equipped with a star
operation, and this homomorphism is
also star
-preserving.
Instances for non_unital_star_alg_hom
- non_unital_star_alg_hom.has_sizeof_inst
- non_unital_star_alg_hom_class.non_unital_star_alg_hom.has_coe_t
- non_unital_star_alg_hom.non_unital_star_alg_hom_class
- non_unital_star_alg_hom.has_coe_to_fun
- non_unital_star_alg_hom.monoid
- non_unital_star_alg_hom.has_zero
- non_unital_star_alg_hom.inhabited
- non_unital_star_alg_hom.monoid_with_zero
Reinterpret a non-unital star algebra homomorphism as a non-unital algebra homomorphism by forgetting the interaction with the star operation.
- coe : F → Π (a : A), (λ (_x : A), B) a
- coe_injective' : function.injective non_unital_star_alg_hom_class.coe
- map_smul : ∀ (f : F) (c : R) (x : A), ⇑f (c • x) = c • ⇑f x
- map_add : ∀ (f : F) (x y : A), ⇑f (x + y) = ⇑f x + ⇑f y
- map_zero : ∀ (f : F), ⇑f 0 = 0
- map_mul : ∀ (f : F) (x y : A), ⇑f (x * y) = ⇑f x * ⇑f y
- map_star : ∀ (f : F) (r : A), ⇑f (has_star.star r) = has_star.star (⇑f r)
non_unital_star_alg_hom_class F R A B
asserts F
is a type of bundled non-unital ⋆-algebra
homomorphisms from A
to B
.
Instances of this typeclass
Instances of other typeclasses for non_unital_star_alg_hom_class
- non_unital_star_alg_hom_class.has_sizeof_inst
Equations
- non_unital_star_alg_hom.non_unital_star_alg_hom_class = {coe := non_unital_star_alg_hom.to_fun _inst_7, coe_injective' := _, map_smul := _, map_add := _, map_zero := _, map_mul := _, map_star := _}
Helper instance for when there's too many metavariables to apply fun_like.has_coe_to_fun
directly.
Copy of a non_unital_star_alg_hom
with a new to_fun
equal to the old one. Useful
to fix definitional equalities.
The identity as a non-unital ⋆-algebra homomorphism.
The composition of non-unital ⋆-algebra homomorphisms, as a non-unital ⋆-algebra homomorphism.
Equations
- non_unital_star_alg_hom.monoid = {mul := non_unital_star_alg_hom.comp _inst_4, mul_assoc := _, one := non_unital_star_alg_hom.id R A _inst_4, one_mul := _, mul_one := _, npow := npow_rec (mul_one_class.to_has_mul (A →⋆ₙₐ[R] A)), npow_zero' := _, npow_succ' := _}
Equations
Equations
- non_unital_star_alg_hom.monoid_with_zero = {mul := monoid.mul non_unital_star_alg_hom.monoid, mul_assoc := _, one := monoid.one non_unital_star_alg_hom.monoid, one_mul := _, mul_one := _, npow := monoid.npow non_unital_star_alg_hom.monoid, npow_zero' := _, npow_succ' := _, zero := 0, zero_mul := _, mul_zero := _}
Unital star algebra homomorphisms #
Reinterpret a unital star algebra homomorphism as a unital algebra homomorphism by forgetting the interaction with the star operation.
- to_fun : A → B
- map_one' : self.to_fun 1 = 1
- map_mul' : ∀ (x y : A), self.to_fun (x * y) = self.to_fun x * self.to_fun y
- map_zero' : self.to_fun 0 = 0
- map_add' : ∀ (x y : A), self.to_fun (x + y) = self.to_fun x + self.to_fun y
- commutes' : ∀ (r : R), self.to_fun (⇑(algebra_map R A) r) = ⇑(algebra_map R B) r
- map_star' : ∀ (x : A), self.to_fun (has_star.star x) = has_star.star (self.to_fun x)
A ⋆-algebra homomorphism is an algebra homomorphism between R
-algebras A
and B
equipped with a star
operation, and this homomorphism is also star
-preserving.
Instances for star_alg_hom
- coe : F → Π (a : A), (λ (_x : A), B) a
- coe_injective' : function.injective star_alg_hom_class.coe
- map_mul : ∀ (f : F) (x y : A), ⇑f (x * y) = ⇑f x * ⇑f y
- map_one : ∀ (f : F), ⇑f 1 = 1
- map_add : ∀ (f : F) (x y : A), ⇑f (x + y) = ⇑f x + ⇑f y
- map_zero : ∀ (f : F), ⇑f 0 = 0
- commutes : ∀ (f : F) (r : R), ⇑f (⇑(algebra_map R A) r) = ⇑(algebra_map R B) r
- map_star : ∀ (f : F) (r : A), ⇑f (has_star.star r) = has_star.star (⇑f r)
star_alg_hom_class F R A B
states that F
is a type of ⋆-algebra homomorphisms.
You should also extend this typeclass when you extend star_alg_hom
.
Instances of this typeclass
Instances of other typeclasses for star_alg_hom_class
- star_alg_hom_class.has_sizeof_inst
Equations
- star_alg_hom_class.to_non_unital_star_alg_hom_class F R A B = {coe := alg_hom_class.coe (star_alg_hom_class.to_alg_hom_class F R A B), coe_injective' := _, map_smul := _, map_add := _, map_zero := _, map_mul := _, map_star := _}
Helper instance for when there's too many metavariables to apply fun_like.has_coe_to_fun
directly.
Copy of a star_alg_hom
with a new to_fun
equal to the old one. Useful
to fix definitional equalities.
The identity as a star_alg_hom
.
Equations
- star_alg_hom.inhabited = {default := star_alg_hom.id R A _inst_4}
The composition of ⋆-algebra homomorphisms, as a ⋆-algebra homomorphism.
Equations
- star_alg_hom.monoid = {mul := star_alg_hom.comp _inst_4, mul_assoc := _, one := star_alg_hom.id R A _inst_4, one_mul := _, mul_one := _, npow := npow_rec (mul_one_class.to_has_mul (A →⋆ₐ[R] A)), npow_zero' := _, npow_succ' := _}
A unital morphism of ⋆-algebras is a non_unital_star_alg_hom
.
Operations on the product type #
Note that this is copied from algebra/hom/non_unital_alg
.
The first projection of a product is a non-unital ⋆-algebra homomoprhism.
The second projection of a product is a non-unital ⋆-algebra homomorphism.
The pi.prod
of two morphisms is a morphism.
Taking the product of two maps with the same domain is equivalent to taking the product of their codomains.
The left injection into a product is a non-unital algebra homomorphism.
Equations
- non_unital_star_alg_hom.inl R A B = 1.prod 0
The right injection into a product is a non-unital algebra homomorphism.
Equations
- non_unital_star_alg_hom.inr R A B = 0.prod 1
Taking the product of two maps with the same domain is equivalent to taking the product of their codomains.
Star algebra equivalences #
- to_fun : A → B
- inv_fun : B → A
- left_inv : function.left_inverse self.inv_fun self.to_fun
- right_inv : function.right_inverse self.inv_fun self.to_fun
- map_mul' : ∀ (x y : A), self.to_fun (x * y) = self.to_fun x * self.to_fun y
- map_add' : ∀ (x y : A), self.to_fun (x + y) = self.to_fun x + self.to_fun y
- map_star' : ∀ (a : A), self.to_fun (has_star.star a) = has_star.star (self.to_fun a)
- map_smul' : ∀ (r : R) (a : A), self.to_fun (r • a) = r • self.to_fun a
A ⋆-algebra equivalence is an equivalence preserving addition, multiplication, scalar
multiplication and the star operation, which allows for considering both unital and non-unital
equivalences with a single structure. Currently, alg_equiv
requires unital algebras, which is
why this structure does not extend it.
Instances for star_alg_equiv
- star_alg_equiv.has_sizeof_inst
- star_alg_equiv.star_alg_equiv_class
- star_alg_equiv.has_coe_to_fun
- star_alg_equiv.inhabited
Reinterpret a star algebra equivalence as a ring_equiv
by forgetting the interaction with
the star operation and scalar multiplication.
- coe : F → A → B
- inv : F → B → A
- left_inv : ∀ (e : F), function.left_inverse (star_alg_equiv_class.inv e) (star_alg_equiv_class.coe e)
- right_inv : ∀ (e : F), function.right_inverse (star_alg_equiv_class.inv e) (star_alg_equiv_class.coe e)
- coe_injective' : ∀ (e g : F), star_alg_equiv_class.coe e = star_alg_equiv_class.coe g → star_alg_equiv_class.inv e = star_alg_equiv_class.inv g → e = g
- map_mul : ∀ (f : F) (a b : A), ⇑f (a * b) = ⇑f a * ⇑f b
- map_add : ∀ (f : F) (a b : A), ⇑f (a + b) = ⇑f a + ⇑f b
- map_star : ∀ (f : F) (a : A), ⇑f (has_star.star a) = has_star.star (⇑f a)
- map_smul : ∀ (f : F) (r : R) (a : A), ⇑f (r • a) = r • ⇑f a
star_alg_equiv_class F R A B
asserts F
is a type of bundled ⋆-algebra equivalences between
A
and B
.
You should also extend this typeclass when you extend star_alg_equiv
.
Instances of this typeclass
Instances of other typeclasses for star_alg_equiv_class
- star_alg_equiv_class.has_sizeof_inst
Equations
- star_alg_equiv_class.star_hom_class = {coe := λ (f : F), ⇑f, coe_injective' := _, map_star := _}
Equations
- star_alg_equiv_class.smul_hom_class = {coe := λ (f : F), ⇑f, coe_injective' := _, map_smul := _}
Equations
- star_alg_equiv.star_alg_equiv_class = {coe := star_alg_equiv.to_fun _inst_8, inv := star_alg_equiv.inv_fun _inst_8, left_inv := _, right_inv := _, coe_injective' := _, map_mul := _, map_add := _, map_star := _, map_smul := _}
Helper instance for when there's too many metavariables to apply
fun_like.has_coe_to_fun
directly.
Equations
- star_alg_equiv.has_coe_to_fun = {coe := star_alg_equiv.to_fun _inst_8}
Star algebra equivalences are reflexive.
Equations
- star_alg_equiv.refl = {to_fun := (ring_equiv.refl A).to_fun, inv_fun := (ring_equiv.refl A).inv_fun, left_inv := _, right_inv := _, map_mul' := _, map_add' := _, map_star' := _, map_smul' := _}
Star algebra equivalences are transitive.
Equations
- e₁.trans e₂ = {to_fun := (e₁.to_ring_equiv.trans e₂.to_ring_equiv).to_fun, inv_fun := (e₁.to_ring_equiv.trans e₂.to_ring_equiv).inv_fun, left_inv := _, right_inv := _, map_mul' := _, map_add' := _, map_star' := _, map_smul' := _}
If a (unital or non-unital) star algebra morphism has an inverse, it is an isomorphism of star algebras.
Promote a bijective star algebra homomorphism to a star algebra equivalence.