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 |
|---|---|---|---|---|---|---|---|---|---|---|
End_algebra_map_is_unit_inv_apply_eq_iff
{x : R} (h : is_unit (algebra_map R (module.End R M) x)) (m m' : M) :
h.unit⁻¹ m = m' ↔ m = x • m' | { mp := λ H, ((congr_arg h.unit H).symm.trans (End_is_unit_apply_inv_apply_of_is_unit h _)).symm,
mpr := λ H, H.symm ▸
begin
apply_fun h.unit using ((module.End_is_unit_iff _).mp h).injective,
erw [End_is_unit_apply_inv_apply_of_is_unit],
refl,
end } | lemma | module.End_algebra_map_is_unit_inv_apply_eq_iff | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"is_unit",
"module.End",
"module.End_is_unit_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
End_algebra_map_is_unit_inv_apply_eq_iff'
{x : R} (h : is_unit (algebra_map R (module.End R M) x)) (m m' : M) :
m' = h.unit⁻¹ m ↔ m = x • m' | { mp := λ H, ((congr_arg h.unit H).trans (End_is_unit_apply_inv_apply_of_is_unit h _)).symm,
mpr := λ H, H.symm ▸
begin
apply_fun h.unit using ((module.End_is_unit_iff _).mp h).injective,
erw [End_is_unit_apply_inv_apply_of_is_unit],
refl,
end } | lemma | module.End_algebra_map_is_unit_inv_apply_eq_iff' | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"is_unit",
"module.End",
"module.End_is_unit_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_algebra_map_mul (f : A →ₗ[R] B) (a : A) (r : R) :
f (algebra_map R A r * a) = algebra_map R B r * f a | by rw [←algebra.smul_def, ←algebra.smul_def, map_smul] | lemma | linear_map.map_algebra_map_mul | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map"
] | An alternate statement of `linear_map.map_smul` for when `algebra_map` is more convenient to
work with than `•`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_mul_algebra_map (f : A →ₗ[R] B) (a : A) (r : R) :
f (a * algebra_map R A r) = f a * algebra_map R B r | by rw [←algebra.commutes, ←algebra.commutes, map_algebra_map_mul] | lemma | linear_map.map_mul_algebra_map | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_nat : algebra ℕ R | { commutes' := nat.cast_commute,
smul_def' := λ _ _, nsmul_eq_mul _ _,
to_ring_hom := nat.cast_ring_hom R } | instance | algebra_nat | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"nat.cast_commute",
"nat.cast_ring_hom",
"nsmul_eq_mul"
] | Semiring ⥤ ℕ-Alg | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
nat_algebra_subsingleton : subsingleton (algebra ℕ R) | ⟨λ P Q, by { ext, simp, }⟩ | instance | nat_algebra_subsingleton | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_rat_algebra_map [ring R] [ring S] [algebra ℚ R] [algebra ℚ S]
(f : R →+* S) (r : ℚ) : f (algebra_map ℚ R r) = algebra_map ℚ S r | ring_hom.ext_iff.1 (subsingleton.elim (f.comp (algebra_map ℚ R)) (algebra_map ℚ S)) r | lemma | ring_hom.map_rat_algebra_map | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"algebra_map",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_rat {α} [division_ring α] [char_zero α] : algebra ℚ α | { smul := (•),
smul_def' := division_ring.qsmul_eq_mul',
to_ring_hom := rat.cast_hom α,
commutes' := rat.cast_commute } | instance | algebra_rat | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"char_zero",
"division_ring",
"rat.cast_commute",
"rat.cast_hom"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_map_rat_rat : algebra_map ℚ ℚ = ring_hom.id ℚ | subsingleton.elim _ _ | theorem | algebra_map_rat_rat | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"ring_hom.id"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_rat_subsingleton {α} [semiring α] :
subsingleton (algebra ℚ α) | ⟨λ x y, algebra.algebra_ext x y $ ring_hom.congr_fun $ subsingleton.elim _ _⟩ | instance | algebra_rat_subsingleton | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"algebra.algebra_ext",
"ring_hom.congr_fun",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_int : algebra ℤ R | { commutes' := int.cast_commute,
smul_def' := λ _ _, zsmul_eq_mul _ _,
to_ring_hom := int.cast_ring_hom R } | instance | algebra_int | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"int.cast_commute",
"int.cast_ring_hom",
"zsmul_eq_mul"
] | Ring ⥤ ℤ-Alg | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
algebra_map_int_eq : algebra_map ℤ R = int.cast_ring_hom R | rfl | lemma | algebra_map_int_eq | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"int.cast_ring_hom"
] | A special case of `eq_int_cast'` that happens to be true definitionally | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
int_algebra_subsingleton : subsingleton (algebra ℤ R) | ⟨λ P Q, by { ext, simp, }⟩ | instance | int_algebra_subsingleton | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
of_algebra_map_injective
[comm_semiring R] [semiring A] [algebra R A] [no_zero_divisors A]
(h : function.injective (algebra_map R A)) : no_zero_smul_divisors R A | ⟨λ c x hcx, (mul_eq_zero.mp ((smul_def c x).symm.trans hcx)).imp_left
(map_eq_zero_iff (algebra_map R A) h).mp⟩ | lemma | no_zero_smul_divisors.of_algebra_map_injective | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"no_zero_divisors",
"no_zero_smul_divisors",
"semiring"
] | If `algebra_map R A` is injective and `A` has no zero divisors,
`R`-multiples in `A` are zero only if one of the factors is zero.
Cannot be an instance because there is no `injective (algebra_map R A)` typeclass. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
algebra_map_injective [comm_ring R] [ring A] [nontrivial A]
[algebra R A] [no_zero_smul_divisors R A] :
function.injective (algebra_map R A) | suffices function.injective (λ (c : R), c • (1 : A)),
by { convert this, ext, rw [algebra.smul_def, mul_one] },
smul_left_injective R one_ne_zero | lemma | no_zero_smul_divisors.algebra_map_injective | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"algebra.smul_def",
"algebra_map",
"algebra_map_injective",
"comm_ring",
"mul_one",
"no_zero_smul_divisors",
"nontrivial",
"one_ne_zero",
"ring",
"smul_left_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.ne_zero.of_no_zero_smul_divisors (n : ℕ) [comm_ring R] [ne_zero (n : R)] [ring A]
[nontrivial A] [algebra R A] [no_zero_smul_divisors R A] : ne_zero (n : A) | ne_zero.nat_of_injective $ no_zero_smul_divisors.algebra_map_injective R A | lemma | ne_zero.of_no_zero_smul_divisors | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"comm_ring",
"ne_zero",
"ne_zero.nat_of_injective",
"no_zero_smul_divisors",
"no_zero_smul_divisors.algebra_map_injective",
"nontrivial",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
iff_algebra_map_injective [comm_ring R] [ring A] [is_domain A] [algebra R A] :
no_zero_smul_divisors R A ↔ function.injective (algebra_map R A) | ⟨@@no_zero_smul_divisors.algebra_map_injective R A _ _ _ _,
no_zero_smul_divisors.of_algebra_map_injective⟩ | lemma | no_zero_smul_divisors.iff_algebra_map_injective | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"algebra_map",
"comm_ring",
"is_domain",
"no_zero_smul_divisors",
"no_zero_smul_divisors.algebra_map_injective",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
char_zero.no_zero_smul_divisors_nat [semiring R] [no_zero_divisors R] [char_zero R] :
no_zero_smul_divisors ℕ R | no_zero_smul_divisors.of_algebra_map_injective $ (algebra_map ℕ R).injective_nat | instance | no_zero_smul_divisors.char_zero.no_zero_smul_divisors_nat | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"char_zero",
"no_zero_divisors",
"no_zero_smul_divisors",
"no_zero_smul_divisors.of_algebra_map_injective",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
char_zero.no_zero_smul_divisors_int [ring R] [no_zero_divisors R] [char_zero R] :
no_zero_smul_divisors ℤ R | no_zero_smul_divisors.of_algebra_map_injective $ (algebra_map ℤ R).injective_int | instance | no_zero_smul_divisors.char_zero.no_zero_smul_divisors_int | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"char_zero",
"no_zero_divisors",
"no_zero_smul_divisors",
"no_zero_smul_divisors.of_algebra_map_injective",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra.no_zero_smul_divisors [nontrivial A] [no_zero_divisors A] :
no_zero_smul_divisors R A | no_zero_smul_divisors.of_algebra_map_injective (algebra_map R A).injective | instance | no_zero_smul_divisors.algebra.no_zero_smul_divisors | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_map",
"no_zero_divisors",
"no_zero_smul_divisors",
"no_zero_smul_divisors.of_algebra_map_injective",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_compatible_smul (r : R) (m : M) : r • m = ((algebra_map R A) r) • m | by rw [←(one_smul A m), ←smul_assoc, algebra.smul_def, mul_one, one_smul] | lemma | algebra_compatible_smul | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra.smul_def",
"algebra_map",
"mul_one",
"one_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra_map_smul (r : R) (m : M) : ((algebra_map R A) r) • m = r • m | (algebra_compatible_smul A r m).symm | lemma | algebra_map_smul | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra_compatible_smul",
"algebra_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
int_cast_smul {k V : Type*} [comm_ring k] [add_comm_group V] [module k V] (r : ℤ) (x : V) :
(r : k) • x = r • x | algebra_map_smul k r x | lemma | int_cast_smul | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"add_comm_group",
"algebra_map_smul",
"comm_ring",
"module"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
no_zero_smul_divisors.trans (R A M : Type*) [comm_ring R] [ring A] [is_domain A] [algebra R A]
[add_comm_group M] [module R M] [module A M] [is_scalar_tower R A M] [no_zero_smul_divisors R A]
[no_zero_smul_divisors A M] : no_zero_smul_divisors R M | begin
refine ⟨λ r m h, _⟩,
rw [algebra_compatible_smul A r m] at h,
cases smul_eq_zero.1 h with H H,
{ have : function.injective (algebra_map R A) :=
no_zero_smul_divisors.iff_algebra_map_injective.1 infer_instance,
left,
exact (injective_iff_map_eq_zero _).1 this _ H },
{ right,
exact H }
e... | lemma | no_zero_smul_divisors.trans | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"add_comm_group",
"algebra",
"algebra_compatible_smul",
"algebra_map",
"comm_ring",
"is_domain",
"is_scalar_tower",
"module",
"no_zero_smul_divisors",
"ring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_scalar_tower.to_smul_comm_class : smul_comm_class R A M | ⟨λ r a m, by rw [algebra_compatible_smul A r (a • m), smul_smul, algebra.commutes, mul_smul,
←algebra_compatible_smul]⟩ | instance | is_scalar_tower.to_smul_comm_class | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra.commutes",
"algebra_compatible_smul",
"smul_comm_class",
"smul_smul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
is_scalar_tower.to_smul_comm_class' : smul_comm_class A R M | smul_comm_class.symm _ _ _ | instance | is_scalar_tower.to_smul_comm_class' | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"smul_comm_class",
"smul_comm_class.symm"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
algebra.to_smul_comm_class {R A} [comm_semiring R] [semiring A] [algebra R A] :
smul_comm_class R A A | is_scalar_tower.to_smul_comm_class | instance | algebra.to_smul_comm_class | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"algebra",
"comm_semiring",
"is_scalar_tower.to_smul_comm_class",
"semiring",
"smul_comm_class"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
smul_algebra_smul_comm (r : R) (a : A) (m : M) : a • r • m = r • a • m | smul_comm _ _ _ | lemma | smul_algebra_smul_comm | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_is_scalar_tower : has_coe (M →ₗ[A] N) (M →ₗ[R] N) | ⟨restrict_scalars R⟩ | instance | linear_map.coe_is_scalar_tower | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_restrict_scalars_eq_coe (f : M →ₗ[A] N) :
(f.restrict_scalars R : M → N) = f | rfl | lemma | linear_map.coe_restrict_scalars_eq_coe | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_coe_is_scalar_tower (f : M →ₗ[A] N) :
((f : M →ₗ[R] N) : M → N) = f | rfl | lemma | linear_map.coe_coe_is_scalar_tower | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
lto_fun (R : Type u) (M : Type v) (A : Type w)
[comm_semiring R] [add_comm_monoid M] [module R M] [comm_ring A] [algebra R A] :
(M →ₗ[R] A) →ₗ[A] (M → A) | { to_fun := linear_map.to_fun,
map_add' := λ f g, rfl,
map_smul' := λ c f, rfl } | def | linear_map.lto_fun | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [
"add_comm_monoid",
"algebra",
"comm_ring",
"comm_semiring",
"module"
] | `A`-linearly coerce a `R`-linear map from `M` to `A` to a function, given an algebra `A` over
a commutative semiring `R` and `M` a module over `R`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
linear_map.ker_restrict_scalars (f : M →ₗ[S] N) :
(f.restrict_scalars R).ker = f.ker.restrict_scalars R | rfl | lemma | linear_map.ker_restrict_scalars | algebra.algebra | src/algebra/algebra/basic.lean | [
"algebra.module.basic",
"algebra.module.ulift",
"algebra.ne_zero",
"algebra.punit_instances",
"algebra.ring.aut",
"algebra.ring.ulift",
"algebra.char_zero.lemmas",
"linear_algebra.basic",
"ring_theory.subring.basic",
"tactic.abel"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul : A →ₗ[R] A →ₗ[R] A | linear_map.mk₂ R (*) add_mul smul_mul_assoc mul_add mul_smul_comm | def | linear_map.mul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"linear_map.mk₂",
"mul_smul_comm",
"smul_mul_assoc"
] | The multiplication in a non-unital non-associative algebra is a bilinear map.
A weaker version of this for semirings exists as `add_monoid_hom.mul`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul' : A ⊗[R] A →ₗ[R] A | tensor_product.lift (mul R A) | def | linear_map.mul' | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"tensor_product.lift"
] | The multiplication map on a non-unital algebra, as an `R`-linear map from `A ⊗[R] A` to `A`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_left (a : A) : A →ₗ[R] A | mul R A a | def | linear_map.mul_left | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | The multiplication on the left in a non-unital algebra is a linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_right (a : A) : A →ₗ[R] A | (mul R A).flip a | def | linear_map.mul_right | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | The multiplication on the right in an algebra is a linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_left_right (ab : A × A) : A →ₗ[R] A | (mul_right R ab.snd).comp (mul_left R ab.fst) | def | linear_map.mul_left_right | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | Simultaneous multiplication on the left and right is a linear map. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
mul_left_to_add_monoid_hom (a : A) :
(mul_left R a : A →+ A) = add_monoid_hom.mul_left a | rfl | lemma | linear_map.mul_left_to_add_monoid_hom | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"add_monoid_hom.mul_left"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_to_add_monoid_hom (a : A) :
(mul_right R a : A →+ A) = add_monoid_hom.mul_right a | rfl | lemma | linear_map.mul_right_to_add_monoid_hom | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"add_monoid_hom.mul_right"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_apply' (a b : A) : mul R A a b = a * b | rfl | lemma | linear_map.mul_apply' | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_apply (a b : A) : mul_left R a b = a * b | rfl | lemma | linear_map.mul_left_apply | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_apply (a b : A) : mul_right R a b = b * a | rfl | lemma | linear_map.mul_right_apply | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_right_apply (a b x : A) : mul_left_right R (a, b) x = a * x * b | rfl | lemma | linear_map.mul_left_right_apply | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul'_apply {a b : A} : mul' R A (a ⊗ₜ b) = a * b | rfl | lemma | linear_map.mul'_apply | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_zero_eq_zero :
mul_left R (0 : A) = 0 | (mul R A).map_zero | lemma | linear_map.mul_left_zero_eq_zero | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_zero_eq_zero :
mul_right R (0 : A) = 0 | (mul R A).flip.map_zero | lemma | linear_map.mul_right_zero_eq_zero | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.non_unital_alg_hom.lmul : A →ₙₐ[R] (End R A) | { map_mul' := by { intros a b, ext c, exact mul_assoc a b c },
map_zero' := by { ext a, exact zero_mul a },
.. (mul R A) } | def | non_unital_alg_hom.lmul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"mul_assoc",
"zero_mul"
] | The multiplication in a non-unital algebra is a bilinear map.
A weaker version of this for non-unital non-associative algebras exists as `linear_map.mul`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
_root_.non_unital_alg_hom.coe_lmul_eq_mul : ⇑(non_unital_alg_hom.lmul R A) = mul R A | rfl | lemma | non_unital_alg_hom.coe_lmul_eq_mul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"non_unital_alg_hom.lmul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
commute_mul_left_right (a b : A) :
commute (mul_left R a) (mul_right R b) | by { ext c, exact (mul_assoc a c b).symm, } | lemma | linear_map.commute_mul_left_right | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"commute",
"mul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_mul (a b : A) :
mul_left R (a * b) = (mul_left R a).comp (mul_left R b) | by { ext, simp only [mul_left_apply, comp_apply, mul_assoc] } | lemma | linear_map.mul_left_mul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"mul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_mul (a b : A) :
mul_right R (a * b) = (mul_right R b).comp (mul_right R a) | by { ext, simp only [mul_right_apply, comp_apply, mul_assoc] } | lemma | linear_map.mul_right_mul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"mul_assoc"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
_root_.algebra.lmul : A →ₐ[R] (End R A) | { map_one' := by { ext a, exact one_mul a },
map_mul' := by { intros a b, ext c, exact mul_assoc a b c },
map_zero' := by { ext a, exact zero_mul a },
commutes' := by { intro r, ext a, exact (algebra.smul_def r a).symm, },
.. (linear_map.mul R A) } | def | algebra.lmul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"algebra.smul_def",
"linear_map.mul",
"mul_assoc",
"one_mul",
"zero_mul"
] | The multiplication in an algebra is an algebra homomorphism into the endomorphisms on
the algebra.
A weaker version of this for non-unital algebras exists as `non_unital_alg_hom.mul`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
_root_.algebra.coe_lmul_eq_mul : ⇑(algebra.lmul R A) = mul R A | rfl | lemma | algebra.coe_lmul_eq_mul | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"algebra.lmul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_eq_zero_iff (a : A) :
mul_left R a = 0 ↔ a = 0 | begin
split; intros h,
{ rw [← mul_one a, ← mul_left_apply a 1, h, linear_map.zero_apply], },
{ rw h, exact mul_left_zero_eq_zero, },
end | lemma | linear_map.mul_left_eq_zero_iff | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"linear_map.zero_apply",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_eq_zero_iff (a : A) :
mul_right R a = 0 ↔ a = 0 | begin
split; intros h,
{ rw [← one_mul a, ← mul_right_apply a 1, h, linear_map.zero_apply], },
{ rw h, exact mul_right_zero_eq_zero, },
end | lemma | linear_map.mul_right_eq_zero_iff | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"linear_map.zero_apply",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_one : mul_left R (1:A) = linear_map.id | by { ext, simp only [linear_map.id_coe, one_mul, id.def, mul_left_apply] } | lemma | linear_map.mul_left_one | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"linear_map.id",
"linear_map.id_coe",
"one_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_one : mul_right R (1:A) = linear_map.id | by { ext, simp only [linear_map.id_coe, mul_one, id.def, mul_right_apply] } | lemma | linear_map.mul_right_one | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"linear_map.id",
"linear_map.id_coe",
"mul_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pow_mul_left (a : A) (n : ℕ) :
(mul_left R a) ^ n = mul_left R (a ^ n) | by simpa only [mul_left, ←algebra.coe_lmul_eq_mul] using ((algebra.lmul R A).map_pow a n).symm | lemma | linear_map.pow_mul_left | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"algebra.lmul",
"map_pow"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
pow_mul_right (a : A) (n : ℕ) :
(mul_right R a) ^ n = mul_right R (a ^ n) | begin
simp only [mul_right, ←algebra.coe_lmul_eq_mul],
exact linear_map.coe_injective
(((mul_right R a).coe_pow n).symm ▸ (mul_right_iterate a n)),
end | lemma | linear_map.pow_mul_right | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"linear_map.coe_injective",
"mul_right_iterate"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_left_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
function.injective (mul_left R x) | begin
letI : nontrivial A := ⟨⟨x, 0, hx⟩⟩,
letI := no_zero_divisors.to_is_domain A,
exact mul_right_injective₀ hx,
end | lemma | linear_map.mul_left_injective | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"mul_left_injective",
"mul_right_injective₀",
"no_zero_divisors",
"no_zero_divisors.to_is_domain",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_right_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
function.injective (mul_right R x) | begin
letI : nontrivial A := ⟨⟨x, 0, hx⟩⟩,
letI := no_zero_divisors.to_is_domain A,
exact mul_left_injective₀ hx,
end | lemma | linear_map.mul_right_injective | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"mul_left_injective₀",
"mul_right_injective",
"no_zero_divisors",
"no_zero_divisors.to_is_domain",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mul_injective [no_zero_divisors A] {x : A} (hx : x ≠ 0) :
function.injective (mul R A x) | begin
letI : nontrivial A := ⟨⟨x, 0, hx⟩⟩,
letI := no_zero_divisors.to_is_domain A,
exact mul_right_injective₀ hx,
end | lemma | linear_map.mul_injective | algebra.algebra | src/algebra/algebra/bilinear.lean | [
"algebra.algebra.basic",
"algebra.hom.iterate",
"algebra.hom.non_unital_alg",
"linear_algebra.tensor_product"
] | [
"mul_right_injective₀",
"no_zero_divisors",
"no_zero_divisors.to_is_domain",
"nontrivial"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
alg_equiv (R : Type u) (A : Type v) (B : Type w)
[comm_semiring R] [semiring A] [semiring B] [algebra R A] [algebra R B]
extends A ≃ B, A ≃* B, A ≃+ B, A ≃+* B | (commutes' : ∀ r : R, to_fun (algebra_map R A r) = algebra_map R B r) | structure | alg_equiv | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"semiring"
] | An equivalence of algebras is an equivalence of rings commuting with the actions of scalars. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
alg_equiv_class (F : Type*) (R A B : out_param Type*)
[comm_semiring R] [semiring A] [semiring B] [algebra R A] [algebra R B]
extends ring_equiv_class F A B | (commutes : ∀ (f : F) (r : R), f (algebra_map R A r) = algebra_map R B r) | class | alg_equiv_class | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"algebra",
"algebra_map",
"comm_semiring",
"ring_equiv_class",
"semiring"
] | `alg_equiv_class F R A B` states that `F` is a type of algebra structure preserving
equivalences. You should extend this class when you extend `alg_equiv`. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_alg_hom_class (F R A B : Type*)
[comm_semiring R] [semiring A] [semiring B] [algebra R A] [algebra R B]
[h : alg_equiv_class F R A B] : alg_hom_class F R A B | { coe := coe_fn,
coe_injective' := fun_like.coe_injective,
map_zero := map_zero,
map_one := map_one,
.. h } | instance | alg_equiv_class.to_alg_hom_class | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"alg_equiv_class",
"alg_hom_class",
"algebra",
"comm_semiring",
"fun_like.coe_injective",
"map_one",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_linear_equiv_class (F R A B : Type*)
[comm_semiring R] [semiring A] [semiring B] [algebra R A] [algebra R B]
[h : alg_equiv_class F R A B] : linear_equiv_class F R A B | { map_smulₛₗ := λ f, map_smulₛₗ f,
..h } | instance | alg_equiv_class.to_linear_equiv_class | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"alg_equiv_class",
"algebra",
"comm_semiring",
"linear_equiv_class",
"semiring"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_coe {F : Type*} [alg_equiv_class F R A₁ A₂] (f : F) :
⇑(f : A₁ ≃ₐ[R] A₂) = f | rfl | lemma | alg_equiv.coe_coe | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"alg_equiv_class",
"coe_coe"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext {f g : A₁ ≃ₐ[R] A₂} (h : ∀ a, f a = g a) : f = g | fun_like.ext f g h | lemma | alg_equiv.ext | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"fun_like.ext"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr_arg {f : A₁ ≃ₐ[R] A₂} {x x' : A₁} : x = x' → f x = f x' | fun_like.congr_arg f | lemma | alg_equiv.congr_arg | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"fun_like.congr_arg"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
congr_fun {f g : A₁ ≃ₐ[R] A₂} (h : f = g) (x : A₁) : f x = g x | fun_like.congr_fun h x | lemma | alg_equiv.congr_fun | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"fun_like.congr_fun"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
ext_iff {f g : A₁ ≃ₐ[R] A₂} : f = g ↔ ∀ x, f x = g x | fun_like.ext_iff | lemma | alg_equiv.ext_iff | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"fun_like.ext_iff"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_fun_injective : @function.injective (A₁ ≃ₐ[R] A₂) (A₁ → A₂) (λ e, (e : A₁ → A₂)) | fun_like.coe_injective | lemma | alg_equiv.coe_fun_injective | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"fun_like.coe_injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
has_coe_to_ring_equiv : has_coe (A₁ ≃ₐ[R] A₂) (A₁ ≃+* A₂) | ⟨alg_equiv.to_ring_equiv⟩ | instance | alg_equiv.has_coe_to_ring_equiv | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_mk {to_fun inv_fun left_inv right_inv map_mul map_add commutes} :
⇑(⟨to_fun, inv_fun, left_inv, right_inv, map_mul, map_add, commutes⟩ : A₁ ≃ₐ[R] A₂) = to_fun | rfl | lemma | alg_equiv.coe_mk | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"inv_fun",
"map_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
mk_coe (e : A₁ ≃ₐ[R] A₂) (e' h₁ h₂ h₃ h₄ h₅) :
(⟨e, e', h₁, h₂, h₃, h₄, h₅⟩ : A₁ ≃ₐ[R] A₂) = e | ext $ λ _, rfl | theorem | alg_equiv.mk_coe | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_fun_eq_coe (e : A₁ ≃ₐ[R] A₂) : e.to_fun = e | rfl | lemma | alg_equiv.to_fun_eq_coe | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_equiv_eq_coe : e.to_equiv = e | rfl | lemma | alg_equiv.to_equiv_eq_coe | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_ring_equiv_eq_coe : e.to_ring_equiv = e | rfl | lemma | alg_equiv.to_ring_equiv_eq_coe | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_ring_equiv : ((e : A₁ ≃+* A₂) : A₁ → A₂) = e | rfl | lemma | alg_equiv.coe_ring_equiv | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_ring_equiv' : (e.to_ring_equiv : A₁ → A₂) = e | rfl | lemma | alg_equiv.coe_ring_equiv' | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_ring_equiv_injective : function.injective (coe : (A₁ ≃ₐ[R] A₂) → (A₁ ≃+* A₂)) | λ e₁ e₂ h, ext $ ring_equiv.congr_fun h | lemma | alg_equiv.coe_ring_equiv_injective | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"ring_equiv.congr_fun"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_add : ∀ x y, e (x + y) = e x + e y | map_add e | lemma | alg_equiv.map_add | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_zero : e 0 = 0 | map_zero e | lemma | alg_equiv.map_zero | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_mul : ∀ x y, e (x * y) = (e x) * (e y) | map_mul e | lemma | alg_equiv.map_mul | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"map_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_one : e 1 = 1 | map_one e | lemma | alg_equiv.map_one | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"map_one"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
commutes : ∀ (r : R), e (algebra_map R A₁ r) = algebra_map R A₂ r | e.commutes' | lemma | alg_equiv.commutes | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"algebra_map"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_smul (r : R) (x : A₁) : e (r • x) = r • e x | by simp only [algebra.smul_def, map_mul, commutes] | lemma | alg_equiv.map_smul | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"algebra.smul_def",
"map_mul"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_sum {ι : Type*} (f : ι → A₁) (s : finset ι) :
e (∑ x in s, f x) = ∑ x in s, e (f x) | e.to_add_equiv.map_sum f s | lemma | alg_equiv.map_sum | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"finset"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
map_finsupp_sum {α : Type*} [has_zero α] {ι : Type*} (f : ι →₀ α) (g : ι → α → A₁) :
e (f.sum g) = f.sum (λ i b, e (g i b)) | e.map_sum _ _ | lemma | alg_equiv.map_finsupp_sum | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
to_alg_hom : A₁ →ₐ[R] A₂ | { map_one' := e.map_one, map_zero' := e.map_zero, ..e } | def | alg_equiv.to_alg_hom | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | Interpret an algebra equivalence as an algebra homomorphism.
This definition is included for symmetry with the other `to_*_hom` projections.
The `simp` normal form is to use the coercion of the `alg_hom_class.has_coe_t` instance. | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
to_alg_hom_eq_coe : e.to_alg_hom = e | rfl | lemma | alg_equiv.to_alg_hom_eq_coe | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_alg_hom : ((e : A₁ →ₐ[R] A₂) : A₁ → A₂) = e | rfl | lemma | alg_equiv.coe_alg_hom | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_alg_hom_injective : function.injective (coe : (A₁ ≃ₐ[R] A₂) → (A₁ →ₐ[R] A₂)) | λ e₁ e₂ h, ext $ alg_hom.congr_fun h | lemma | alg_equiv.coe_alg_hom_injective | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"alg_hom.congr_fun"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
coe_ring_hom_commutes : ((e : A₁ →ₐ[R] A₂) : A₁ →+* A₂) = ((e : A₁ ≃+* A₂) : A₁ →+* A₂) | rfl | lemma | alg_equiv.coe_ring_hom_commutes | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | The two paths coercion can take to a `ring_hom` are equivalent | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 |
map_pow : ∀ (x : A₁) (n : ℕ), e (x ^ n) = (e x) ^ n | map_pow _ | lemma | alg_equiv.map_pow | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"map_pow"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
injective : function.injective e | equiv_like.injective e | lemma | alg_equiv.injective | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"equiv_like.injective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
surjective : function.surjective e | equiv_like.surjective e | lemma | alg_equiv.surjective | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"equiv_like.surjective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
bijective : function.bijective e | equiv_like.bijective e | lemma | alg_equiv.bijective | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [
"equiv_like.bijective"
] | https://github.com/leanprover-community/mathlib | 65a1391a0106c9204fe45bc73a039f056558cb83 | |
refl : A₁ ≃ₐ[R] A₁ | {commutes' := λ r, rfl, ..(1 : A₁ ≃+* A₁)} | def | alg_equiv.refl | algebra.algebra | src/algebra/algebra/equiv.lean | [
"algebra.algebra.hom"
] | [] | Algebra equivalences are reflexive. | 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.