Loogle!
Result
Found 854 declarations mentioning Star.star. Of these, only the first 200 are shown.
- Star.star π Mathlib.Algebra.Notation.Defs
{R : Type u} [self : Star R] : R β R - Pi.star_apply π Mathlib.Algebra.Notation.Pi.Defs
{ΞΉ : Type u_1} {R : ΞΉ β Type u_6} [(i : ΞΉ) β Star (R i)] (x : (i : ΞΉ) β R i) (i : ΞΉ) : star x i = star (x i) - Pi.star_def π Mathlib.Algebra.Notation.Pi.Defs
{ΞΉ : Type u_1} {R : ΞΉ β Type u_6} [(i : ΞΉ) β Star (R i)] (x : (i : ΞΉ) β R i) : star x = fun i => star (x i) - Prod.fst_star π Mathlib.Algebra.Notation.Prod
{R : Type u_5} {S : Type u_6} [Star R] [Star S] (x : R Γ S) : (star x).1 = star x.1 - Prod.snd_star π Mathlib.Algebra.Notation.Prod
{R : Type u_5} {S : Type u_6} [Star R] [Star S] (x : R Γ S) : (star x).2 = star x.2 - Prod.star_def π Mathlib.Algebra.Notation.Prod
{R : Type u_5} {S : Type u_6} [Star R] [Star S] (x : R Γ S) : star x = (star x.1, star x.2) - Filter.EventuallyEq.fun_star π Mathlib.Order.Filter.Basic
{Ξ± : Type u} {R : Type u_2} [Star R] {f g : Ξ± β R} {l : Filter Ξ±} (h : f =αΆ [l] g) : (fun i => star (f i)) =αΆ [l] fun i => star (g i) - Filter.EventuallyEq.star π Mathlib.Order.Filter.Basic
{Ξ± : Type u} {R : Type u_2} [Star R] {f g : Ξ± β R} {l : Filter Ξ±} (h : f =αΆ [l] g) : star f =αΆ [l] star g - InvolutiveStar.mk π Mathlib.Algebra.Star.Basic
{R : Type u} [toStar : Star R] (star_involutive : Function.Involutive star) : InvolutiveStar R - InvolutiveStar.star_involutive π Mathlib.Algebra.Star.Basic
{R : Type u} [self : InvolutiveStar R] : Function.Involutive star - star_injective π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] : Function.Injective star - TrivialStar.mk π Mathlib.Algebra.Star.Basic
{R : Type u} [Star R] (star_trivial : β (r : R), star r = r) : TrivialStar R - TrivialStar.star_trivial π Mathlib.Algebra.Star.Basic
{R : Type u} {instβ : Star R} [self : TrivialStar R] (r : R) : star r = r - star_star π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] (r : R) : star (star r) = r - MulOpposite.op_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Star R] (r : R) : MulOpposite.op (star r) = star (MulOpposite.op r) - MulOpposite.unop_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Star R] (r : Rα΅α΅α΅) : MulOpposite.unop (star r) = star (MulOpposite.unop r) - eq_star_of_eq_star π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] {r s : R} (h : r = star s) : s = star r - IsLeftRegular.star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x : R} (hx : IsLeftRegular x) : IsRightRegular (star x) - IsRegular.star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x : R} (hx : IsRegular x) : IsRegular (star x) - IsRightRegular.star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x : R} (hx : IsRightRegular x) : IsLeftRegular (star x) - eq_star_iff_eq_star π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] {r s : R} : r = star s β s = star r - isLeftRegular_star_iff π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x : R} : IsLeftRegular (star x) β IsRightRegular x - isRegular_star_iff π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x : R} : IsRegular (star x) β IsRegular x - isRightRegular_star_iff π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x : R} : IsRightRegular (star x) β IsLeftRegular x - star_eq_iff_star_eq π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] {r s : R} : star r = s β star s = r - star_inj π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] {x y : R} : star x = star y β x = y - star_id_of_comm π Mathlib.Algebra.Star.Basic
{R : Type u_1} [CommMonoid R] {x : R} : star x = x - Function.Injective.involutiveStar π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type v} (f : R β S) [Star R] [InvolutiveStar S] (hf : Function.Injective f) (star : β (x : R), f (star x) = star (f x)) : InvolutiveStar R - Equiv.Perm.star_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [InvolutiveStar R] (aβ : R) : Equiv.Perm.star aβ = star aβ - Commute.star_left π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y : R} : Commute x (star y) β Commute (star x) y - Commute.star_right π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y : R} : Commute (star x) y β Commute x (star y) - Commute.star_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y : R} : Commute x y β Commute (star x) (star y) - commute_star_comm π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y : R} : Commute (star x) y β Commute x (star y) - commute_star_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y : R} : Commute (star x) (star y) β Commute x y - IsUnit.star π Mathlib.Algebra.Star.Basic
{R : Type u} [Monoid R] [StarMul R] {a : R} : IsUnit a β IsUnit (star a) - StarMemClass.mk π Mathlib.Algebra.Star.Basic
{S : Type u_1} {R : Type u_2} [Star R] [SetLike S R] (star_mem : β {s : S} {r : R}, r β s β star r β s) : StarMemClass S R - StarMemClass.star_mem π Mathlib.Algebra.Star.Basic
{S : Type u_1} {R : Type u_2} {instβ : Star R} {instβΒΉ : SetLike S R} [self : StarMemClass S R] {s : S} {r : R} : r β s β star r β s - isUnit_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Monoid R] [StarMul R] {a : R} : IsUnit (star a) β IsUnit a - mem_of_star_mem π Mathlib.Algebra.Star.Basic
{S : Type u_1} {R : Type u_2} [InvolutiveStar R] [SetLike S R] [StarMemClass S R] {s : S} {r : R} (hr : star r β s) : r β s - star_mem_iff π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type u_1} [SetLike S R] [InvolutiveStar R] [StarMemClass S R] {s : S} {x : R} : star x β s β x β s - star_zero π Mathlib.Algebra.Star.Basic
(R : Type u) [AddMonoid R] [StarAddMonoid R] : star 0 = 0 - star_one π Mathlib.Algebra.Star.Basic
(R : Type u) [MulOneClass R] [StarMul R] : star 1 = 1 - SemiconjBy.star_star_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y z : R} : SemiconjBy x y z β SemiconjBy (star x) (star z) (star y) - StarMul.mk π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [toInvolutiveStar : InvolutiveStar R] (star_mul : β (r s : R), star (r * s) = star s * star r) : StarMul R - semiconjBy_star_star_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] {x y z : R} : SemiconjBy (star x) (star z) (star y) β SemiconjBy x y z - star_eq_zero π Mathlib.Algebra.Star.Basic
{R : Type u} [AddMonoid R] [StarAddMonoid R] {x : R} : star x = 0 β x = 0 - star_ne_zero π Mathlib.Algebra.Star.Basic
{R : Type u} [AddMonoid R] [StarAddMonoid R] {x : R} : star x β 0 β x β 0 - StarHomClass.map_star π Mathlib.Algebra.Star.Basic
{F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {instβ : Star R} {instβΒΉ : Star S} {instβΒ² : FunLike F R S} [self : StarHomClass F R S] (f : F) (r : R) : f (star r) = star (f r) - StarHomClass.mk π Mathlib.Algebra.Star.Basic
{F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} [Star R] [Star S] [FunLike F R S] (map_star : β (f : F) (r : R), f (star r) = star (f r)) : StarHomClass F R S - StarModule.mk π Mathlib.Algebra.Star.Basic
{R : Type u} {A : Type v} [Star R] [Star A] [SMul R A] (star_smul : β (r : R) (a : A), star (r β’ a) = star r β’ star a) : StarModule R A - StarModule.star_smul π Mathlib.Algebra.Star.Basic
{R : Type u} {A : Type v} {instβ : Star R} {instβΒΉ : Star A} {instβΒ² : SMul R A} [self : StarModule R A] (r : R) (a : A) : star (r β’ a) = star r β’ star a - Invertible.star π Mathlib.Algebra.Star.Basic
{R : Type u_1} [MulOneClass R] [StarMul R] (r : R) [Invertible r] : Invertible (star r) - star_natCast π Mathlib.Algebra.Star.Basic
{R : Type u} [NonAssocSemiring R] [StarRing R] (n : β) : star βn = βn - star_mul_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] (x y : R) : star (x * star y) = y * star x - star_star_mul π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] (x y : R) : star (star x * y) = star y * x - StarMul.star_mul π Mathlib.Algebra.Star.Basic
{R : Type u} {instβ : Mul R} [self : StarMul R] (r s : R) : star (r * s) = star s * star r - StarAddMonoid.mk π Mathlib.Algebra.Star.Basic
{R : Type u} [AddMonoid R] [toInvolutiveStar : InvolutiveStar R] (star_add : β (r s : R), star (r + s) = star r + star s) : StarAddMonoid R - star_nsmul π Mathlib.Algebra.Star.Basic
{R : Type u} [AddMonoid R] [StarAddMonoid R] (n : β) (x : R) : star (n β’ x) = n β’ star x - star_intCast π Mathlib.Algebra.Star.Basic
{R : Type u} [NonAssocRing R] [StarRing R] (z : β€) : star βz = βz - Units.coe_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Monoid R] [StarMul R] (u : RΛ£) : β(star u) = star βu - starMulEquiv_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [Mul R] [StarMul R] (x : R) : starMulEquiv x = MulOpposite.op (star x) - StarAddMonoid.star_add π Mathlib.Algebra.Star.Basic
{R : Type u} {instβ : AddMonoid R} [self : StarAddMonoid R] (r s : R) : star (r + s) = star r + star s - star_neg π Mathlib.Algebra.Star.Basic
{R : Type u} [AddGroup R] [StarAddMonoid R] (r : R) : star (-r) = -star r - star_ofNat π Mathlib.Algebra.Star.Basic
{R : Type u} [NonAssocSemiring R] [StarRing R] (n : β) [n.AtLeastTwo] : star (OfNat.ofNat n) = OfNat.ofNat n - Function.Injective.starMul π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type v} (f : R β S) [Star R] [Mul R] [Mul S] [StarMul S] (hf : Function.Injective f) (star : β (x : R), f (star x) = star (f x)) (mul : β (x y : R), f (x * y) = f x * f y) : StarMul R - star_mul' π Mathlib.Algebra.Star.Basic
{R : Type u} [CommMagma R] [StarMul R] (x y : R) : star (x * y) = star x * star y - starAddEquiv_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [AddMonoid R] [StarAddMonoid R] (aβ : R) : starAddEquiv aβ = star aβ - star_zsmul π Mathlib.Algebra.Star.Basic
{R : Type u} [AddGroup R] [StarAddMonoid R] (n : β€) (x : R) : star (n β’ x) = n β’ star x - Ring.inverse_star π Mathlib.Algebra.Star.Basic
{R : Type u} [Semiring R] [StarRing R] (a : R) : Ring.inverse (star a) = star (Ring.inverse a) - Function.Injective.starAddMonoid π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type v} (f : R β S) [Star R] [AddMonoid R] [AddMonoid S] [StarAddMonoid S] (hf : Function.Injective f) (star : β (x : R), f (star x) = star (f x)) (add : β (x y : R), f (x + y) = f x + f y) : StarAddMonoid R - star_pow π Mathlib.Algebra.Star.Basic
{R : Type u} [Monoid R] [StarMul R] (x : R) (n : β) : star (x ^ n) = star x ^ n - Units.coe_star_inv π Mathlib.Algebra.Star.Basic
{R : Type u} [Monoid R] [StarMul R] (u : RΛ£) : β(star u)β»ΒΉ = star βuβ»ΒΉ - Function.Injective.starModule π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type v} (f : R β S) (π : Type u_1) [Star π] [SMul π R] [Star R] [SMul π S] [Star S] [StarModule π S] (hf : Function.Injective f) (star : β (x : R), f (star x) = star (f x)) (smul : β (r : π) (x : R), f (r β’ x) = r β’ f x) : StarModule π R - star_invβ π Mathlib.Algebra.Star.Basic
{R : Type u} [GroupWithZero R] [StarMul R] (x : R) : star xβ»ΒΉ = (star x)β»ΒΉ - star_sub π Mathlib.Algebra.Star.Basic
{R : Type u} [AddGroup R] [StarAddMonoid R] (r s : R) : star (r - s) = star r - star s - StarMemClass.coe_star π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type w} [Star R] [SetLike S R] [hS : StarMemClass S R] (s : S) (x : β₯s) : β(star x) = star βx - starMulAut_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [CommSemigroup R] [StarMul R] (aβ : R) : starMulAut aβ = star aβ - starRingEnd_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [CommSemiring R] [StarRing R] (x : R) : (starRingEnd R) x = star x - star_inv π Mathlib.Algebra.Star.Basic
{R : Type u} [Group R] [StarMul R] (x : R) : star xβ»ΒΉ = (star x)β»ΒΉ - StarRing.mk π Mathlib.Algebra.Star.Basic
{R : Type u} [NonUnitalNonAssocSemiring R] [toStarMul : StarMul R] (star_add : β (r s : R), star (r + s) = star r + star s) : StarRing R - RingHom.star_def π Mathlib.Algebra.Star.Basic
{R : Type u} [CommSemiring R] [StarRing R] {S : Type u_1} [NonAssocSemiring S] (f : S β+* R) : star f = (starRingEnd R).comp f - StarRing.star_add π Mathlib.Algebra.Star.Basic
{R : Type u} {instβ : NonUnitalNonAssocSemiring R} [self : StarRing R] (r s : R) : star (r + s) = star r + star s - star_zpowβ π Mathlib.Algebra.Star.Basic
{R : Type u} [GroupWithZero R] [StarMul R] (x : R) (z : β€) : star (x ^ z) = star x ^ z - star_zpow π Mathlib.Algebra.Star.Basic
{R : Type u} [Group R] [StarMul R] (x : R) (z : β€) : star (x ^ z) = star x ^ z - Pi.star_single π Mathlib.Algebra.Star.Basic
{ΞΉ : Type u_1} {R : ΞΉ β Type u_2} [DecidableEq ΞΉ] [(i : ΞΉ) β AddMonoid (R i)] [(i : ΞΉ) β StarAddMonoid (R i)] (i : ΞΉ) (r : R i) : star (Pi.single i r) = Pi.single i (star r) - Pi.star_mulSingle π Mathlib.Algebra.Star.Basic
{ΞΉ : Type u_1} {R : ΞΉ β Type u_2} [DecidableEq ΞΉ] [(i : ΞΉ) β MulOneClass (R i)] [(i : ΞΉ) β StarMul (R i)] (i : ΞΉ) (r : R i) : star (Pi.mulSingle i r) = Pi.mulSingle i (star r) - star_divβ π Mathlib.Algebra.Star.Basic
{R : Type u} [CommGroupWithZero R] [StarMul R] (x y : R) : star (x / y) = star x / star y - Function.Injective.starRing π Mathlib.Algebra.Star.Basic
{R : Type u} {S : Type v} (f : R β S) [Star R] [NonUnitalNonAssocSemiring R] [NonUnitalNonAssocSemiring S] [StarRing S] (hf : Function.Injective f) (star : β (x : R), f (star x) = star (f x)) (add : β (x y : R), f (x + y) = f x + f y) (mul : β (x y : R), f (x * y) = f x * f y) : StarRing R - star_div π Mathlib.Algebra.Star.Basic
{R : Type u} [CommGroup R] [StarMul R] (x y : R) : star (x / y) = star x / star y - starRingEquiv_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [NonUnitalNonAssocSemiring R] [StarRing R] (x : R) : starRingEquiv x = MulOpposite.op (star x) - star_invOf π Mathlib.Algebra.Star.Basic
{R : Type u_1} [Monoid R] [StarMul R] (r : R) [Invertible r] [Invertible (star r)] : star β r = β (star r) - RingHom.star_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [CommSemiring R] [StarRing R] {S : Type u_1} [NonAssocSemiring S] (f : S β+* R) (s : S) : (star f) s = star (f s) - starRingAut_apply π Mathlib.Algebra.Star.Basic
{R : Type u} [CommSemiring R] [StarRing R] (aβ : R) : starRingAut aβ = star aβ - star_nnratCast π Mathlib.Algebra.Star.Rat
{R : Type u_1} [DivisionSemiring R] [StarRing R] (q : ββ₯0) : star βq = βq - star_ratCast π Mathlib.Algebra.Star.Rat
{R : Type u_1} [DivisionRing R] [StarRing R] (r : β) : star βr = βr - IsSelfAdjoint.star_eq π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Star R] {x : R} (hx : IsSelfAdjoint x) : star x = x - isSelfAdjoint_iff π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Star R] {x : R} : IsSelfAdjoint x β star x = x - IsStarNormal.mk π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Mul R] [Star R] {x : R} (star_comm_self : Commute (star x) x) : IsStarNormal x - IsStarNormal.star_comm_self π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} {instβ : Mul R} {instβΒΉ : Star R} {x : R} [self : IsStarNormal x] : Commute (star x) x - isStarNormal_iff π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Mul R] [Star R] (x : R) : IsStarNormal x β Commute (star x) x - IsSelfAdjoint.star_iff π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [InvolutiveStar R] {x : R} : IsSelfAdjoint (star x) β IsSelfAdjoint x - IsSelfAdjoint.mul_star_self π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Mul R] [StarMul R] (x : R) : IsSelfAdjoint (x * star x) - IsSelfAdjoint.star_mul_self π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Mul R] [StarMul R] (x : R) : IsSelfAdjoint (star x * x) - IsStarNormal.star π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Mul R] [StarMul R] {x : R} [IsStarNormal x] : IsStarNormal (star x) - star_comm_self' π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Mul R] [Star R] (x : R) [IsStarNormal x] : star x * x = x * star x - IsSelfAdjoint.add_star_self π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [AddCommMonoid R] [StarAddMonoid R] (x : R) : IsSelfAdjoint (x + star x) - IsSelfAdjoint.star_add_self π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [AddCommMonoid R] [StarAddMonoid R] (x : R) : IsSelfAdjoint (star x + x) - selfAdjoint.mem_iff π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [AddGroup R] [StarAddMonoid R] {x : R} : x β selfAdjoint R β star x = x - IsSelfAdjoint.conjugate π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Semigroup R] [StarMul R] {x : R} (hx : IsSelfAdjoint x) (z : R) : IsSelfAdjoint (z * x * star z) - IsSelfAdjoint.conjugate' π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Semigroup R] [StarMul R] {x : R} (hx : IsSelfAdjoint x) (z : R) : IsSelfAdjoint (star z * x * z) - skewAdjoint.mem_iff π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [AddCommGroup R] [StarAddMonoid R] {x : R} : x β skewAdjoint R β star x = -x - selfAdjoint.star_val_eq π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [AddGroup R] [StarAddMonoid R] {x : β₯(selfAdjoint R)} : star βx = βx - IsUnit.isSelfAdjoint_conjugate_iff π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Monoid R] [StarMul R] {a u : R} (hu : IsUnit u) : IsSelfAdjoint (u * a * star u) β IsSelfAdjoint a - IsUnit.isSelfAdjoint_conjugate_iff' π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Monoid R] [StarMul R] {a u : R} (hu : IsUnit u) : IsSelfAdjoint (star u * a * u) β IsSelfAdjoint a - Commute.isStarNormal_add π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [NonUnitalNonAssocSemiring R] [StarRing R] {a b : R} (hab : Commute a (star b)) [ha : IsStarNormal a] [hb : IsStarNormal b] : IsStarNormal (a + b) - skewAdjoint.star_val_eq π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [AddCommGroup R] [StarAddMonoid R] {x : β₯(skewAdjoint R)} : star βx = -βx - Commute.isStarNormal_sub π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [NonUnitalNonAssocRing R] [StarRing R] {a b : R} (hab : Commute a (star b)) [ha : IsStarNormal a] [hb : IsStarNormal b] : IsStarNormal (a - b) - skewAdjoint.conjugate π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Ring R] [StarRing R] {x : R} (hx : x β skewAdjoint R) (z : R) : z * x * star z β skewAdjoint R - skewAdjoint.conjugate' π Mathlib.Algebra.Star.SelfAdjoint
{R : Type u_1} [Ring R] [StarRing R] {x : R} (hx : x β skewAdjoint R) (z : R) : star z * x * z β skewAdjoint R - star_sum π Mathlib.Algebra.Star.BigOperators
{R : Type u_1} [AddCommMonoid R] [StarAddMonoid R] {Ξ± : Type u_2} (s : Finset Ξ±) (f : Ξ± β R) : star (β x β s, f x) = β x β s, star (f x) - star_prod π Mathlib.Algebra.Star.BigOperators
{R : Type u_1} [CommMonoid R] [StarMul R] {Ξ± : Type u_2} (s : Finset Ξ±) (f : Ξ± β R) : star (β x β s, f x) = β x β s, star (f x) - star_finsuppSum π Mathlib.Algebra.Star.BigOperators
{R : Type u_1} {ΞΉ : Type u_2} {M : Type u_3} [Zero M] [AddCommMonoid R] [StarAddMonoid R] (s : ΞΉ ββ M) (f : ΞΉ β M β R) : star (s.sum f) = s.sum fun i m => star f i m - star_finsuppProd π Mathlib.Algebra.Star.BigOperators
{R : Type u_1} {ΞΉ : Type u_2} {M : Type u_3} [Zero M] [CommMonoid R] [StarMul R] (s : ΞΉ ββ M) (f : ΞΉ β M β R) : star (s.prod f) = s.prod fun i m => star f i m - IsIdempotentElem.star π Mathlib.Algebra.Star.Module
{R : Type u_1} [Mul R] [StarMul R] {a : R} : IsIdempotentElem a β IsIdempotentElem (star a) - IsIdempotentElem.star_iff π Mathlib.Algebra.Star.Module
{R : Type u_1} [Mul R] [StarMul R] {a : R} : IsIdempotentElem (star a) β IsIdempotentElem a - star_nnqsmul π Mathlib.Algebra.Star.Module
{R : Type u_1} [AddCommMonoid R] [StarAddMonoid R] [Module ββ₯0 R] (q : ββ₯0) (x : R) : star (q β’ x) = q β’ star x - star_nnrat_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} [AddCommMonoid R] [StarAddMonoid R] [Module ββ₯0 R] (q : ββ₯0) (x : R) : star (q β’ x) = q β’ star x - star_natCast_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} {M : Type u_2} [Semiring R] [AddCommMonoid M] [Module R M] [StarAddMonoid M] (n : β) (x : M) : star (βn β’ x) = βn β’ star x - star_qsmul π Mathlib.Algebra.Star.Module
{R : Type u_1} [AddCommGroup R] [StarAddMonoid R] [Module β R] (q : β) (x : R) : star (q β’ x) = q β’ star x - star_rat_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} [AddCommGroup R] [StarAddMonoid R] [Module β R] (q : β) (x : R) : star (q β’ x) = q β’ star x - algebraMap_star_comm π Mathlib.Algebra.Star.Module
{R : Type u_1} {A : Type u_2} [CommSemiring R] [StarRing R] [Semiring A] [StarMul A] [Algebra R A] [StarModule R A] (r : R) : (algebraMap R A) (star r) = star ((algebraMap R A) r) - star_inv_natCast_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} {M : Type u_2} [DivisionSemiring R] [AddCommMonoid M] [Module R M] [StarAddMonoid M] (n : β) (x : M) : star ((βn)β»ΒΉ β’ x) = (βn)β»ΒΉ β’ star x - star_intCast_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} {M : Type u_2} [Ring R] [AddCommGroup M] [Module R M] [StarAddMonoid M] (n : β€) (x : M) : star (βn β’ x) = βn β’ star x - star_ratCast_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} {M : Type u_2} [DivisionRing R] [AddCommGroup M] [Module R M] [StarAddMonoid M] (n : β) (x : M) : star (βn β’ x) = βn β’ star x - starLinearEquiv_apply π Mathlib.Algebra.Star.Module
(R : Type u_1) {A : Type u_2} [CommSemiring R] [StarRing R] [AddCommMonoid A] [StarAddMonoid A] [Module R A] [StarModule R A] (aβ : A) : (starLinearEquiv R) aβ = star aβ - star_inv_intCast_smul π Mathlib.Algebra.Star.Module
{R : Type u_1} {M : Type u_2} [DivisionRing R] [AddCommGroup M] [Module R M] [StarAddMonoid M] (n : β€) (x : M) : star ((βn)β»ΒΉ β’ x) = (βn)β»ΒΉ β’ star x - skewAdjointPart_apply_coe π Mathlib.Algebra.Star.Module
(R : Type u_1) {A : Type u_2} [Semiring R] [StarMul R] [TrivialStar R] [AddCommGroup A] [Module R A] [StarAddMonoid A] [StarModule R A] [Invertible 2] (x : A) : β((skewAdjointPart R) x) = β 2 β’ (x - star x) - selfAdjointPart_apply_coe π Mathlib.Algebra.Star.Module
(R : Type u_1) {A : Type u_2} [Semiring R] [StarMul R] [TrivialStar R] [AddCommGroup A] [Module R A] [StarAddMonoid A] [StarModule R A] [Invertible 2] (x : A) : β((selfAdjointPart R) x) = β 2 β’ (x + star x) - StarRingEquiv.mk π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (toRingEquiv : A β+* B) (map_star' : β (a : A), toRingEquiv.toFun (star a) = star (toRingEquiv.toFun a)) : A ββ+* B - StarRingEquivClass.map_star π Mathlib.Algebra.Star.StarRingHom
{F : Type u_1} {A : outParam (Type u_2)} {B : outParam (Type u_3)} {instβ : Add A} {instβΒΉ : Mul A} {instβΒ² : Star A} {instβΒ³ : Add B} {instββ΄ : Mul B} {instββ΅ : Star B} {instββΆ : EquivLike F A B} [self : StarRingEquivClass F A B] (f : F) (a : A) : f (star a) = star (f a) - NonUnitalStarRingHom.mk π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (toNonUnitalRingHom : A ββ+* B) (map_star' : β (a : A), toNonUnitalRingHom.toFun (star a) = star (toNonUnitalRingHom.toFun a)) : A βββ+* B - StarRingEquiv.map_star' π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (self : A ββ+* B) (a : A) : self.toFun (star a) = star (self.toFun a) - StarRingEquivClass.mk π Mathlib.Algebra.Star.StarRingHom
{F : Type u_1} {A : outParam (Type u_2)} {B : outParam (Type u_3)} [Add A] [Mul A] [Star A] [Add B] [Mul B] [Star B] [EquivLike F A B] [toRingEquivClass : RingEquivClass F A B] (map_star : β (f : F) (a : A), f (star a) = star (f a)) : StarRingEquivClass F A B - NonUnitalStarRingHom.map_star' π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (self : A βββ+* B) (a : A) : self.toFun (star a) = star (self.toFun a) - NonUnitalStarRingHom.coe_mk π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A ββ+* B) (h : β (a : A), f.toFun (star a) = star (f.toFun a)) : β{ toNonUnitalRingHom := f, map_star' := h } = βf - StarRingEquiv.coe_mk π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A β+* B) (hβ : β (a : A), e.toFun (star a) = star (e.toFun a)) : β{ toRingEquiv := e, map_star' := hβ } = βe - StarRingEquiv.symm_mk π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A β+* B) (hβ : β (a : A), e.toFun (star a) = star (e.toFun a)) : { toRingEquiv := e, map_star' := hβ }.symm = { toRingEquiv := e.symm, map_star' := β― } - StarRingEquiv.mk_coe π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [Add A] [Add B] [Mul A] [Mul B] [Star A] [Star B] (e : A ββ+* B) (e' : B β A) (hβ : Function.LeftInverse e' βe) (hβ : Function.RightInverse e' βe) (hβ : β (x y : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun (x * y) = { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun x * { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun y) (hβ : β (x y : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun (x + y) = { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun x + { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun y) (hβ : β (a : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ }.toFun (star a) = star ({ toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ }.toFun a)) : { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ, map_star' := hβ } = e - NonUnitalStarRingHom.mk_coe π Mathlib.Algebra.Star.StarRingHom
{A : Type u_1} {B : Type u_2} [NonUnitalNonAssocSemiring A] [Star A] [NonUnitalNonAssocSemiring B] [Star B] (f : A βββ+* B) (hβ : β (x y : A), f (x * y) = f x * f y) (hβ : { toFun := βf, map_mul' := hβ }.toFun 0 = 0) (hβ : β (x y : A), { toFun := βf, map_mul' := hβ }.toFun (x + y) = { toFun := βf, map_mul' := hβ }.toFun x + { toFun := βf, map_mul' := hβ }.toFun y) (hβ : β (a : A), { toFun := βf, map_mul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun (star a) = star ({ toFun := βf, map_mul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun a)) : { toFun := βf, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, map_star' := hβ } = f - StarAlgEquiv.toAlgEquiv_ofAlgEquiv π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_6} {A : Type u_7} {B : Type u_8} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] [Star A] [Star B] (f : A ββ[R] B) (map_star : β (x : A), f (star x) = star (f x)) : (StarAlgEquiv.ofAlgEquiv f map_star).toAlgEquiv = f - StarAlgEquiv.ofAlgEquiv π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_6} {A : Type u_7} {B : Type u_8} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] [Star A] [Star B] (f : A ββ[R] B) (map_star : β (x : A), f (star x) = star (f x)) : A βββ[R] B - StarAlgHom.mk π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B] (toAlgHom : A ββ[R] B) (map_star' : β (x : A), (ββtoAlgHom.toRingHom).toFun (star x) = star ((ββtoAlgHom.toRingHom).toFun x)) : A βββ[R] B - StarAlgHom.map_star' π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [CommSemiring R] [Semiring A] [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B] (self : A βββ[R] B) (x : A) : (ββ(βself).toRingHom).toFun (star x) = star ((ββ(βself).toRingHom).toFun x) - StarAlgEquiv.ofAlgEquiv_toAlgEquiv π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_6} {A : Type u_7} {B : Type u_8} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] [Star A] [Star B] (f : A βββ[R] B) (map_star : β (x : A), f.toAlgEquiv (star x) = star (f.toAlgEquiv x)) : StarAlgEquiv.ofAlgEquiv f.toAlgEquiv map_star = f - StarAlgEquiv.ofAlgEquiv_apply π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_6} {A : Type u_7} {B : Type u_8} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] [Star A] [Star B] (f : A ββ[R] B) (map_star : β (x : A), f (star x) = star (f x)) (x : A) : (StarAlgEquiv.ofAlgEquiv f map_star) x = f x - StarAlgHom.coe_mk' π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_2} {A : Type u_3} {B : Type u_4} [CommSemiring R] [Semiring A] [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B] (f : A ββ[R] B) (h : β (x : A), (ββf.toRingHom).toFun (star x) = star ((ββf.toRingHom).toFun x)) : β{ toAlgHom := f, map_star' := h } = βf - StarAlgEquiv.ofAlgEquiv_symm π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_6} {A : Type u_7} {B : Type u_8} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] [Star A] [Star B] (f : A ββ[R] B) (map_star : β (x : A), f (star x) = star (f x)) : (StarAlgEquiv.ofAlgEquiv f map_star).symm = StarAlgEquiv.ofAlgEquiv f.symm β― - NonUnitalStarAlgHom.mk π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B] (toNonUnitalAlgHom : A βββ[R] B) (map_star' : β (a : A), toNonUnitalAlgHom.toFun (star a) = star (toNonUnitalAlgHom.toFun a)) : A ββββ[R] B - NonUnitalStarAlgHom.map_star' π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B] (self : A ββββ[R] B) (a : A) : self.toFun (star a) = star (self.toFun a) - NonUnitalStarAlgHom.coe_mk' π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B] (f : A βββ[R] B) (h : β (a : A), f.toFun (star a) = star (f.toFun a)) : β{ toNonUnitalAlgHom := f, map_star' := h } = βf - StarAlgEquiv.mk_coe π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_2} {A : Type u_3} {B : Type u_4} [Add A] [Add B] [Mul A] [Mul B] [SMul R A] [SMul R B] [Star A] [Star B] (e : A βββ[R] B) (e' : B β A) (hβ : Function.LeftInverse e' βe) (hβ : Function.RightInverse e' βe) (hβ : β (x y : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun (x * y) = { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun x * { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun y) (hβ : β (x y : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun (x + y) = { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun x + { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ }.toFun y) (hβ : β (a : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ }.toFun (star a) = star ({ toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ }.toFun a)) (hβ : β (r : R) (a : A), { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ, map_star' := hβ }.toFun (r β’ a) = r β’ { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ, map_star' := hβ }.toFun a) : { toFun := βe, invFun := e', left_inv := hβ, right_inv := hβ, map_mul' := hβ, map_add' := hβ, map_star' := hβ , map_smul' := hβ } = e - StarAlgHom.coe_mk π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_2} {A : Type u_3} {B : Type u_4} [CommSemiring R] [Semiring A] [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B] (f : A β B) (hβ : f 1 = 1) (hβ : β (x y : A), { toFun := f, map_one' := hβ }.toFun (x * y) = { toFun := f, map_one' := hβ }.toFun x * { toFun := f, map_one' := hβ }.toFun y) (hβ : (β{ toFun := f, map_one' := hβ, map_mul' := hβ }).toFun 0 = 0) (hβ : β (x y : A), (β{ toFun := f, map_one' := hβ, map_mul' := hβ }).toFun (x + y) = (β{ toFun := f, map_one' := hβ, map_mul' := hβ }).toFun x + (β{ toFun := f, map_one' := hβ, map_mul' := hβ }).toFun y) (hβ : β (r : R), (ββ{ toFun := f, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ }).toFun ((algebraMap R A) r) = (algebraMap R B) r) (hβ : β (x : A), (ββ{ toFun := f, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, commutes' := hβ }.toRingHom).toFun (star x) = star ((ββ{ toFun := f, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, commutes' := hβ }.toRingHom).toFun x)) : β{ toFun := f, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, commutes' := hβ , map_star' := hβ } = f - StarAlgHom.mk_coe π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_2} {A : Type u_3} {B : Type u_4} [CommSemiring R] [Semiring A] [Algebra R A] [Star A] [Semiring B] [Algebra R B] [Star B] (f : A βββ[R] B) (hβ : f 1 = 1) (hβ : β (x y : A), { toFun := βf, map_one' := hβ }.toFun (x * y) = { toFun := βf, map_one' := hβ }.toFun x * { toFun := βf, map_one' := hβ }.toFun y) (hβ : (β{ toFun := βf, map_one' := hβ, map_mul' := hβ }).toFun 0 = 0) (hβ : β (x y : A), (β{ toFun := βf, map_one' := hβ, map_mul' := hβ }).toFun (x + y) = (β{ toFun := βf, map_one' := hβ, map_mul' := hβ }).toFun x + (β{ toFun := βf, map_one' := hβ, map_mul' := hβ }).toFun y) (hβ : β (r : R), (ββ{ toFun := βf, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ }).toFun ((algebraMap R A) r) = (algebraMap R B) r) (hβ : β (x : A), (ββ{ toFun := βf, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, commutes' := hβ }.toRingHom).toFun (star x) = star ((ββ{ toFun := βf, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, commutes' := hβ }.toRingHom).toFun x)) : { toFun := βf, map_one' := hβ, map_mul' := hβ, map_zero' := hβ, map_add' := hβ, commutes' := hβ , map_star' := hβ } = f - NonUnitalStarAlgHom.coe_mk π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B] (f : A β B) (hβ : β (m : R) (x : A), f (m β’ x) = (MonoidHom.id R) m β’ f x) (hβ : { toFun := f, map_smul' := hβ }.toFun 0 = 0) (hβ : β (x y : A), { toFun := f, map_smul' := hβ }.toFun (x + y) = { toFun := f, map_smul' := hβ }.toFun x + { toFun := f, map_smul' := hβ }.toFun y) (hβ : β (x y : A), { toFun := f, map_smul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun (x * y) = { toFun := f, map_smul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun x * { toFun := f, map_smul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun y) (hβ : β (a : A), { toFun := f, map_smul' := hβ, map_zero' := hβ, map_add' := hβ, map_mul' := hβ }.toFun (star a) = star ({ toFun := f, map_smul' := hβ, map_zero' := hβ, map_add' := hβ, map_mul' := hβ }.toFun a)) : β{ toFun := f, map_smul' := hβ, map_zero' := hβ, map_add' := hβ, map_mul' := hβ, map_star' := hβ } = f - NonUnitalStarAlgHom.mk_coe π Mathlib.Algebra.Star.StarAlgHom
{R : Type u_1} {A : Type u_2} {B : Type u_3} [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B] [Star B] (f : A ββββ[R] B) (hβ : β (m : R) (x : A), f (m β’ x) = (MonoidHom.id R) m β’ f x) (hβ : { toFun := βf, map_smul' := hβ }.toFun 0 = 0) (hβ : β (x y : A), { toFun := βf, map_smul' := hβ }.toFun (x + y) = { toFun := βf, map_smul' := hβ }.toFun x + { toFun := βf, map_smul' := hβ }.toFun y) (hβ : β (x y : A), { toFun := βf, map_smul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun (x * y) = { toFun := βf, map_smul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun x * { toFun := βf, map_smul' := hβ, map_zero' := hβ, map_add' := hβ }.toFun y) (hβ : β (a : A), { toFun := βf, map_smul' := hβ, map_zero' := hβ, map_add' := hβ, map_mul' := hβ }.toFun (star a) = star ({ toFun := βf, map_smul' := hβ, map_zero' := hβ, map_add' := hβ, map_mul' := hβ }.toFun a)) : { toFun := βf, map_smul' := hβ, map_zero' := hβ, map_add' := hβ, map_mul' := hβ, map_star' := hβ } = f - Matrix.conjTranspose_apply π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [Star Ξ±] (M : Matrix m n Ξ±) (i : m) (j : n) : M.conjTranspose j i = star (M i j) - Matrix.star_eq_conjTranspose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {Ξ± : Type v} [Star Ξ±] (M : Matrix m m Ξ±) : star M = M.conjTranspose - Matrix.star_apply π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [Star Ξ±] (M : Matrix n n Ξ±) (i j : n) : star M i j = star (M j i) - Matrix.conjTranspose_transpose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [Star Ξ±] (M : Matrix m n Ξ±) : M.conjTranspose.transpose = M.map star - Matrix.diag_conjTranspose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [Star Ξ±] (A : Matrix n n Ξ±) : A.conjTranspose.diag = star A.diag - Matrix.transpose_conjTranspose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [Star Ξ±] (M : Matrix m n Ξ±) : M.transpose.conjTranspose = M.map star - Matrix.diag_map_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [Star Ξ±] (A : Matrix n n Ξ±) : (A.map star).diag = star A.diag - Matrix.star_mul π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{R : Type u} {instβ : Mul R} [self : StarMul R] (r s : R) : star (r * s) = star s * star r - Matrix.conjTranspose_map π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} {Ξ² : Type w} [Star Ξ±] [Star Ξ²] {A : Matrix m n Ξ±} (f : Ξ± β Ξ²) (hf : Function.Semiconj f star star) : A.conjTranspose.map f = (A.map f).conjTranspose - Matrix.diagonal_conjTranspose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [AddMonoid Ξ±] [StarAddMonoid Ξ±] (v : n β Ξ±) : (Matrix.diagonal v).conjTranspose = Matrix.diagonal (star v) - Matrix.map_diagonal_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [AddMonoid Ξ±] [StarAddMonoid Ξ±] (x : n β Ξ±) : (Matrix.diagonal x).map star = Matrix.diagonal (star x) - Matrix.conjTranspose_vecMulVec π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [Mul Ξ±] [StarMul Ξ±] (w : m β Ξ±) (v : n β Ξ±) : (Matrix.vecMulVec w v).conjTranspose = Matrix.vecMulVec (star v) (star w) - Matrix.conjTranspose_single π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [DecidableEq n] [DecidableEq m] [AddMonoid Ξ±] [StarAddMonoid Ξ±] (i : m) (j : n) (a : Ξ±) : (Matrix.single i j a).conjTranspose = Matrix.single j i (star a) - Matrix.conjTranspose_eq_diagonal π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [AddMonoid Ξ±] [StarAddMonoid Ξ±] {M : Matrix n n Ξ±} {v : n β Ξ±} : M.conjTranspose = Matrix.diagonal v β M = Matrix.diagonal (star v) - Matrix.map_vecMulVec_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [Mul Ξ±] [StarMul Ξ±] (w : m β Ξ±) (v : n β Ξ±) : (Matrix.vecMulVec w v).map star = (Matrix.vecMulVec (star v) (star w)).transpose - Matrix.map_star_eq_diagonal π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [AddMonoid Ξ±] [StarAddMonoid Ξ±] {M : Matrix n n Ξ±} {v : n β Ξ±} : M.map star = Matrix.diagonal v β M = Matrix.diagonal (star v) - Matrix.map_star_eq_zero π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [AddMonoid Ξ±] [StarAddMonoid Ξ±] {M : Matrix m n Ξ±} : M.map star = 0 β M = 0 - Matrix.conjTranspose_smul π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {R : Type u_5} {Ξ± : Type v} [Star R] [Star Ξ±] [SMul R Ξ±] [StarModule R Ξ±] (c : R) (M : Matrix m n Ξ±) : (c β’ M).conjTranspose = star c β’ M.conjTranspose - Matrix.map_natCast_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [NonAssocSemiring Ξ±] [StarRing Ξ±] (d : β) : (βd).map star = βd - Matrix.map_intCast_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [Ring Ξ±] [StarRing Ξ±] (d : β€) : (βd).map star = βd - Matrix.map_star_eq_natCast π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [NonAssocSemiring Ξ±] [StarRing Ξ±] {M : Matrix n n Ξ±} {d : β} : M.map star = βd β M = βd - Matrix.conjTranspose_smul_self π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [Mul Ξ±] [StarMul Ξ±] (c : Ξ±) (M : Matrix m n Ξ±) : (c β’ M).conjTranspose = MulOpposite.op (star c) β’ M.conjTranspose - Matrix.map_ofNat_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [NonAssocSemiring Ξ±] [StarRing Ξ±] (d : β) [d.AtLeastTwo] : (OfNat.ofNat d).map star = OfNat.ofNat d - Matrix.map_star_eq_intCast π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [Ring Ξ±] [StarRing Ξ±] {M : Matrix n n Ξ±} {d : β€} : M.map star = βd β M = βd - Matrix.map_star_eq_one π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [NonAssocSemiring Ξ±] [StarRing Ξ±] {M : Matrix n n Ξ±} : M.map star = 1 β M = 1 - Matrix.mulVec_conjTranspose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [NonUnitalSemiring Ξ±] [Fintype m] [StarRing Ξ±] (A : Matrix m n Ξ±) (x : m β Ξ±) : A.conjTranspose.mulVec x = star (Matrix.vecMul (star x) A) - Matrix.star_mulVec π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [NonUnitalSemiring Ξ±] [Fintype n] [StarRing Ξ±] (M : Matrix m n Ξ±) (v : n β Ξ±) : star (M.mulVec v) = Matrix.vecMul (star v) M.conjTranspose - Matrix.star_vecMul π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [NonUnitalSemiring Ξ±] [Fintype m] [StarRing Ξ±] (M : Matrix m n Ξ±) (v : m β Ξ±) : star (Matrix.vecMul v M) = M.conjTranspose.mulVec (star v) - Matrix.vecMul_conjTranspose π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {Ξ± : Type v} [NonUnitalSemiring Ξ±] [Fintype n] [StarRing Ξ±] (A : Matrix m n Ξ±) (x : n β Ξ±) : Matrix.vecMul x A.conjTranspose = star (A.mulVec (star x)) - Matrix.dotProduct_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {Ξ± : Type v} [Fintype m] [NonUnitalSemiring Ξ±] [StarRing Ξ±] (v w : m β Ξ±) : v β¬α΅₯ star w = star (w β¬α΅₯ star v) - Matrix.star_dotProduct π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {Ξ± : Type v} [Fintype m] [NonUnitalSemiring Ξ±] [StarRing Ξ±] (v w : m β Ξ±) : star v β¬α΅₯ w = star (star w β¬α΅₯ v) - Matrix.star_dotProduct_star π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {Ξ± : Type v} [Fintype m] [NonUnitalSemiring Ξ±] [StarRing Ξ±] (v w : m β Ξ±) : star v β¬α΅₯ star w = star (w β¬α΅₯ v) - Matrix.map_star_eq_ofNat π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{n : Type u_3} {Ξ± : Type v} [DecidableEq n] [Semiring Ξ±] [StarRing Ξ±] {M : Matrix n n Ξ±} {d : β} [d.AtLeastTwo] : M.map star = OfNat.ofNat d β M = OfNat.ofNat d - Matrix.conjTranspose_smul_non_comm π Mathlib.LinearAlgebra.Matrix.ConjTranspose
{m : Type u_2} {n : Type u_3} {R : Type u_5} {Ξ± : Type v} [Star R] [Star Ξ±] [SMul R Ξ±] [SMul Rα΅α΅α΅ Ξ±] (c : R) (M : Matrix m n Ξ±) (h : β (r : R) (a : Ξ±), star (r β’ a) = MulOpposite.op (star r) β’ star a) : (c β’ M).conjTranspose = MulOpposite.op (star c) β’ M.conjTranspose - Matrix.conjTranspose_replicateCol π Mathlib.LinearAlgebra.Matrix.RowCol
{m : Type u_2} {Ξ± : Type v} {ΞΉ : Type u_6} [Star Ξ±] (v : m β Ξ±) : (Matrix.replicateCol ΞΉ v).conjTranspose = Matrix.replicateRow ΞΉ (star v)
About
Loogle searches Lean and Mathlib definitions and theorems.
You can use Loogle from within the Lean4 VSCode language extension
using the Loogle command from the command palette. You can also try the
#loogle command from LeanSearchClient,
the CLI version, the Loogle
VS Code extension, the lean.nvim
integration or the Zulip bot.
Usage
Loogle finds definitions and lemmas in various ways:
By constant:
πReal.sin
finds all lemmas whose statement somehow mentions the sine function.By lemma name substring:
π"differ"
finds all lemmas that have"differ"somewhere in their lemma name.By subexpression:
π_ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.The pattern can also be non-linear, as in
πReal.sqrt ?a * Real.sqrt ?aIf the pattern has parameters, they are matched in any order. Both of these will find
List.map:
π(?a -> ?b) -> List ?a -> List ?b
πList ?a -> (?a -> ?b) -> List ?bBy main conclusion:
π|- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of allβandβ) has the given shape.As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
π|- _ < _ β tsum _ < tsum _
will findtsum_lt_tsumeven though the hypothesisf i < g iis not the last.You can filter for definitions vs theorems: Using
β’ (_ : Type _)finds all definitions which provide data whileβ’ (_ : Prop)finds all theorems (and definitions of proofs).
If you pass more than one such search filter, separated by commas
Loogle will return lemmas which match all of them. The
search
π Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ β _
would find all lemmas which mention the constants Real.sin
and tsum, have "two" as a substring of the
lemma name, include a product and a power somewhere in the type,
and have a hypothesis of the form _ < _ (if
there were any such lemmas). Metavariables (?a) are
assigned independently in each filter.
The #lucky button will directly send you to the
documentation of the first hit.
Source code
You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO. Please review the Lean FRO Terms of Use and Privacy Policy.
This is Loogle revision 9f11169 serving mathlib revision ce5dd8c