statement stringlengths 1 2.88k | proof stringlengths 0 13.9k | type stringclasses 10
values | symbolic_name stringlengths 1 131 | library stringclasses 417
values | filename stringlengths 17 80 | imports listlengths 0 16 | deps listlengths 0 64 | docstring stringlengths 0 10.2k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
has_star (R : Type u) | (star : R → R) | class | has_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [] | Notation typeclass (with no default notation!) for an algebraic structure with a star operation. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_mem_class (S R : Type*) [has_star R] [set_like S R] | (star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s) | class | star_mem_class | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_star",
"set_like"
] | `star_mem_class S G` states `S` is a type of subsets `s ⊆ G` closed under star. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
has_involutive_star (R : Type u) extends has_star R | (star_involutive : function.involutive star) | class | has_involutive_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_star"
] | Typeclass for a star operation with is involutive. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_star [has_involutive_star R] (r : R) : star (star r) = r | star_involutive _ | lemma | star_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_injective [has_involutive_star R] : function.injective (star : R → R) | star_involutive.injective | lemma | star_injective | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_inj [has_involutive_star R] {x y : R} : star x = star y ↔ x = y | star_injective.eq_iff | lemma | star_inj | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
equiv.star [has_involutive_star R] : equiv.perm R | star_involutive.to_perm _ | def | equiv.star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"equiv.perm",
"has_involutive_star"
] | `star` as an equivalence when it is involutive. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
eq_star_of_eq_star [has_involutive_star R] {r s : R} (h : r = star s) : s = star r | by simp [h] | lemma | eq_star_of_eq_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
eq_star_iff_eq_star [has_involutive_star R] {r s : R} : r = star s ↔ s = star r | ⟨eq_star_of_eq_star, eq_star_of_eq_star⟩ | lemma | eq_star_iff_eq_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_eq_iff_star_eq [has_involutive_star R] {r s : R} : star r = s ↔ star s = r | eq_comm.trans $ eq_star_iff_eq_star.trans eq_comm | lemma | star_eq_iff_star_eq | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_trivial_star (R : Type u) [has_star R] : Prop | (star_trivial : ∀ (r : R), star r = r) | class | has_trivial_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_star"
] | Typeclass for a trivial star operation. This is mostly meant for `ℝ`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_semigroup (R : Type u) [semigroup R] extends has_involutive_star R | (star_mul : ∀ r s : R, star (r * s) = star s * star r) | class | star_semigroup | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_involutive_star",
"semigroup"
] | A `*`-semigroup is a semigroup `R` with an involutive operations `star`
so `star (r * s) = star s * star r`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_star_mul (x y : R) : star (star x * y) = star y * x | by rw [star_mul, star_star] | lemma | star_star_mul | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"star_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_mul_star (x y : R) : star (x * star y) = y * star x | by rw [star_mul, star_star] | lemma | star_mul_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"star_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
semiconj_by_star_star_star {x y z : R} :
semiconj_by (star x) (star z) (star y) ↔ semiconj_by x y z | by simp_rw [semiconj_by, ←star_mul, star_inj, eq_comm] | lemma | semiconj_by_star_star_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"semiconj_by",
"star_inj"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
commute_star_star {x y : R} : commute (star x) (star y) ↔ commute x y | semiconj_by_star_star_star | lemma | commute_star_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"commute",
"semiconj_by_star_star_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
commute_star_comm {x y : R} : commute (star x) y ↔ commute x (star y) | by rw [←commute_star_star, star_star] | lemma | commute_star_comm | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"commute",
"star_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_mul' [comm_semigroup R] [star_semigroup R] (x y : R) :
star (x * y) = star x * star y | (star_mul x y).trans (mul_comm _ _) | lemma | star_mul' | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semigroup",
"mul_comm",
"star_semigroup"
] | In a commutative ring, make `simp` prefer leaving the order unchanged. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_mul_equiv [semigroup R] [star_semigroup R] : R ≃* Rᵐᵒᵖ | { to_fun := λ x, mul_opposite.op (star x),
map_mul' := λ x y, (star_mul x y).symm ▸ (mul_opposite.op_mul _ _),
..(has_involutive_star.star_involutive.to_perm star).trans op_equiv} | def | star_mul_equiv | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"mul_opposite.op",
"mul_opposite.op_mul",
"semigroup",
"star_semigroup"
] | `star` as an `mul_equiv` from `R` to `Rᵐᵒᵖ` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_mul_aut [comm_semigroup R] [star_semigroup R] : mul_aut R | { to_fun := star,
map_mul' := star_mul',
..(has_involutive_star.star_involutive.to_perm star) } | def | star_mul_aut | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semigroup",
"mul_aut",
"star_mul'",
"star_semigroup"
] | `star` as a `mul_aut` for commutative `R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_one [monoid R] [star_semigroup R] : star (1 : R) = 1 | op_injective $ (star_mul_equiv : R ≃* Rᵐᵒᵖ).map_one.trans (op_one _).symm | lemma | star_one | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"monoid",
"star_mul_equiv",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_pow [monoid R] [star_semigroup R] (x : R) (n : ℕ) : star (x ^ n) = star x ^ n | op_injective $
((star_mul_equiv : R ≃* Rᵐᵒᵖ).to_monoid_hom.map_pow x n).trans (op_pow (star x) n).symm | lemma | star_pow | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"monoid",
"star_mul_equiv",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_inv [group R] [star_semigroup R] (x : R) : star (x⁻¹) = (star x)⁻¹ | op_injective $
((star_mul_equiv : R ≃* Rᵐᵒᵖ).to_monoid_hom.map_inv x).trans (op_inv (star x)).symm | lemma | star_inv | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"group",
"star_mul_equiv",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_zpow [group R] [star_semigroup R] (x : R) (z : ℤ) : star (x ^ z) = star x ^ z | op_injective $
((star_mul_equiv : R ≃* Rᵐᵒᵖ).to_monoid_hom.map_zpow x z).trans (op_zpow (star x) z).symm | lemma | star_zpow | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"group",
"star_mul_equiv",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_div [comm_group R] [star_semigroup R] (x y : R) :
star (x / y) = star x / star y | map_div (star_mul_aut : R ≃* R) _ _ | lemma | star_div | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_group",
"map_div",
"star_mul_aut",
"star_semigroup"
] | When multiplication is commutative, `star` preserves division. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_semigroup_of_comm {R : Type*} [comm_monoid R] : star_semigroup R | { star := id,
star_involutive := λ x, rfl,
star_mul := mul_comm } | def | star_semigroup_of_comm | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_monoid",
"mul_comm",
"star_semigroup"
] | Any commutative monoid admits the trivial `*`-structure.
See note [reducible non-instances]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_id_of_comm {R : Type*} [comm_semiring R] {x : R} : star x = x | rfl | lemma | star_id_of_comm | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring"
] | Note that since `star_semigroup_of_comm` is reducible, `simp` can already prove this. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_add_monoid (R : Type u) [add_monoid R] extends has_involutive_star R | (star_add : ∀ r s : R, star (r + s) = star r + star s) | class | star_add_monoid | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"has_involutive_star"
] | A `*`-additive monoid `R` is an additive monoid with an involutive `star` operation which
preserves addition. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_add_equiv [add_monoid R] [star_add_monoid R] : R ≃+ R | { to_fun := star,
map_add' := star_add,
..(has_involutive_star.star_involutive.to_perm star)} | def | star_add_equiv | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"star_add_monoid"
] | `star` as an `add_equiv` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_zero [add_monoid R] [star_add_monoid R] : star (0 : R) = 0 | (star_add_equiv : R ≃+ R).map_zero | lemma | star_zero | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_eq_zero [add_monoid R] [star_add_monoid R] {x : R} : star x = 0 ↔ x = 0 | star_add_equiv.map_eq_zero_iff | lemma | star_eq_zero | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_ne_zero [add_monoid R] [star_add_monoid R] {x : R} : star x ≠ 0 ↔ x ≠ 0 | star_eq_zero.not | lemma | star_ne_zero | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_neg [add_group R] [star_add_monoid R] (r : R) : star (-r) = - star r | (star_add_equiv : R ≃+ R).map_neg _ | lemma | star_neg | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_group",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_sub [add_group R] [star_add_monoid R] (r s : R) :
star (r - s) = star r - star s | (star_add_equiv : R ≃+ R).map_sub _ _ | lemma | star_sub | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_group",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_nsmul [add_monoid R] [star_add_monoid R] (x : R) (n : ℕ) :
star (n • x) = n • star x | (star_add_equiv : R ≃+ R).to_add_monoid_hom.map_nsmul _ _ | lemma | star_nsmul | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_zsmul [add_group R] [star_add_monoid R] (x : R) (n : ℤ) :
star (n • x) = n • star x | (star_add_equiv : R ≃+ R).to_add_monoid_hom.map_zsmul _ _ | lemma | star_zsmul | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_group",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_ring (R : Type u) [non_unital_semiring R] extends star_semigroup R | (star_add : ∀ r s : R, star (r + s) = star r + star s) | class | star_ring | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"non_unital_semiring",
"star_semigroup"
] | A `*`-ring `R` is a (semi)ring with an involutive `star` operation which is additive
which makes `R` with its multiplicative structure into a `*`-semigroup
(i.e. `star (r * s) = star s * star r`). | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_ring.to_star_add_monoid [non_unital_semiring R] [star_ring R] : star_add_monoid R | { star_add := star_ring.star_add } | instance | star_ring.to_star_add_monoid | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"non_unital_semiring",
"star_add_monoid",
"star_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_ring_equiv [non_unital_semiring R] [star_ring R] : R ≃+* Rᵐᵒᵖ | { to_fun := λ x, mul_opposite.op (star x),
..star_add_equiv.trans (mul_opposite.op_add_equiv : R ≃+ Rᵐᵒᵖ),
..star_mul_equiv } | def | star_ring_equiv | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"mul_opposite.op",
"mul_opposite.op_add_equiv",
"non_unital_semiring",
"star_mul_equiv",
"star_ring"
] | `star` as an `ring_equiv` from `R` to `Rᵐᵒᵖ` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_nat_cast [semiring R] [star_ring R] (n : ℕ) :
star (n : R) = n | (congr_arg unop (map_nat_cast (star_ring_equiv : R ≃+* Rᵐᵒᵖ) n)).trans (unop_nat_cast _) | lemma | star_nat_cast | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"map_nat_cast",
"semiring",
"star_ring",
"star_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_int_cast [ring R] [star_ring R] (z : ℤ) :
star (z : R) = z | (congr_arg unop $ map_int_cast (star_ring_equiv : R ≃+* Rᵐᵒᵖ) z).trans (unop_int_cast _) | lemma | star_int_cast | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"map_int_cast",
"ring",
"star_ring",
"star_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_rat_cast [division_ring R] [star_ring R] (r : ℚ) :
star (r : R) = r | (congr_arg unop $ map_rat_cast (star_ring_equiv : R ≃+* Rᵐᵒᵖ) r).trans (unop_rat_cast _) | lemma | star_rat_cast | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"division_ring",
"map_rat_cast",
"star_ring",
"star_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_ring_aut [comm_semiring R] [star_ring R] : ring_aut R | { to_fun := star,
..star_add_equiv,
..star_mul_aut } | def | star_ring_aut | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"ring_aut",
"star_add_equiv",
"star_mul_aut",
"star_ring"
] | `star` as a ring automorphism, for commutative `R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_ring_end [comm_semiring R] [star_ring R] : R →+* R | @star_ring_aut R _ _ | def | star_ring_end | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"star_ring",
"star_ring_aut"
] | `star` as a ring endomorphism, for commutative `R`. This is used to denote complex
conjugation, and is available under the notation `conj` in the locale `complex_conjugate`.
Note that this is the preferred form (over `star_ring_aut`, available under the same hypotheses)
because the notation `E →ₗ⋆[R] F` for an `R`-con... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_ring_end_apply [comm_semiring R] [star_ring R] {x : R} :
star_ring_end R x = star x | rfl | lemma | star_ring_end_apply | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"star_ring",
"star_ring_end"
] | This is not a simp lemma, since we usually want simp to keep `star_ring_end` bundled.
For example, for complex conjugation, we don't want simp to turn `conj x`
into the bare function `star x` automatically since most lemmas are about `conj x`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_ring_end_self_apply [comm_semiring R] [star_ring R] (x : R) :
star_ring_end R (star_ring_end R x) = x | star_star x | lemma | star_ring_end_self_apply | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"star_ring",
"star_ring_end",
"star_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ring_hom.has_involutive_star {S : Type*} [non_assoc_semiring S] [comm_semiring R]
[star_ring R] : has_involutive_star (S →+* R) | { to_has_star := { star := λ f, ring_hom.comp (star_ring_end R) f },
star_involutive :=
by { intro _, ext, simp only [ring_hom.coe_comp, function.comp_app, star_ring_end_self_apply] }} | instance | ring_hom.has_involutive_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"has_involutive_star",
"non_assoc_semiring",
"ring_hom.coe_comp",
"ring_hom.comp",
"star_ring",
"star_ring_end",
"star_ring_end_self_apply"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ring_hom.star_def {S : Type*} [non_assoc_semiring S] [comm_semiring R] [star_ring R]
(f : S →+* R) : has_star.star f = ring_hom.comp (star_ring_end R) f | rfl | lemma | ring_hom.star_def | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"non_assoc_semiring",
"ring_hom.comp",
"star_ring",
"star_ring_end"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ring_hom.star_apply {S : Type*} [non_assoc_semiring S] [comm_semiring R] [star_ring R]
(f : S →+* R) (s : S) : star f s = star (f s) | rfl | lemma | ring_hom.star_apply | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"non_assoc_semiring",
"star_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_inv' [division_semiring R] [star_ring R] (x : R) : star (x⁻¹) = (star x)⁻¹ | op_injective $ (map_inv₀ (star_ring_equiv : R ≃+* Rᵐᵒᵖ) x).trans (op_inv (star x)).symm | lemma | star_inv' | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"division_semiring",
"map_inv₀",
"star_ring",
"star_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_zpow₀ [division_semiring R] [star_ring R] (x : R) (z : ℤ) :
star (x ^ z) = star x ^ z | op_injective $ (map_zpow₀ (star_ring_equiv : R ≃+* Rᵐᵒᵖ) x z).trans (op_zpow (star x) z).symm | lemma | star_zpow₀ | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"division_semiring",
"map_zpow₀",
"star_ring",
"star_ring_equiv"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_div' [semifield R] [star_ring R] (x y : R) : star (x / y) = star x / star y | map_div₀ (star_ring_end R) _ _ | lemma | star_div' | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"map_div₀",
"semifield",
"star_ring",
"star_ring_end"
] | When multiplication is commutative, `star` preserves division. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_bit0 [add_monoid R] [star_add_monoid R] (r : R) :
star (bit0 r) = bit0 (star r) | by simp [bit0] | lemma | star_bit0 | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"add_monoid",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_bit1 [semiring R] [star_ring R] (r : R) : star (bit1 r) = bit1 (star r) | by simp [bit1] | lemma | star_bit1 | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"semiring",
"star_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_ring_of_comm {R : Type*} [comm_semiring R] : star_ring R | { star := id,
star_add := λ x y, rfl,
..star_semigroup_of_comm } | def | star_ring_of_comm | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_semiring",
"star_ring",
"star_semigroup_of_comm"
] | Any commutative semiring admits the trivial `*`-structure.
See note [reducible non-instances]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_module (R : Type u) (A : Type v) [has_star R] [has_star A] [has_smul R A] : Prop | (star_smul : ∀ (r : R) (a : A), star (r • a) = star r • star a) | class | star_module | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_smul",
"has_star"
] | A star module `A` over a star ring `R` is a module which is a star add monoid,
and the two star structures are compatible in the sense
`star (r • a) = star r • star a`.
Note that it is up to the user of this typeclass to enforce
`[semiring R] [star_ring R] [add_comm_monoid A] [star_add_monoid A] [module R A]`, and tha... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_semigroup.to_star_module [comm_monoid R] [star_semigroup R] : star_module R R | ⟨star_mul'⟩ | instance | star_semigroup.to_star_module | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_monoid",
"star_module",
"star_semigroup"
] | A commutative star monoid is a star module over itself via `monoid.to_mul_action`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_hom_class (F : Type*) (R S : out_param Type*) [has_star R] [has_star S]
extends fun_like F R (λ _, S) | (map_star : ∀ (f : F) (r : R), f (star r) = star (f r)) | class | star_hom_class | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"fun_like",
"has_star"
] | `star_hom_class F R S` states that `F` is a type of `star`-preserving maps from `R` to `S`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
coe_star (u : Rˣ) : ↑(star u) = (star ↑u : R) | rfl | lemma | units.coe_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_star_inv (u : Rˣ) : ↑(star u)⁻¹ = (star ↑u⁻¹ : R) | rfl | lemma | units.coe_star_inv | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_unit.star [monoid R] [star_semigroup R] {a : R} : is_unit a → is_unit (star a) | | ⟨u, hu⟩ := ⟨star u, hu ▸ rfl⟩ | lemma | is_unit.star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"is_unit",
"monoid",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_unit_star [monoid R] [star_semigroup R] {a : R} : is_unit (star a) ↔ is_unit a | ⟨λ h, star_star a ▸ h.star, is_unit.star⟩ | lemma | is_unit_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"is_unit",
"monoid",
"star_semigroup",
"star_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ring.inverse_star [semiring R] [star_ring R] (a : R) :
ring.inverse (star a) = star (ring.inverse a) | begin
by_cases ha : is_unit a,
{ obtain ⟨u, rfl⟩ := ha,
rw [ring.inverse_unit, ←units.coe_star, ring.inverse_unit, ←units.coe_star_inv], },
rw [ring.inverse_non_unit _ ha, ring.inverse_non_unit _ (mt is_unit_star.mp ha), star_zero],
end | lemma | ring.inverse_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"is_unit",
"ring.inverse",
"ring.inverse_non_unit",
"ring.inverse_unit",
"semiring",
"star_ring",
"star_zero"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
invertible.star {R : Type*} [monoid R] [star_semigroup R] (r : R) [invertible r] :
invertible (star r) | { inv_of := star (⅟r),
inv_of_mul_self := by rw [←star_mul, mul_inv_of_self, star_one],
mul_inv_of_self := by rw [←star_mul, inv_of_mul_self, star_one] } | instance | invertible.star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"inv_of_mul_self",
"invertible",
"monoid",
"mul_inv_of_self",
"star_one",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_inv_of {R : Type*} [monoid R] [star_semigroup R] (r : R)
[invertible r] [invertible (star r)] :
star (⅟r) = ⅟(star r) | by { letI := invertible.star r, convert (rfl : star (⅟r) = _) } | lemma | star_inv_of | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"invertible",
"invertible.star",
"monoid",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
unop_star [has_star R] (r : Rᵐᵒᵖ) : unop (star r) = star (unop r) | rfl | lemma | mul_opposite.unop_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
op_star [has_star R] (r : R) : op (star r) = star (op r) | rfl | lemma | mul_opposite.op_star | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"has_star"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_semigroup.to_opposite_star_module [comm_monoid R] [star_semigroup R] :
star_module Rᵐᵒᵖ R | ⟨λ r s, star_mul' s r.unop⟩ | instance | star_semigroup.to_opposite_star_module | algebra.star | src/algebra/star/basic.lean | [
"algebra.ring.aut",
"algebra.ring.comp_typeclasses",
"data.rat.cast",
"group_theory.group_action.opposite",
"data.set_like.basic"
] | [
"comm_monoid",
"star_module",
"star_mul'",
"star_semigroup"
] | A commutative star monoid is a star module over its opposite via
`monoid.to_opposite_mul_action`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_prod [comm_monoid R] [star_semigroup R] {α : Type*}
(s : finset α) (f : α → R):
star (∏ x in s, f x) = ∏ x in s, star (f x) | map_prod (star_mul_aut : R ≃* R) _ _ | lemma | star_prod | algebra.star | src/algebra/star/big_operators.lean | [
"algebra.big_operators.basic",
"algebra.star.basic"
] | [
"comm_monoid",
"finset",
"map_prod",
"star_mul_aut",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_sum [add_comm_monoid R] [star_add_monoid R] {α : Type*}
(s : finset α) (f : α → R):
star (∑ x in s, f x) = ∑ x in s, star (f x) | (star_add_equiv : R ≃+ R).map_sum _ _ | lemma | star_sum | algebra.star | src/algebra/star/big_operators.lean | [
"algebra.big_operators.basic",
"algebra.star.basic"
] | [
"add_comm_monoid",
"finset",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_CHSH_tuple {R} [monoid R] [star_semigroup R] (A₀ A₁ B₀ B₁ : R) | (A₀_inv : A₀^2 = 1) (A₁_inv : A₁^2 = 1) (B₀_inv : B₀^2 = 1) (B₁_inv : B₁^2 = 1)
(A₀_sa : star A₀ = A₀) (A₁_sa : star A₁ = A₁) (B₀_sa : star B₀ = B₀) (B₁_sa : star B₁ = B₁)
(A₀B₀_commutes : A₀ * B₀ = B₀ * A₀)
(A₀B₁_commutes : A₀ * B₁ = B₁ * A₀)
(A₁B₀_commutes : A₁ * B₀ = B₀ * A₁)
(A₁B₁_commutes : A₁ * B₁ = B₁ * A₁) | structure | is_CHSH_tuple | algebra.star | src/algebra/star/chsh.lean | [
"algebra.char_p.invertible",
"data.real.sqrt"
] | [
"monoid",
"star_semigroup"
] | A CHSH tuple in a *-monoid consists of 4 self-adjoint involutions `A₀ A₁ B₀ B₁` such that
the `Aᵢ` commute with the `Bⱼ`.
The physical interpretation is that `A₀` and `A₁` are a pair of boolean observables which
are spacelike separated from another pair `B₀` and `B₁` of boolean observables. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
CHSH_id [comm_ring R] {A₀ A₁ B₀ B₁ : R}
(A₀_inv : A₀^2 = 1) (A₁_inv : A₁^2 = 1) (B₀_inv : B₀^2 = 1) (B₁_inv : B₁^2 = 1) :
(2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) *
(2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) =
4 * (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁) | -- If we had a Gröbner basis algorithm, this would be trivial.
-- Without one, it is somewhat tedious!
begin
rw ← sub_eq_zero,
repeat
{ ring_nf,
simp only [A₁_inv, B₁_inv, sub_eq_add_neg, add_mul, mul_add, sub_mul, mul_sub, add_assoc,
neg_add, neg_sub, sub_add, sub_sub, neg_mul, ←sq, A₀_inv, B₀_in... | lemma | CHSH_id | algebra.star | src/algebra/star/chsh.lean | [
"algebra.char_p.invertible",
"data.real.sqrt"
] | [
"comm_ring",
"mul_one",
"neg_mul",
"one_mul",
"zero_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
CHSH_inequality_of_comm
[ordered_comm_ring R] [star_ordered_ring R] [algebra ℝ R] [ordered_smul ℝ R]
(A₀ A₁ B₀ B₁ : R) (T : is_CHSH_tuple A₀ A₁ B₀ B₁) :
A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2 | begin
let P := (2 - A₀ * B₀ - A₀ * B₁ - A₁ * B₀ + A₁ * B₁),
have i₁ : 0 ≤ P,
{ have idem : P * P = 4 * P := CHSH_id T.A₀_inv T.A₁_inv T.B₀_inv T.B₁_inv,
have idem' : P = (1 / 4 : ℝ) • (P * P),
{ have h : 4 * P = (4 : ℝ) • P := by simp [algebra.smul_def],
rw [idem, h, ←mul_smul],
norm_num, },
... | lemma | CHSH_inequality_of_comm | algebra.star | src/algebra/star/chsh.lean | [
"algebra.char_p.invertible",
"data.real.sqrt"
] | [
"CHSH_id",
"algebra",
"algebra.smul_def",
"is_CHSH_tuple",
"mul_comm",
"ordered_comm_ring",
"ordered_smul",
"smul_le_smul_of_nonneg",
"star_bit0",
"star_mul_self_nonneg",
"star_one",
"star_ordered_ring",
"star_sub"
] | Given a CHSH tuple (A₀, A₁, B₀, B₁) in a *commutative* ordered `*`-algebra over ℝ,
`A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2`.
(We could work over ℤ[⅟2] if we wanted to!) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
tsirelson_inequality_aux : √2 * √2 ^ 3 = √2 * (2 * √2⁻¹ + 4 * (√2⁻¹ * 2⁻¹)) | begin
ring_nf, field_simp [(@real.sqrt_pos 2).2 (by norm_num)],
convert congr_arg (^2) (@real.sq_sqrt 2 (by norm_num)) using 1;
simp only [← pow_mul]; norm_num,
end | lemma | tsirelson_inequality.tsirelson_inequality_aux | algebra.star | src/algebra/star/chsh.lean | [
"algebra.char_p.invertible",
"data.real.sqrt"
] | [
"pow_mul",
"real.sq_sqrt",
"real.sqrt_pos"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
sqrt_two_inv_mul_self : √2⁻¹ * √2⁻¹ = (2⁻¹ : ℝ) | by { rw ←mul_inv, norm_num } | lemma | tsirelson_inequality.sqrt_two_inv_mul_self | algebra.star | src/algebra/star/chsh.lean | [
"algebra.char_p.invertible",
"data.real.sqrt"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tsirelson_inequality
[ordered_ring R] [star_ordered_ring R]
[algebra ℝ R] [ordered_smul ℝ R] [star_module ℝ R]
(A₀ A₁ B₀ B₁ : R) (T : is_CHSH_tuple A₀ A₁ B₀ B₁) :
A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ √2^3 • 1 | begin
-- abel will create `ℤ` multiplication. We will `simp` them away to `ℝ` multiplication.
have M : ∀ (m : ℤ) (a : ℝ) (x : R), m • a • x = ((m : ℝ) * a) • x :=
λ m a x, by rw [zsmul_eq_smul_cast ℝ, ← mul_smul],
let P := √2⁻¹ • (A₁ + A₀) - B₀,
let Q := √2⁻¹ • (A₁ - A₀) + B₁,
have w : √2^3 • 1 - A₀ * B₀ ... | lemma | tsirelson_inequality | algebra.star | src/algebra/star/chsh.lean | [
"algebra.char_p.invertible",
"data.real.sqrt"
] | [
"add_smul",
"algebra",
"algebra.mul_smul_comm",
"algebra.smul_mul_assoc",
"int.cast_bit0",
"int.cast_neg",
"int.cast_one",
"is_CHSH_tuple",
"mul_inv_cancel_of_invertible",
"mul_left_cancel₀",
"neg_mul",
"neg_smul",
"one_mul",
"one_smul",
"ordered_ring",
"ordered_smul",
"smul_add",
... | In a noncommutative ordered `*`-algebra over ℝ,
Tsirelson's bound for a CHSH tuple (A₀, A₁, B₀, B₁) is
`A₀ * B₀ + A₀ * B₁ + A₁ * B₀ - A₁ * B₁ ≤ 2^(3/2) • 1`.
We prove this by providing an explicit sum-of-squares decomposition
of the difference.
(We could work over `ℤ[2^(1/2), 2^(-1/2)]` if we really wanted to!) | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_of (x : α) : star (of x) = of x | rfl | lemma | free_monoid.star_of | algebra.star | src/algebra/star/free.lean | [
"algebra.star.basic",
"algebra.free_algebra"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_one : star (1 : free_monoid α) = 1 | rfl | lemma | free_monoid.star_one | algebra.star | src/algebra/star/free.lean | [
"algebra.star.basic",
"algebra.free_algebra"
] | [
"free_monoid",
"star_one"
] | Note that `star_one` is already a global simp lemma, but this one works with dsimp too | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_ι (x : X) : star (ι R x) = (ι R x) | by simp [star, has_star.star] | lemma | free_algebra.star_ι | algebra.star | src/algebra/star/free.lean | [
"algebra.star.basic",
"algebra.free_algebra"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_algebra_map (r : R) : star (algebra_map R (free_algebra R X) r) = (algebra_map R _ r) | by simp [star, has_star.star] | lemma | free_algebra.star_algebra_map | algebra.star | src/algebra/star/free.lean | [
"algebra.star.basic",
"algebra.free_algebra"
] | [
"algebra_map",
"free_algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_hom : free_algebra R X ≃ₐ[R] (free_algebra R X)ᵐᵒᵖ | { commutes' := λ r, by simp [star_algebra_map],
..star_ring_equiv } | def | free_algebra.star_hom | algebra.star | src/algebra/star/free.lean | [
"algebra.star.basic",
"algebra.free_algebra"
] | [
"free_algebra",
"star_ring_equiv"
] | `star` as an `alg_equiv` | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_nat_cast_smul [semiring R] [add_comm_monoid M] [module R M] [star_add_monoid M]
(n : ℕ) (x : M) : star ((n : R) • x) = (n : R) • star x | map_nat_cast_smul (star_add_equiv : M ≃+ M) R R n x | lemma | star_nat_cast_smul | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_monoid",
"map_nat_cast_smul",
"module",
"semiring",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_int_cast_smul [ring R] [add_comm_group M] [module R M] [star_add_monoid M]
(n : ℤ) (x : M) : star ((n : R) • x) = (n : R) • star x | map_int_cast_smul (star_add_equiv : M ≃+ M) R R n x | lemma | star_int_cast_smul | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_group",
"map_int_cast_smul",
"module",
"ring",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_inv_nat_cast_smul [division_semiring R] [add_comm_monoid M] [module R M]
[star_add_monoid M] (n : ℕ) (x : M) : star ((n⁻¹ : R) • x) = (n⁻¹ : R) • star x | map_inv_nat_cast_smul (star_add_equiv : M ≃+ M) R R n x | lemma | star_inv_nat_cast_smul | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_monoid",
"division_semiring",
"map_inv_nat_cast_smul",
"module",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_inv_int_cast_smul [division_ring R] [add_comm_group M] [module R M]
[star_add_monoid M] (n : ℤ) (x : M) : star ((n⁻¹ : R) • x) = (n⁻¹ : R) • star x | map_inv_int_cast_smul (star_add_equiv : M ≃+ M) R R n x | lemma | star_inv_int_cast_smul | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_group",
"division_ring",
"map_inv_int_cast_smul",
"module",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_rat_cast_smul [division_ring R] [add_comm_group M] [module R M]
[star_add_monoid M] (n : ℚ) (x : M) : star ((n : R) • x) = (n : R) • star x | map_rat_cast_smul (star_add_equiv : M ≃+ M) _ _ _ x | lemma | star_rat_cast_smul | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_group",
"division_ring",
"map_rat_cast_smul",
"module",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_rat_smul {R : Type*} [add_comm_group R] [star_add_monoid R] [module ℚ R]
(x : R) (n : ℚ) : star (n • x) = n • star x | map_rat_smul (star_add_equiv : R ≃+ R) _ _ | lemma | star_rat_smul | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_group",
"map_rat_smul",
"module",
"star_add_equiv",
"star_add_monoid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_linear_equiv (R : Type*) {A : Type*}
[comm_semiring R] [star_ring R] [add_comm_monoid A] [star_add_monoid A] [module R A]
[star_module R A] :
A ≃ₗ⋆[R] A | { to_fun := star,
map_smul' := star_smul,
.. star_add_equiv } | def | star_linear_equiv | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"add_comm_monoid",
"comm_semiring",
"module",
"star_add_equiv",
"star_add_monoid",
"star_module",
"star_ring"
] | If `A` is a module over a commutative `R` with compatible actions,
then `star` is a semilinear equivalence. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
self_adjoint.submodule : submodule R A | { smul_mem' := λ r x, (is_self_adjoint.all _).smul,
..self_adjoint A } | def | self_adjoint.submodule | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"is_self_adjoint.all",
"self_adjoint",
"submodule"
] | The self-adjoint elements of a star module, as a submodule. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
skew_adjoint.submodule : submodule R A | { smul_mem' := skew_adjoint.smul_mem,
..skew_adjoint A } | def | skew_adjoint.submodule | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"skew_adjoint",
"skew_adjoint.smul_mem",
"submodule"
] | The skew-adjoint elements of a star module, as a submodule. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
self_adjoint_part : A →ₗ[R] self_adjoint A | { to_fun := λ x, ⟨(⅟2 : R) • (x + star x),
by simp only [self_adjoint.mem_iff, star_smul, add_comm,
star_add_monoid.star_add, star_inv', star_bit0,
star_one, star_star, star_inv_of (2 : R), star_trivial]⟩,
map_add' := λ x y, by { ext, simp [add_add_add_comm] },
map_smul' := λ r... | def | self_adjoint_part | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"commute.inv_of_left",
"commute.one_left",
"self_adjoint",
"self_adjoint.mem_iff",
"star_bit0",
"star_inv'",
"star_inv_of",
"star_one",
"star_star"
] | The self-adjoint part of an element of a star module, as a linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
skew_adjoint_part : A →ₗ[R] skew_adjoint A | { to_fun := λ x, ⟨(⅟2 : R) • (x - star x),
by simp only [skew_adjoint.mem_iff, star_smul, star_sub, star_star, star_trivial, ←smul_neg,
neg_sub]⟩,
map_add' := λ x y, by { ext, simp only [sub_add, ←smul_add, sub_sub_eq_add_sub, star_add,
add_subgroup.coe_... | def | skew_adjoint_part | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"commute.inv_of_right",
"commute.one_right",
"skew_adjoint",
"skew_adjoint.mem_iff",
"star_star",
"star_sub"
] | The skew-adjoint part of an element of a star module, as a linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
star_module.self_adjoint_part_add_skew_adjoint_part (x : A) :
(self_adjoint_part R x : A) + skew_adjoint_part R x = x | by simp only [smul_sub, self_adjoint_part_apply_coe, smul_add, skew_adjoint_part_apply_coe,
add_add_sub_cancel, inv_of_two_smul_add_inv_of_two_smul] | lemma | star_module.self_adjoint_part_add_skew_adjoint_part | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"inv_of_two_smul_add_inv_of_two_smul",
"self_adjoint_part",
"skew_adjoint_part",
"smul_add",
"smul_sub"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_module.decompose_prod_adjoint : A ≃ₗ[R] self_adjoint A × skew_adjoint A | linear_equiv.of_linear
((self_adjoint_part R).prod (skew_adjoint_part R))
((self_adjoint.submodule R A).subtype.coprod (skew_adjoint.submodule R A).subtype)
(by ext; simp)
(linear_map.ext $ star_module.self_adjoint_part_add_skew_adjoint_part R) | def | star_module.decompose_prod_adjoint | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"linear_equiv.of_linear",
"linear_map.ext",
"self_adjoint",
"self_adjoint.submodule",
"self_adjoint_part",
"skew_adjoint",
"skew_adjoint.submodule",
"skew_adjoint_part",
"star_module.self_adjoint_part_add_skew_adjoint_part"
] | The decomposition of elements of a star module into their self- and skew-adjoint parts,
as a linear equivalence. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
algebra_map_star_comm {R A : Type*} [comm_semiring R] [star_ring R] [semiring A]
[star_semigroup A] [algebra R A] [star_module R A] (r : R) :
algebra_map R A (star r) = star (algebra_map R A r) | by simp only [algebra.algebra_map_eq_smul_one, star_smul, star_one] | lemma | algebra_map_star_comm | algebra.star | src/algebra/star/module.lean | [
"algebra.star.self_adjoint",
"algebra.module.equiv",
"linear_algebra.prod"
] | [
"algebra",
"algebra.algebra_map_eq_smul_one",
"algebra_map",
"comm_semiring",
"semiring",
"star_module",
"star_one",
"star_ring",
"star_semigroup"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
star_ordered_ring (R : Type u) [non_unital_semiring R] [partial_order R]
extends star_ring R | (add_le_add_left : ∀ a b : R, a ≤ b → ∀ c : R, c + a ≤ c + b)
(le_iff : ∀ x y : R,
x ≤ y ↔ ∃ p, p ∈ add_submonoid.closure (set.range $ λ s, star s * s) ∧ y = x + p) | class | star_ordered_ring | algebra.star | src/algebra/star/order.lean | [
"algebra.star.basic",
"group_theory.submonoid.basic"
] | [
"non_unital_semiring",
"set.range",
"star_ring"
] | An ordered `*`-ring is a ring which is both an `ordered_add_comm_group` and a `*`-ring,
and the nonnegative elements constitute precisely the `add_submonoid` generated by
elements of the form `star s * s`.
If you are working with a `non_unital_ring` and not a `non_unital_semiring`, it may be more
convenient do declare... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_ordered_add_comm_monoid [non_unital_semiring R] [partial_order R]
[star_ordered_ring R] : ordered_add_comm_monoid R | { ..show non_unital_semiring R, by apply_instance,
..show partial_order R, by apply_instance,
..show star_ordered_ring R, by apply_instance } | instance | star_ordered_ring.to_ordered_add_comm_monoid | algebra.star | src/algebra/star/order.lean | [
"algebra.star.basic",
"group_theory.submonoid.basic"
] | [
"non_unital_semiring",
"ordered_add_comm_monoid",
"star_ordered_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_has_exists_add_of_le [non_unital_semiring R] [partial_order R]
[star_ordered_ring R] : has_exists_add_of_le R | { exists_add_of_le := λ a b h, match (le_iff _ _).mp h with ⟨p, _, hp⟩ := ⟨p, hp⟩ end } | instance | star_ordered_ring.to_has_exists_add_of_le | algebra.star | src/algebra/star/order.lean | [
"algebra.star.basic",
"group_theory.submonoid.basic"
] | [
"has_exists_add_of_le",
"non_unital_semiring",
"star_ordered_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_ordered_add_comm_group [non_unital_ring R] [partial_order R] [star_ordered_ring R] :
ordered_add_comm_group R | { ..show non_unital_ring R, by apply_instance,
..show partial_order R, by apply_instance,
..show star_ordered_ring R, by apply_instance } | instance | star_ordered_ring.to_ordered_add_comm_group | algebra.star | src/algebra/star/order.lean | [
"algebra.star.basic",
"group_theory.submonoid.basic"
] | [
"non_unital_ring",
"ordered_add_comm_group",
"star_ordered_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_le_iff [non_unital_semiring R] [partial_order R] [star_ring R]
(h_add : ∀ {x y : R}, x ≤ y → ∀ z, z + x ≤ z + y)
(h_le_iff : ∀ x y : R, x ≤ y ↔ ∃ s, y = x + star s * s) :
star_ordered_ring R | { add_le_add_left := @h_add,
le_iff := λ x y,
begin
refine ⟨λ h, _, _⟩,
{ obtain ⟨p, hp⟩ := (h_le_iff x y).mp h,
exact ⟨star p * p, add_submonoid.subset_closure ⟨p, rfl⟩, hp⟩ },
{ rintro ⟨p, hp, hpxy⟩,
revert x y hpxy,
refine add_submonoid.closure_induction hp _ (λ x y h, add_zero x ▸ ... | def | star_ordered_ring.of_le_iff | algebra.star | src/algebra/star/order.lean | [
"algebra.star.basic",
"group_theory.submonoid.basic"
] | [
"non_unital_semiring",
"star_ordered_ring",
"star_ring"
] | To construct a `star_ordered_ring` instance it suffices to show that `x ≤ y` if and only if
`y = x + star s * s` for some `s : R`.
This is provided for convenience because it holds in some common scenarios (e.g.,`ℝ≥0`, `C(X, ℝ≥0)`)
and obviates the hassle of `add_submonoid.closure_induction` when creating those instan... | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.