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 |
|---|---|---|---|---|---|---|---|---|---|---|
ring_invo [semiring R] extends R ≃+* Rᵐᵒᵖ | (involution' : ∀ x, (to_fun (to_fun x).unop).unop = x) | structure | ring_invo | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"semiring"
] | A ring involution | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ring_invo_class (F : Type*) (R : out_param Type*) [semiring R]
extends ring_equiv_class F R Rᵐᵒᵖ | (involution : ∀ (f : F) (x), (f (f x).unop).unop = x) | class | ring_invo_class | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_equiv_class",
"semiring"
] | `ring_invo_class F R S` states that `F` is a type of ring involutions.
You should extend this class when you extend `ring_invo`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mk' (f : R →+* Rᵐᵒᵖ) (involution : ∀ r, (f (f r).unop).unop = r) :
ring_invo R | { inv_fun := λ r, (f r.unop).unop,
left_inv := λ r, involution r,
right_inv := λ r, mul_opposite.unop_injective $ involution _,
involution' := involution,
.. f } | def | ring_invo.mk' | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"inv_fun",
"mk'",
"mul_opposite.unop_injective",
"ring_invo"
] | Construct a ring involution from a ring homomorphism. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_fun_eq_coe (f : ring_invo R) : f.to_fun = f | rfl | lemma | ring_invo.to_fun_eq_coe | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_invo"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
involution (f : ring_invo R) (x : R) : (f (f x).unop).unop = x | f.involution' x | lemma | ring_invo.involution | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_invo"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_coe_to_ring_equiv : has_coe (ring_invo R) (R ≃+* Rᵐᵒᵖ) | ⟨ring_invo.to_ring_equiv⟩ | instance | ring_invo.has_coe_to_ring_equiv | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_invo"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_ring_equiv (f : ring_invo R) (a : R) :
(f : R ≃+* Rᵐᵒᵖ) a = f a | rfl | lemma | ring_invo.coe_ring_equiv | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_invo"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_eq_zero_iff (f : ring_invo R) {x : R} : f x = 0 ↔ x = 0 | f.to_ring_equiv.map_eq_zero_iff | lemma | ring_invo.map_eq_zero_iff | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_invo"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ring_invo.id : ring_invo R | { involution' := λ r, rfl,
..(ring_equiv.to_opposite R) } | def | ring_invo.id | ring_theory | src/ring_theory/ring_invo.lean | [
"algebra.ring.equiv",
"algebra.ring.opposite"
] | [
"ring_equiv.to_opposite",
"ring_invo"
] | The identity function of a `comm_ring` is a ring involution. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_simple_module | (is_simple_order (submodule R M)) | abbreviation | is_simple_module | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_order",
"submodule"
] | A module is simple when it has only two submodules, `⊥` and `⊤`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_semisimple_module | (complemented_lattice (submodule R M)) | abbreviation | is_semisimple_module | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"complemented_lattice",
"submodule"
] | A module is semisimple when every submodule has a complement, or equivalently, the module
is a direct sum of simple modules. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_simple_module.nontrivial [is_simple_module R M] : nontrivial M | ⟨⟨0, begin
have h : (⊥ : submodule R M) ≠ ⊤ := bot_ne_top,
contrapose! h,
ext,
simp [submodule.mem_bot,submodule.mem_top, h x],
end⟩⟩ | theorem | is_simple_module.nontrivial | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"bot_ne_top",
"is_simple_module",
"nontrivial",
"submodule",
"submodule.mem_bot",
"submodule.mem_top"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_simple_module.congr (l : M ≃ₗ[R] N) [is_simple_module R N] : is_simple_module R M | (submodule.order_iso_map_comap l).is_simple_order | lemma | is_simple_module.congr | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module",
"is_simple_order",
"submodule.order_iso_map_comap"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_simple_module_iff_is_atom :
is_simple_module R m ↔ is_atom m | begin
rw ← set.is_simple_order_Iic_iff_is_atom,
apply order_iso.is_simple_order_iff,
exact submodule.map_subtype.rel_iso m,
end | theorem | is_simple_module_iff_is_atom | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_atom",
"is_simple_module",
"order_iso.is_simple_order_iff",
"set.is_simple_order_Iic_iff_is_atom",
"submodule.map_subtype.rel_iso"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_simple_module_iff_is_coatom :
is_simple_module R (M ⧸ m) ↔ is_coatom m | begin
rw ← set.is_simple_order_Ici_iff_is_coatom,
apply order_iso.is_simple_order_iff,
exact submodule.comap_mkq.rel_iso m,
end | theorem | is_simple_module_iff_is_coatom | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_coatom",
"is_simple_module",
"order_iso.is_simple_order_iff",
"set.is_simple_order_Ici_iff_is_coatom",
"submodule.comap_mkq.rel_iso"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
covby_iff_quot_is_simple {A B : submodule R M} (hAB : A ≤ B) :
A ⋖ B ↔ is_simple_module R (B ⧸ submodule.comap B.subtype A) | begin
set f : submodule R B ≃o set.Iic B := submodule.map_subtype.rel_iso B with hf,
rw [covby_iff_coatom_Iic hAB, is_simple_module_iff_is_coatom, ←order_iso.is_coatom_iff f, hf],
simp [-order_iso.is_coatom_iff, submodule.map_subtype.rel_iso, submodule.map_comap_subtype,
inf_eq_right.2 hAB],
end | theorem | covby_iff_quot_is_simple | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"covby_iff_coatom_Iic",
"is_simple_module",
"is_simple_module_iff_is_coatom",
"order_iso.is_coatom_iff",
"set.Iic",
"submodule",
"submodule.comap",
"submodule.map_comap_subtype",
"submodule.map_subtype.rel_iso"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_atom : is_atom m | is_simple_module_iff_is_atom.1 hm | lemma | is_simple_module.is_atom | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_atom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_semisimple_of_Sup_simples_eq_top
(h : Sup {m : submodule R M | is_simple_module R m} = ⊤) :
is_semisimple_module R M | complemented_lattice_of_Sup_atoms_eq_top (by simp_rw [← h, is_simple_module_iff_is_atom]) | theorem | is_semisimple_of_Sup_simples_eq_top | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"complemented_lattice_of_Sup_atoms_eq_top",
"is_semisimple_module",
"is_simple_module",
"is_simple_module_iff_is_atom",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
Sup_simples_eq_top : Sup {m : submodule R M | is_simple_module R m} = ⊤ | begin
simp_rw is_simple_module_iff_is_atom,
exact Sup_atoms_eq_top,
end | theorem | is_semisimple_module.Sup_simples_eq_top | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"Sup_atoms_eq_top",
"is_simple_module",
"is_simple_module_iff_is_atom",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_semisimple_submodule {m : submodule R M} : is_semisimple_module R m | begin
have f : submodule R m ≃o set.Iic m := submodule.map_subtype.rel_iso m,
exact f.complemented_lattice_iff.2 is_modular_lattice.complemented_lattice_Iic,
end | instance | is_semisimple_module.is_semisimple_submodule | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_modular_lattice.complemented_lattice_Iic",
"is_semisimple_module",
"set.Iic",
"submodule",
"submodule.map_subtype.rel_iso"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_semisimple_iff_top_eq_Sup_simples :
Sup {m : submodule R M | is_simple_module R m} = ⊤ ↔ is_semisimple_module R M | ⟨is_semisimple_of_Sup_simples_eq_top, by { introI, exact is_semisimple_module.Sup_simples_eq_top }⟩ | theorem | is_semisimple_iff_top_eq_Sup_simples | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_semisimple_module",
"is_semisimple_module.Sup_simples_eq_top",
"is_simple_module",
"submodule"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
injective_or_eq_zero [is_simple_module R M] (f : M →ₗ[R] N) :
function.injective f ∨ f = 0 | begin
rw [← ker_eq_bot, ← ker_eq_top],
apply eq_bot_or_eq_top,
end | theorem | linear_map.injective_or_eq_zero | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
injective_of_ne_zero [is_simple_module R M] {f : M →ₗ[R] N} (h : f ≠ 0) :
function.injective f | f.injective_or_eq_zero.resolve_right h | theorem | linear_map.injective_of_ne_zero | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
surjective_or_eq_zero [is_simple_module R N] (f : M →ₗ[R] N) :
function.surjective f ∨ f = 0 | begin
rw [← range_eq_top, ← range_eq_bot, or_comm],
apply eq_bot_or_eq_top,
end | theorem | linear_map.surjective_or_eq_zero | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
surjective_of_ne_zero [is_simple_module R N] {f : M →ₗ[R] N} (h : f ≠ 0) :
function.surjective f | f.surjective_or_eq_zero.resolve_right h | theorem | linear_map.surjective_of_ne_zero | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bijective_or_eq_zero [is_simple_module R M] [is_simple_module R N]
(f : M →ₗ[R] N) :
function.bijective f ∨ f = 0 | begin
by_cases h : f = 0,
{ right,
exact h },
exact or.intro_left _ ⟨injective_of_ne_zero h, surjective_of_ne_zero h⟩,
end | theorem | linear_map.bijective_or_eq_zero | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module"
] | **Schur's Lemma** for linear maps between (possibly distinct) simple modules | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
bijective_of_ne_zero [is_simple_module R M] [is_simple_module R N]
{f : M →ₗ[R] N} (h : f ≠ 0):
function.bijective f | f.bijective_or_eq_zero.resolve_right h | theorem | linear_map.bijective_of_ne_zero | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_simple_module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_coatom_ker_of_surjective [is_simple_module R N] {f : M →ₗ[R] N}
(hf : function.surjective f) : is_coatom f.ker | begin
rw ←is_simple_module_iff_is_coatom,
exact is_simple_module.congr (f.quot_ker_equiv_of_surjective hf)
end | theorem | linear_map.is_coatom_ker_of_surjective | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"is_coatom",
"is_simple_module",
"is_simple_module.congr"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.module.End.division_ring
[decidable_eq (module.End R M)] [is_simple_module R M] :
division_ring (module.End R M) | { inv := λ f, if h : f = 0 then 0 else (linear_map.inverse f
(equiv.of_bijective _ (bijective_of_ne_zero h)).inv_fun
(equiv.of_bijective _ (bijective_of_ne_zero h)).left_inv
(equiv.of_bijective _ (bijective_of_ne_zero h)).right_inv),
exists_pair_ne := ⟨0, 1, begin
haveI := is_simple_module.nontrivial ... | instance | module.End.division_ring | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"division_ring",
"equiv.of_bijective",
"exists_pair_ne",
"inv_fun",
"inv_zero",
"is_simple_module",
"is_simple_module.nontrivial",
"linear_map.inverse",
"module.End",
"module.End.ring",
"mul_inv_cancel",
"ring"
] | Schur's Lemma makes the endomorphism ring of a simple module a division ring. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
jordan_holder_module : jordan_holder_lattice (submodule R M) | { is_maximal := (⋖),
lt_of_is_maximal := λ x y, covby.lt,
sup_eq_of_is_maximal := λ x y z hxz hyz, wcovby.sup_eq hxz.wcovby hyz.wcovby,
is_maximal_inf_left_of_is_maximal_sup := λ A B, inf_covby_of_covby_sup_of_covby_sup_left,
iso ... | instance | jordan_holder_module | ring_theory | src/ring_theory/simple_module.lean | [
"linear_algebra.isomorphisms",
"order.jordan_holder"
] | [
"covby.lt",
"inf_comm",
"inf_covby_of_covby_sup_of_covby_sup_left",
"iso",
"jordan_holder_lattice",
"linear_map.quotient_inf_equiv_sup_quotient",
"submodule",
"sup_comm",
"wcovby.sup_eq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_eq_lsmul_rtensor (a : A) (x : M ⊗[R] N) : a • x = (lsmul R M a).rtensor N x | rfl | lemma | tensor_product.algebra_tensor_module.smul_eq_lsmul_rtensor | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
curry (f : (M ⊗[R] N) →ₗ[A] P) : M →ₗ[A] (N →ₗ[R] P) | { to_fun := curry (f.restrict_scalars R),
map_smul' := λ c x, linear_map.ext $ λ y, f.map_smul c (x ⊗ₜ y),
.. curry (f.restrict_scalars R) } | def | tensor_product.algebra_tensor_module.curry | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_map.ext"
] | Heterobasic version of `tensor_product.curry`:
Given a linear map `M ⊗[R] N →[A] P`, compose it with the canonical
bilinear map `M →[A] N →[R] M ⊗[R] N` to form a bilinear map `M →[A] N →[R] P`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
restrict_scalars_curry (f : (M ⊗[R] N) →ₗ[A] P) :
restrict_scalars R (curry f) = curry (f.restrict_scalars R) | rfl | lemma | tensor_product.algebra_tensor_module.restrict_scalars_curry | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"restrict_scalars"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
curry_injective :
function.injective (curry : (M ⊗ N →ₗ[A] P) → (M →ₗ[A] N →ₗ[R] P)) | λ x y h, linear_map.restrict_scalars_injective R $ curry_injective $
(congr_arg (linear_map.restrict_scalars R) h : _) | lemma | tensor_product.algebra_tensor_module.curry_injective | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_map.restrict_scalars",
"linear_map.restrict_scalars_injective"
] | Just as `tensor_product.ext` is marked `ext` instead of `tensor_product.ext'`, this is
a better `ext` lemma than `tensor_product.algebra_tensor_module.ext` below.
See note [partially-applied ext lemmas]. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
ext {g h : (M ⊗[R] N) →ₗ[A] P}
(H : ∀ x y, g (x ⊗ₜ y) = h (x ⊗ₜ y)) : g = h | curry_injective $ linear_map.ext₂ H | theorem | tensor_product.algebra_tensor_module.ext | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_map.ext₂"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lift (f : M →ₗ[A] (N →ₗ[R] P)) : (M ⊗[R] N) →ₗ[A] P | { map_smul' := λ c, show ∀ x : M ⊗[R] N, (lift (f.restrict_scalars R)).comp (lsmul R _ c) x =
(lsmul R _ c).comp (lift (f.restrict_scalars R)) x,
from ext_iff.1 $ tensor_product.ext' $ λ x y,
by simp only [comp_apply, algebra.lsmul_coe, smul_tmul', lift.tmul, coe_restrict_scalars_eq_coe,
f.map_smu... | def | tensor_product.algebra_tensor_module.lift | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra.lsmul_coe",
"lift",
"tensor_product.ext'"
] | Heterobasic version of `tensor_product.lift`:
Constructing a linear map `M ⊗[R] N →[A] P` given a bilinear map `M →[A] N →[R] P` with the
property that its composition with the canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is
the given bilinear map `M →[A] N →[R] P`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift_tmul (f : M →ₗ[A] (N →ₗ[R] P)) (x : M) (y : N) :
lift f (x ⊗ₜ y) = f x y | rfl | lemma | tensor_product.algebra_tensor_module.lift_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"lift"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
uncurry : (M →ₗ[A] (N →ₗ[R] P)) →ₗ[A] ((M ⊗[R] N) →ₗ[A] P) | { to_fun := lift,
map_add' := λ f g, ext $ λ x y, by simp only [lift_tmul, add_apply],
map_smul' := λ c f, ext $ λ x y, by simp only [lift_tmul, smul_apply, ring_hom.id_apply] } | def | tensor_product.algebra_tensor_module.uncurry | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"lift",
"ring_hom.id_apply"
] | Heterobasic version of `tensor_product.uncurry`:
Linearly constructing a linear map `M ⊗[R] N →[A] P` given a bilinear map `M →[A] N →[R] P`
with the property that its composition with the canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is
the given bilinear map `M →[A] N →[R] P`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lcurry : ((M ⊗[R] N) →ₗ[A] P) →ₗ[A] (M →ₗ[A] (N →ₗ[R] P)) | { to_fun := curry,
map_add' := λ f g, rfl,
map_smul' := λ c f, rfl } | def | tensor_product.algebra_tensor_module.lcurry | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | Heterobasic version of `tensor_product.lcurry`:
Given a linear map `M ⊗[R] N →[A] P`, compose it with the canonical
bilinear map `M →[A] N →[R] M ⊗[R] N` to form a bilinear map `M →[A] N →[R] P`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lift.equiv : (M →ₗ[A] (N →ₗ[R] P)) ≃ₗ[A] ((M ⊗[R] N) →ₗ[A] P) | linear_equiv.of_linear (uncurry R A M N P) (lcurry R A M N P)
(linear_map.ext $ λ f, ext $ λ x y, lift_tmul _ x y)
(linear_map.ext $ λ f, linear_map.ext $ λ x, linear_map.ext $ λ y, lift_tmul f x y) | def | tensor_product.algebra_tensor_module.lift.equiv | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_equiv.of_linear",
"linear_map.ext"
] | Heterobasic version of `tensor_product.lift.equiv`:
A linear equivalence constructing a linear map `M ⊗[R] N →[A] P` given a
bilinear map `M →[A] N →[R] P` with the property that its composition with the
canonical bilinear map `M →[A] N →[R] M ⊗[R] N` is the given bilinear map `M →[A] N →[R] P`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mk : M →ₗ[A] N →ₗ[R] M ⊗[R] N | { map_smul' := λ c x, rfl,
.. mk R M N } | def | tensor_product.algebra_tensor_module.mk | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | Heterobasic version of `tensor_product.mk`:
The canonical bilinear map `M →[A] N →[R] M ⊗[R] N`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
assoc : ((M ⊗[A] P) ⊗[R] N) ≃ₗ[A] (M ⊗[A] (P ⊗[R] N)) | linear_equiv.of_linear
(lift $ tensor_product.uncurry A _ _ _ $ comp (lcurry R A _ _ _) $
tensor_product.mk A M (P ⊗[R] N))
(tensor_product.uncurry A _ _ _ $ comp (uncurry R A _ _ _) $
by { apply tensor_product.curry, exact (mk R A _ _) })
(by { ext, refl, })
(by { ext, simp only [curry_apply, tensor_pr... | def | tensor_product.algebra_tensor_module.assoc | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"curry_apply",
"lift",
"linear_equiv.of_linear",
"linear_map.comp_apply",
"tensor_product.curry",
"tensor_product.curry_apply",
"tensor_product.mk",
"tensor_product.mk_apply",
"tensor_product.uncurry",
"tensor_product.uncurry_apply"
] | Heterobasic version of `tensor_product.assoc`:
Linear equivalence between `(M ⊗[A] N) ⊗[R] P` and `M ⊗[A] (N ⊗[R] P)`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
base_change (f : M →ₗ[R] N) : A ⊗[R] M →ₗ[A] A ⊗[R] N | { to_fun := f.ltensor A,
map_add' := (f.ltensor A).map_add,
map_smul' := λ a x,
show (f.ltensor A) (rtensor M (linear_map.mul R A a) x) =
(rtensor N ((linear_map.mul R A) a)) ((ltensor A f) x),
by { rw [← comp_apply, ← comp_apply],
simp only [ltensor_comp_rtensor, rtensor_comp_ltensor] } } | def | linear_map.base_change | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_map.mul"
] | `base_change A f` for `f : M →ₗ[R] N` is the `A`-linear map `A ⊗[R] M →ₗ[A] A ⊗[R] N`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
base_change_tmul (a : A) (x : M) :
f.base_change A (a ⊗ₜ x) = a ⊗ₜ (f x) | rfl | lemma | linear_map.base_change_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change_eq_ltensor :
(f.base_change A : A ⊗ M → A ⊗ N) = f.ltensor A | rfl | lemma | linear_map.base_change_eq_ltensor | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change_add :
(f + g).base_change A = f.base_change A + g.base_change A | by { ext, simp [base_change_eq_ltensor], } | lemma | linear_map.base_change_add | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change_zero : base_change A (0 : M →ₗ[R] N) = 0 | by { ext, simp [base_change_eq_ltensor], } | lemma | linear_map.base_change_zero | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change_smul : (r • f).base_change A = r • (f.base_change A) | by { ext, simp [base_change_tmul], } | lemma | linear_map.base_change_smul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change_hom : (M →ₗ[R] N) →ₗ[R] A ⊗[R] M →ₗ[A] A ⊗[R] N | { to_fun := base_change A,
map_add' := base_change_add,
map_smul' := base_change_smul } | def | linear_map.base_change_hom | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | `base_change` as a linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
base_change_sub :
(f - g).base_change A = f.base_change A - g.base_change A | by { ext, simp [base_change_eq_ltensor], } | lemma | linear_map.base_change_sub | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
base_change_neg : (-f).base_change A = -(f.base_change A) | by { ext, simp [base_change_eq_ltensor], } | lemma | linear_map.base_change_neg | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_aux (a₁ : A) (b₁ : B) : (A ⊗[R] B) →ₗ[R] (A ⊗[R] B) | tensor_product.map (linear_map.mul_left R a₁) (linear_map.mul_left R b₁) | def | algebra.tensor_product.mul_aux | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_map.mul_left",
"tensor_product.map"
] | (Implementation detail)
The multiplication map on `A ⊗[R] B`,
for a fixed pure tensor in the first argument,
as an `R`-linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_aux_apply (a₁ a₂ : A) (b₁ b₂ : B) :
(mul_aux a₁ b₁) (a₂ ⊗ₜ[R] b₂) = (a₁ * a₂) ⊗ₜ[R] (b₁ * b₂) | rfl | lemma | algebra.tensor_product.mul_aux_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul : (A ⊗[R] B) →ₗ[R] (A ⊗[R] B) →ₗ[R] (A ⊗[R] B) | tensor_product.lift $ linear_map.mk₂ R mul_aux
(λ x₁ x₂ y, tensor_product.ext' $ λ x' y',
by simp only [mul_aux_apply, linear_map.add_apply, add_mul, add_tmul])
(λ c x y, tensor_product.ext' $ λ x' y',
by simp only [mul_aux_apply, linear_map.smul_apply, smul_tmul', smul_mul_assoc])
(λ x y₁ y₂, tensor_prod... | def | algebra.tensor_product.mul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"linear_map.add_apply",
"linear_map.mk₂",
"linear_map.smul_apply",
"smul_mul_assoc",
"tensor_product.ext'",
"tensor_product.lift"
] | (Implementation detail)
The multiplication map on `A ⊗[R] B`,
as an `R`-bilinear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_apply (a₁ a₂ : A) (b₁ b₂ : B) :
mul (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂) = (a₁ * a₂) ⊗ₜ[R] (b₁ * b₂) | rfl | lemma | algebra.tensor_product.mul_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_assoc' (mul : (A ⊗[R] B) →ₗ[R] (A ⊗[R] B) →ₗ[R] (A ⊗[R] B))
(h : ∀ (a₁ a₂ a₃ : A) (b₁ b₂ b₃ : B),
mul (mul (a₁ ⊗ₜ[R] b₁) (a₂ ⊗ₜ[R] b₂)) (a₃ ⊗ₜ[R] b₃) =
mul (a₁ ⊗ₜ[R] b₁) (mul (a₂ ⊗ₜ[R] b₂) (a₃ ⊗ₜ[R] b₃))) :
∀ (x y z : A ⊗[R] B), mul (mul x y) z = mul x (mul y z) | begin
intros,
apply tensor_product.induction_on x,
{ simp only [linear_map.map_zero, linear_map.zero_apply], },
apply tensor_product.induction_on y,
{ simp only [linear_map.map_zero, forall_const, linear_map.zero_apply], },
apply tensor_product.induction_on z,
{ simp only [linear_map.map_zero, forall_cons... | lemma | algebra.tensor_product.mul_assoc' | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"forall_const",
"linear_map.add_apply",
"linear_map.map_add",
"linear_map.map_zero",
"linear_map.zero_apply",
"tensor_product.induction_on"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_assoc (x y z : A ⊗[R] B) : mul (mul x y) z = mul x (mul y z) | mul_assoc' mul (by { intros, simp only [mul_apply, mul_assoc], }) x y z | lemma | algebra.tensor_product.mul_assoc | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"mul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
one_mul (x : A ⊗[R] B) : mul (1 ⊗ₜ 1) x = x | begin
apply tensor_product.induction_on x;
simp {contextual := tt},
end | lemma | algebra.tensor_product.one_mul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"one_mul",
"tensor_product.induction_on"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_one (x : A ⊗[R] B) : mul x (1 ⊗ₜ 1) = x | begin
apply tensor_product.induction_on x;
simp {contextual := tt},
end | lemma | algebra.tensor_product.mul_one | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"mul_one",
"tensor_product.induction_on"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
one_def : (1 : A ⊗[R] B) = (1 : A) ⊗ₜ (1 : B) | rfl | lemma | algebra.tensor_product.one_def | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tmul_mul_tmul (a₁ a₂ : A) (b₁ b₂ : B) :
(a₁ ⊗ₜ[R] b₁) * (a₂ ⊗ₜ[R] b₂) = (a₁ * a₂) ⊗ₜ[R] (b₁ * b₂) | rfl | lemma | algebra.tensor_product.tmul_mul_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
tmul_pow (a : A) (b : B) (k : ℕ) :
(a ⊗ₜ[R] b)^k = (a^k) ⊗ₜ[R] (b^k) | begin
induction k with k ih,
{ simp [one_def], },
{ simp [pow_succ, ih], }
end | lemma | algebra.tensor_product.tmul_pow | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"ih",
"pow_succ"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
include_left_ring_hom : A →+* A ⊗[R] B | { to_fun := λ a, a ⊗ₜ 1,
map_zero' := by simp,
map_add' := by simp [add_tmul],
map_one' := rfl,
map_mul' := by simp } | def | algebra.tensor_product.include_left_ring_hom | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | The ring morphism `A →+* A ⊗[R] B` sending `a` to `a ⊗ₜ 1`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
is_scalar_tower_right
[monoid S] [distrib_mul_action S A] [is_scalar_tower S A A] [smul_comm_class R S A] :
is_scalar_tower S (A ⊗[R] B) (A ⊗[R] B) | { smul_assoc := λ r x y, begin
change (r • x) * y = r • (x * y),
apply tensor_product.induction_on y,
{ simp [smul_zero], },
{ apply tensor_product.induction_on x,
{ simp [smul_zero] },
{ intros a b a' b',
dsimp,
rw [tensor_product.smul_tmul', tensor_product.smul_tmul', tmul_... | instance | algebra.tensor_product.is_scalar_tower_right | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"distrib_mul_action",
"is_scalar_tower",
"monoid",
"smul_add",
"smul_assoc",
"smul_comm_class",
"smul_mul_assoc",
"smul_zero",
"tensor_product.induction_on",
"tensor_product.smul_tmul'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_comm_class_right
[monoid S] [distrib_mul_action S A] [smul_comm_class S A A] [smul_comm_class R S A] :
smul_comm_class S (A ⊗[R] B) (A ⊗[R] B) | { smul_comm := λ r x y, begin
change r • (x * y) = x * r • y,
apply tensor_product.induction_on y,
{ simp [smul_zero], },
{ apply tensor_product.induction_on x,
{ simp [smul_zero] },
{ intros a b a' b',
dsimp,
rw [tensor_product.smul_tmul', tensor_product.smul_tmul', tmul_mul... | instance | algebra.tensor_product.smul_comm_class_right | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"distrib_mul_action",
"monoid",
"mul_smul_comm",
"smul_add",
"smul_comm_class",
"smul_zero",
"tensor_product.induction_on",
"tensor_product.smul_tmul'"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
left_algebra [smul_comm_class R S A] : algebra S (A ⊗[R] B) | { commutes' := λ r x,
begin
dsimp only [ring_hom.to_fun_eq_coe, ring_hom.comp_apply, include_left_ring_hom_apply],
rw [algebra_map_eq_smul_one, ←smul_tmul', ←one_def, mul_smul_comm, smul_mul_assoc, mul_one,
one_mul],
end,
smul_def' := λ r x,
begin
dsimp only [ring_hom.to_fun_eq_coe, ring_hom.c... | instance | algebra.tensor_product.left_algebra | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra",
"algebra_map",
"module",
"mul_one",
"mul_smul_comm",
"one_mul",
"ring_hom.comp_apply",
"ring_hom.to_fun_eq_coe",
"smul_comm_class",
"smul_mul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_map_apply [smul_comm_class R S A] (r : S) :
(algebra_map S (A ⊗[R] B)) r = ((algebra_map S A) r) ⊗ₜ 1 | rfl | lemma | algebra.tensor_product.algebra_map_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra_map",
"algebra_map_apply",
"smul_comm_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext {g h : (A ⊗[R] B) →ₐ[R] C}
(H : ∀ a b, g (a ⊗ₜ b) = h (a ⊗ₜ b)) : g = h | begin
apply @alg_hom.to_linear_map_injective R (A ⊗[R] B) C _ _ _ _ _ _ _ _,
ext,
simp [H],
end | theorem | algebra.tensor_product.ext | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"alg_hom.to_linear_map_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
include_left : A →ₐ[R] A ⊗[R] B | { commutes' := by simp,
..include_left_ring_hom } | def | algebra.tensor_product.include_left | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | The `R`-algebra morphism `A →ₐ[R] A ⊗[R] B` sending `a` to `a ⊗ₜ 1`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
include_left_apply (a : A) : (include_left : A →ₐ[R] A ⊗[R] B) a = a ⊗ₜ 1 | rfl | lemma | algebra.tensor_product.include_left_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
include_right : B →ₐ[R] A ⊗[R] B | { to_fun := λ b, 1 ⊗ₜ b,
map_zero' := by simp,
map_add' := by simp [tmul_add],
map_one' := rfl,
map_mul' := by simp,
commutes' := λ r,
begin
simp only [algebra_map_apply],
transitivity r • ((1 : A) ⊗ₜ[R] (1 : B)),
{ rw [←tmul_smul, algebra.smul_def], simp, },
{ simp [algebra.smul_def], },
... | def | algebra.tensor_product.include_right | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra.smul_def",
"algebra_map_apply"
] | The algebra morphism `B →ₐ[R] A ⊗[R] B` sending `b` to `1 ⊗ₜ b`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
include_right_apply (b : B) : (include_right : B →ₐ[R] A ⊗[R] B) b = 1 ⊗ₜ b | rfl | lemma | algebra.tensor_product.include_right_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
include_left_comp_algebra_map {R S T : Type*} [comm_ring R] [comm_ring S] [comm_ring T]
[algebra R S] [algebra R T] :
(include_left.to_ring_hom.comp (algebra_map R S) : R →+* S ⊗[R] T) =
include_right.to_ring_hom.comp (algebra_map R T) | by { ext, simp } | lemma | algebra.tensor_product.include_left_comp_algebra_map | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra",
"algebra_map",
"comm_ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
right_algebra : algebra B (A ⊗[R] B) | (algebra.tensor_product.include_right.to_ring_hom : B →+* A ⊗[R] B).to_algebra | def | algebra.tensor_product.right_algebra | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra"
] | `S ⊗[R] T` has a `T`-algebra structure. This is not a global instance or else the action of
`S` on `S ⊗[R] S` would be ambiguous. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
right_is_scalar_tower : is_scalar_tower R B (A ⊗[R] B) | is_scalar_tower.of_algebra_map_eq (λ r, (algebra.tensor_product.include_right.commutes r).symm) | instance | algebra.tensor_product.right_is_scalar_tower | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"is_scalar_tower",
"is_scalar_tower.of_algebra_map_eq"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
alg_hom_of_linear_map_tensor_product
(f : A ⊗[R] B →ₗ[R] C)
(w₁ : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ (b₁ * b₂)) = f (a₁ ⊗ₜ b₁) * f (a₂ ⊗ₜ b₂))
(w₂ : ∀ r, f ((algebra_map R A) r ⊗ₜ[R] 1) = (algebra_map R C) r):
A ⊗[R] B →ₐ[R] C | { map_one' := by rw [←(algebra_map R C).map_one, ←w₂, (algebra_map R A).map_one]; refl,
map_zero' := by rw [linear_map.to_fun_eq_coe, map_zero],
map_mul' := λ x y, by
{ rw linear_map.to_fun_eq_coe,
apply tensor_product.induction_on x,
{ rw [zero_mul, map_zero, zero_mul] },
{ intros a₁ b₁,
apply ... | def | algebra.tensor_product.alg_hom_of_linear_map_tensor_product | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra_map",
"algebra_map_apply",
"linear_map.to_fun_eq_coe",
"map_one",
"mul_zero",
"tensor_product.induction_on",
"zero_mul"
] | Build an algebra morphism from a linear map out of a tensor product,
and evidence of multiplicativity on pure tensors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_hom_of_linear_map_tensor_product_apply (f w₁ w₂ x) :
(alg_hom_of_linear_map_tensor_product f w₁ w₂ : A ⊗[R] B →ₐ[R] C) x = f x | rfl | lemma | algebra.tensor_product.alg_hom_of_linear_map_tensor_product_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
alg_equiv_of_linear_equiv_tensor_product
(f : A ⊗[R] B ≃ₗ[R] C)
(w₁ : ∀ (a₁ a₂ : A) (b₁ b₂ : B), f ((a₁ * a₂) ⊗ₜ (b₁ * b₂)) = f (a₁ ⊗ₜ b₁) * f (a₂ ⊗ₜ b₂))
(w₂ : ∀ r, f ((algebra_map R A) r ⊗ₜ[R] 1) = (algebra_map R C) r):
A ⊗[R] B ≃ₐ[R] C | { .. alg_hom_of_linear_map_tensor_product (f : A ⊗[R] B →ₗ[R] C) w₁ w₂,
.. f } | def | algebra.tensor_product.alg_equiv_of_linear_equiv_tensor_product | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra_map"
] | Build an algebra equivalence from a linear equivalence out of a tensor product,
and evidence of multiplicativity on pure tensors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_equiv_of_linear_equiv_tensor_product_apply (f w₁ w₂ x) :
(alg_equiv_of_linear_equiv_tensor_product f w₁ w₂ : A ⊗[R] B ≃ₐ[R] C) x = f x | rfl | lemma | algebra.tensor_product.alg_equiv_of_linear_equiv_tensor_product_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
alg_equiv_of_linear_equiv_triple_tensor_product
(f : ((A ⊗[R] B) ⊗[R] C) ≃ₗ[R] D)
(w₁ : ∀ (a₁ a₂ : A) (b₁ b₂ : B) (c₁ c₂ : C),
f ((a₁ * a₂) ⊗ₜ (b₁ * b₂) ⊗ₜ (c₁ * c₂)) = f (a₁ ⊗ₜ b₁ ⊗ₜ c₁) * f (a₂ ⊗ₜ b₂ ⊗ₜ c₂))
(w₂ : ∀ r, f (((algebra_map R A) r ⊗ₜ[R] (1 : B)) ⊗ₜ[R] (1 : C)) = (algebra_map R D) r) :
(A ⊗[R] ... | { to_fun := f,
map_mul' := λ x y,
begin
apply tensor_product.induction_on x,
{ simp only [map_zero, zero_mul] },
{ intros ab₁ c₁,
apply tensor_product.induction_on y,
{ simp only [map_zero, mul_zero] },
{ intros ab₂ c₂,
apply tensor_product.induction_on ab₁,
{ simp only... | def | algebra.tensor_product.alg_equiv_of_linear_equiv_triple_tensor_product | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra_map",
"mul_zero",
"tensor_product.induction_on",
"zero_mul"
] | Build an algebra equivalence from a linear equivalence out of a triple tensor product,
and evidence of multiplicativity on pure tensors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_equiv_of_linear_equiv_triple_tensor_product_apply (f w₁ w₂ x) :
(alg_equiv_of_linear_equiv_triple_tensor_product f w₁ w₂ : (A ⊗[R] B) ⊗[R] C ≃ₐ[R] D) x = f x | rfl | lemma | algebra.tensor_product.alg_equiv_of_linear_equiv_triple_tensor_product_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lid : R ⊗[R] A ≃ₐ[R] A | alg_equiv_of_linear_equiv_tensor_product (tensor_product.lid R A)
(by simp [mul_smul]) (by simp [algebra.smul_def]) | def | algebra.tensor_product.lid | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra.smul_def",
"tensor_product.lid"
] | The base ring is a left identity for the tensor product of algebra, up to algebra isomorphism. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
lid_tmul (r : R) (a : A) :
(tensor_product.lid R A : (R ⊗ A → A)) (r ⊗ₜ a) = r • a | by simp [tensor_product.lid] | theorem | algebra.tensor_product.lid_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"tensor_product.lid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
rid : A ⊗[R] R ≃ₐ[R] A | alg_equiv_of_linear_equiv_tensor_product (tensor_product.rid R A)
(by simp [mul_smul]) (by simp [algebra.smul_def]) | def | algebra.tensor_product.rid | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra.smul_def",
"tensor_product.rid"
] | The base ring is a right identity for the tensor product of algebra, up to algebra isomorphism. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
rid_tmul (r : R) (a : A) :
(tensor_product.rid R A : (A ⊗ R → A)) (a ⊗ₜ r) = r • a | by simp [tensor_product.rid] | theorem | algebra.tensor_product.rid_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"tensor_product.rid"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
comm : A ⊗[R] B ≃ₐ[R] B ⊗[R] A | alg_equiv_of_linear_equiv_tensor_product (tensor_product.comm R A B)
(by simp)
(λ r, begin
transitivity r • ((1 : B) ⊗ₜ[R] (1 : A)),
{ rw [←tmul_smul, algebra.smul_def], simp, },
{ simp [algebra.smul_def], },
end) | def | algebra.tensor_product.comm | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra.smul_def",
"comm",
"tensor_product.comm"
] | The tensor product of R-algebras is commutative, up to algebra isomorphism. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
comm_tmul (a : A) (b : B) :
(tensor_product.comm R A B : (A ⊗[R] B → B ⊗[R] A)) (a ⊗ₜ b) = (b ⊗ₜ a) | by simp [tensor_product.comm] | theorem | algebra.tensor_product.comm_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"tensor_product.comm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
adjoin_tmul_eq_top : adjoin R {t : A ⊗[R] B | ∃ a b, a ⊗ₜ[R] b = t} = ⊤ | top_le_iff.mp $ (top_le_iff.mpr $ span_tmul_eq_top R A B).trans (span_le_adjoin R _) | lemma | algebra.tensor_product.adjoin_tmul_eq_top | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
assoc_aux_1 (a₁ a₂ : A) (b₁ b₂ : B) (c₁ c₂ : C) :
(tensor_product.assoc R A B C) (((a₁ * a₂) ⊗ₜ[R] (b₁ * b₂)) ⊗ₜ[R] (c₁ * c₂)) =
(tensor_product.assoc R A B C) ((a₁ ⊗ₜ[R] b₁) ⊗ₜ[R] c₁) *
(tensor_product.assoc R A B C) ((a₂ ⊗ₜ[R] b₂) ⊗ₜ[R] c₂) | rfl | lemma | algebra.tensor_product.assoc_aux_1 | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"tensor_product.assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
assoc_aux_2 (r : R) :
(tensor_product.assoc R A B C) (((algebra_map R A) r ⊗ₜ[R] 1) ⊗ₜ[R] 1) =
(algebra_map R (A ⊗ (B ⊗ C))) r | rfl | lemma | algebra.tensor_product.assoc_aux_2 | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"algebra_map",
"tensor_product.assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
assoc : ((A ⊗[R] B) ⊗[R] C) ≃ₐ[R] (A ⊗[R] (B ⊗[R] C)) | alg_equiv_of_linear_equiv_triple_tensor_product
(tensor_product.assoc.{u v₁ v₂ v₃} R A B C : (A ⊗ B ⊗ C) ≃ₗ[R] (A ⊗ (B ⊗ C)))
(@algebra.tensor_product.assoc_aux_1.{u v₁ v₂ v₃} R _ A _ _ B _ _ C _ _)
(@algebra.tensor_product.assoc_aux_2.{u v₁ v₂ v₃} R _ A _ _ B _ _ C _ _) | def | algebra.tensor_product.assoc | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | The associator for tensor product of R-algebras, as an algebra isomorphism. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
assoc_tmul (a : A) (b : B) (c : C) :
((tensor_product.assoc R A B C) :
(A ⊗[R] B) ⊗[R] C → A ⊗[R] (B ⊗[R] C)) ((a ⊗ₜ b) ⊗ₜ c) = a ⊗ₜ (b ⊗ₜ c) | rfl | theorem | algebra.tensor_product.assoc_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"tensor_product.assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map (f : A →ₐ[R] B) (g : C →ₐ[R] D) : A ⊗[R] C →ₐ[R] B ⊗[R] D | alg_hom_of_linear_map_tensor_product
(tensor_product.map f.to_linear_map g.to_linear_map)
(by simp)
(by simp [alg_hom.commutes]) | def | algebra.tensor_product.map | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"alg_hom.commutes",
"tensor_product.map"
] | The tensor product of a pair of algebra morphisms. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_tmul (f : A →ₐ[R] B) (g : C →ₐ[R] D) (a : A) (c : C) :
map f g (a ⊗ₜ c) = f a ⊗ₜ g c | rfl | theorem | algebra.tensor_product.map_tmul | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_comp_include_left (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
(map f g).comp include_left = include_left.comp f | alg_hom.ext $ by simp | lemma | algebra.tensor_product.map_comp_include_left | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"alg_hom.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_comp_include_right (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
(map f g).comp include_right = include_right.comp g | alg_hom.ext $ by simp | lemma | algebra.tensor_product.map_comp_include_right | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"alg_hom.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_range (f : A →ₐ[R] B) (g : C →ₐ[R] D) :
(map f g).range = (include_left.comp f).range ⊔ (include_right.comp g).range | begin
apply le_antisymm,
{ rw [←map_top, ←adjoin_tmul_eq_top, ←adjoin_image, adjoin_le_iff],
rintros _ ⟨_, ⟨a, b, rfl⟩, rfl⟩,
rw [map_tmul, ←_root_.mul_one (f a), ←_root_.one_mul (g b), ←tmul_mul_tmul],
exact mul_mem_sup (alg_hom.mem_range_self _ a) (alg_hom.mem_range_self _ b) },
{ rw [←map_comp_incl... | lemma | algebra.tensor_product.map_range | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"alg_hom.mem_range_self",
"alg_hom.range_comp_le_range",
"sup_le"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr (f : A ≃ₐ[R] B) (g : C ≃ₐ[R] D) : A ⊗[R] C ≃ₐ[R] B ⊗[R] D | alg_equiv.of_alg_hom (map f g) (map f.symm g.symm)
(ext $ λ b d, by simp)
(ext $ λ a c, by simp) | def | algebra.tensor_product.congr | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [
"alg_equiv.of_alg_hom"
] | Construct an isomorphism between tensor products of R-algebras
from isomorphisms between the tensor factors. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
congr_apply (f : A ≃ₐ[R] B) (g : C ≃ₐ[R] D) (x) :
congr f g x = (map (f : A →ₐ[R] B) (g : C →ₐ[R] D)) x | rfl | lemma | algebra.tensor_product.congr_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr_symm_apply (f : A ≃ₐ[R] B) (g : C ≃ₐ[R] D) (x) :
(congr f g).symm x = (map (f.symm : B →ₐ[R] A) (g.symm : D →ₐ[R] C)) x | rfl | lemma | algebra.tensor_product.congr_symm_apply | ring_theory | src/ring_theory/tensor_product.lean | [
"linear_algebra.finite_dimensional",
"ring_theory.adjoin.basic",
"linear_algebra.direct_sum.finsupp"
] | [] | 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.