fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
@[stacks 00J8]
isNilpotent_jacobson_bot {R} [Ring R] [IsArtinianRing R] :
IsNilpotent (Ideal.jacobson (⊥ : Ideal R)) :=
Ideal.jacobson_bot (R := R) ▸ IsSemiprimaryRing.isNilpotent
variable {R : Type*} [CommRing R] [IsArtinianRing R] | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/Artinian/Ring.lean | isNilpotent_jacobson_bot | null |
jacobson_eq_radical (I : Ideal R) : I.jacobson = I.radical := by
simp_rw [Ideal.jacobson, Ideal.radical_eq_sInf, IsArtinianRing.isPrime_iff_isMaximal] | lemma | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/Artinian/Ring.lean | jacobson_eq_radical | null |
isNilpotent_nilradical : IsNilpotent (nilradical R) := by
rw [nilradical, ← jacobson_eq_radical]
exact isNilpotent_jacobson_bot
variable (R) in | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/Artinian/Ring.lean | isNilpotent_nilradical | null |
isField_of_isReduced_of_isLocalRing [IsReduced R] [IsLocalRing R] : IsField R :=
(IsArtinianRing.equivPi R).trans (RingEquiv.piUnique _) |>.toMulEquiv.isField
(Ideal.Quotient.field _).toIsField | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/Artinian/Ring.lean | isField_of_isReduced_of_isLocalRing | Commutative Artinian reduced local ring is a field. |
localization_surjective : Function.Surjective (algebraMap R L) := by
intro r'
obtain ⟨r₁, s, rfl⟩ := IsLocalization.mk'_surjective S r'
rsuffices ⟨r₂, h⟩ : ∃ r : R, IsLocalization.mk' L 1 s = algebraMap R L r
· exact ⟨r₁ * r₂, by rw [IsLocalization.mk'_eq_mul_mk'_one, map_mul, h]⟩
obtain ⟨n, r, hr⟩ := IsArtinian.exists_pow_succ_smul_dvd (s : R) (1 : R)
use r
rw [smul_eq_mul, smul_eq_mul, pow_succ, mul_assoc] at hr
apply_fun algebraMap R L at hr
simp only [map_mul] at hr
rw [← IsLocalization.mk'_one (M := S) L, IsLocalization.mk'_eq_iff_eq, mul_one,
Submonoid.coe_one, ← (IsLocalization.map_units L (s ^ n)).mul_left_cancel hr, map_mul] | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/Artinian/Ring.lean | localization_surjective | Localizing an Artinian ring can only reduce the amount of elements. |
localization_artinian : IsArtinianRing L :=
(localization_surjective S L).isArtinianRing | theorem | RingTheory | [
"Mathlib.Algebra.Field.Equiv",
"Mathlib.RingTheory.Artinian.Module",
"Mathlib.RingTheory.Localization.Defs",
"Mathlib.RingTheory.LocalRing.MaximalIdeal.Basic"
] | Mathlib/RingTheory/Artinian/Ring.lean | localization_artinian | null |
Bialgebra (R : Type u) (A : Type v) [CommSemiring R] [Semiring A] extends
Algebra R A, Coalgebra R A where
/-- The counit on a bialgebra preserves 1. -/
counit_one : counit 1 = 1
/-- The counit on a bialgebra preserves multiplication. Note that this is written
in a rather obscure way: it says that two bilinear maps `A →ₗ[R] A →ₗ[R]` are equal.
The two corresponding equal linear maps `A ⊗[R] A →ₗ[R]`
are the following: the first factors through `A` and is multiplication on `A` followed
by `counit`. The second factors through `R ⊗[R] R`, and is `counit ⊗ counit` followed by
multiplication on `R`.
See `Bialgebra.mk'` for a constructor for bialgebras which uses
the more familiar but mathematically equivalent `counit (a * b) = counit a * counit b`. -/
mul_compr₂_counit : (LinearMap.mul R A).compr₂ counit = (LinearMap.mul R R).compl₁₂ counit counit
/-- The comultiplication on a bialgebra preserves `1`. -/
comul_one : comul 1 = 1
/-- The comultiplication on a bialgebra preserves multiplication. This is written in
a rather obscure way: it says that two bilinear maps `A →ₗ[R] A →ₗ[R] (A ⊗[R] A)`
are equal. The corresponding equal linear maps `A ⊗[R] A →ₗ[R] A ⊗[R] A`
are firstly multiplication followed by `comul`, and secondly `comul ⊗ comul` followed
by multiplication on `A ⊗[R] A`.
See `Bialgebra.mk'` for a constructor for bialgebras which uses the more familiar
but mathematically equivalent `comul (a * b) = comul a * comul b`. -/
mul_compr₂_comul :
(LinearMap.mul R A).compr₂ comul = (LinearMap.mul R (A ⊗[R] A)).compl₁₂ comul comul | class | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | Bialgebra | A bialgebra over a commutative (semi)ring `R` is both an algebra and a coalgebra over `R`, such
that the counit and comultiplication are algebra morphisms. |
counit_mul (a b : A) : counit (R := R) (a * b) = counit a * counit b :=
DFunLike.congr_fun (DFunLike.congr_fun mul_compr₂_counit a) b | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | counit_mul | null |
comul_mul (a b : A) : comul (R := R) (a * b) = comul a * comul b :=
DFunLike.congr_fun (DFunLike.congr_fun mul_compr₂_comul a) b
attribute [simp] counit_one comul_one counit_mul comul_mul | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | comul_mul | null |
mk' (R : Type u) (A : Type v) [CommSemiring R] [Semiring A]
[Algebra R A] [C : Coalgebra R A] (counit_one : C.counit 1 = 1)
(counit_mul : ∀ {a b}, C.counit (a * b) = C.counit a * C.counit b)
(comul_one : C.comul 1 = 1)
(comul_mul : ∀ {a b}, C.comul (a * b) = C.comul a * C.comul b) :
Bialgebra R A where
counit_one := counit_one
mul_compr₂_counit := by ext; exact counit_mul
comul_one := comul_one
mul_compr₂_comul := by ext; exact comul_mul
variable (R A) | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | mk' | If `R` is a field (or even a commutative semiring) and `A`
is an `R`-algebra with a coalgebra structure, then `Bialgebra.mk'`
consumes proofs that the counit and comultiplication preserve
the identity and multiplication, and produces a bialgebra
structure on `A`. |
@[simps!]
counitAlgHom : A →ₐ[R] R :=
.ofLinearMap counit counit_one counit_mul | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | counitAlgHom | `counitAlgHom R A` is the counit of the `R`-bialgebra `A`, as an `R`-algebra map. |
@[simps!]
comulAlgHom : A →ₐ[R] A ⊗[R] A :=
.ofLinearMap comul comul_one comul_mul
variable {R A}
@[simp] lemma toLinearMap_counitAlgHom : (counitAlgHom R A).toLinearMap = counit := rfl
@[simp] lemma toLinearMap_comulAlgHom : (comulAlgHom R A).toLinearMap = comul := rfl
@[simp] lemma counit_algebraMap (r : R) : counit (R := R) (algebraMap R A r) = r :=
(counitAlgHom R A).commutes r
@[simp] lemma comul_algebraMap (r : R) :
comul (R := R) (algebraMap R A r) = algebraMap R (A ⊗[R] A) r :=
(comulAlgHom R A).commutes r
@[simp] lemma counit_natCast (n : ℕ) : counit (R := R) (n : A) = n :=
map_natCast (counitAlgHom R A) _
@[simp] lemma comul_natCast (n : ℕ) : comul (R := R) (n : A) = n :=
map_natCast (comulAlgHom R A) _
@[simp] lemma counit_pow (a : A) (n : ℕ) : counit (R := R) (a ^ n) = counit a ^ n :=
map_pow (counitAlgHom R A) a n
@[simp] lemma comul_pow (a : A) (n : ℕ) : comul (R := R) (a ^ n) = comul a ^ n :=
map_pow (comulAlgHom R A) a n | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | comulAlgHom | `comulAlgHom R A` is the comultiplication of the `R`-bialgebra `A`, as an `R`-algebra map. |
toBialgebra : Bialgebra R R where
mul_compr₂_counit := by ext; simp
counit_one := rfl
mul_compr₂_comul := by ext; simp
comul_one := rfl | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | toBialgebra | Every commutative (semi)ring is a bialgebra over itself |
ofAlgHom (comul : A →ₐ[R] (A ⊗[R] A)) (counit : A →ₐ[R] R)
(h_coassoc : (Algebra.TensorProduct.assoc R R A A A).toAlgHom.comp
((Algebra.TensorProduct.map comul (.id R A)).comp comul)
= (Algebra.TensorProduct.map (.id R A) comul).comp comul)
(h_rTensor : (Algebra.TensorProduct.map counit (.id R A)).comp comul
= (Algebra.TensorProduct.lid R A).symm)
(h_lTensor : (Algebra.TensorProduct.map (.id R A) counit).comp comul
= (Algebra.TensorProduct.rid R R A).symm) :
Bialgebra R A :=
letI : Coalgebra R A := {
comul := comul
counit := counit
coassoc := congr(($h_coassoc).toLinearMap)
rTensor_counit_comp_comul := congr(($h_rTensor).toLinearMap)
lTensor_counit_comp_comul := congr(($h_lTensor).toLinearMap)
}
.mk' _ _ (map_one counit) (map_mul counit _ _) (map_one comul) (map_mul comul _ _) | abbrev | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | ofAlgHom | If `R` is a commutative semiring and `A` is an `R`-algebra,
then `Bialgebra.ofAlgHom` consumes the counit and comultiplication
as algebra homomorphisms that satisfy the coalgebra axioms to define
a bialgebra structure on `A`. |
algebraMap_injective : Injective (algebraMap R A) := RightInverse.injective counit_algebraMap | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | algebraMap_injective | null |
counit_surjective : Surjective (Coalgebra.counit : A →ₗ[R] R) :=
RightInverse.surjective counit_algebraMap
include R in
variable (R) in | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | counit_surjective | null |
nontrivial [Nontrivial R] : Nontrivial A := (algebraMap_injective (R := R) _).nontrivial | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic",
"Mathlib.RingTheory.TensorProduct.Basic"
] | Mathlib/RingTheory/Bialgebra/Basic.lean | nontrivial | A bialgebra over a nontrivial ring is nontrivial. |
BialgEquiv (R : Type u) [CommSemiring R] (A : Type v) (B : Type w)
[Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
[CoalgebraStruct R A] [CoalgebraStruct R B] extends A ≃ₗc[R] B, A ≃* B where
attribute [nolint docBlame] BialgEquiv.toMulEquiv
attribute [nolint docBlame] BialgEquiv.toCoalgEquiv
@[inherit_doc BialgEquiv]
notation:50 A " ≃ₐc[" R "] " B => BialgEquiv R A B | structure | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | BialgEquiv | An equivalence of bialgebras is an invertible bialgebra homomorphism. |
BialgEquivClass (F : Type*) (R A B : outParam Type*) [CommSemiring R]
[Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
[CoalgebraStruct R A] [CoalgebraStruct R B] [EquivLike F A B] : Prop
extends CoalgEquivClass F R A B, MulEquivClass F A B | class | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | BialgEquivClass | `BialgEquivClass F R A B` asserts `F` is a type of bundled bialgebra equivalences
from `A` to `B`. |
@[coe]
toBialgEquiv (f : F) : A ≃ₐc[R] B :=
{ (f : A ≃ₗc[R] B), (f : A →ₐc[R] B) with } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toBialgEquiv | Reinterpret an element of a type of bialgebra equivalences as a bialgebra equivalence. |
instCoeToBialgEquiv : CoeHead F (A ≃ₐc[R] B) where
coe f := toBialgEquiv f | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | instCoeToBialgEquiv | Reinterpret an element of a type of bialgebra equivalences as a bialgebra equivalence. |
toBialgHom (f : A ≃ₐc[R] B) : A →ₐc[R] B :=
{ f.toCoalgEquiv with
map_one' := map_one f.toMulEquiv
map_mul' := map_mul f.toMulEquiv } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toBialgHom | The bialgebra morphism underlying a bialgebra equivalence. |
toAlgEquiv (f : A ≃ₐc[R] B) : A ≃ₐ[R] B :=
{ f.toCoalgEquiv with
map_mul' := map_mul f.toMulEquiv
map_add' := map_add f.toCoalgEquiv
commutes' := AlgHomClass.commutes f.toBialgHom } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toAlgEquiv | The algebra equivalence underlying a bialgebra equivalence. |
toEquiv : (A ≃ₐc[R] B) → A ≃ B := fun f => f.toCoalgEquiv.toEquiv | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toEquiv | The equivalence of types underlying a bialgebra equivalence. |
toEquiv_injective : Function.Injective (toEquiv : (A ≃ₐc[R] B) → A ≃ B) :=
fun ⟨_, _⟩ ⟨_, _⟩ h =>
(BialgEquiv.mk.injEq _ _ _ _).mpr (CoalgEquiv.toEquiv_injective h)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toEquiv_injective | null |
toEquiv_inj {e₁ e₂ : A ≃ₐc[R] B} : e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂ :=
toEquiv_injective.eq_iff | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toEquiv_inj | null |
toBialgHom_injective : Function.Injective (toBialgHom : (A ≃ₐc[R] B) → A →ₐc[R] B) :=
fun _ _ H => toEquiv_injective <| Equiv.ext <| BialgHom.congr_fun H | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toBialgHom_injective | null |
@[simp, norm_cast]
toBialgHom_inj {e₁ e₂ : A ≃ₐc[R] B} : (↑e₁ : A →ₐc[R] B) = e₂ ↔ e₁ = e₂ :=
toBialgHom_injective.eq_iff
@[simp] lemma coe_mk (e : A ≃ₗc[R] B) (h) : mk e h = e := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toBialgHom_inj | null |
@[simp, norm_cast]
coe_coe : ⇑(e : A →ₐc[R] B) = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_coe | null |
toCoalgEquiv_eq_coe (f : A ≃ₐc[R] B) : f.toCoalgEquiv = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toCoalgEquiv_eq_coe | null |
toBialgHom_eq_coe (f : A ≃ₐc[R] B) : f.toBialgHom = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toBialgHom_eq_coe | null |
toAlgEquiv_eq_coe (f : A ≃ₐc[R] B) : f.toAlgEquiv = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toAlgEquiv_eq_coe | null |
coe_toCoalgEquiv : ⇑(e : A ≃ₐ[R] B) = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_toCoalgEquiv | null |
coe_toBialgHom : ⇑(e : A →ₐc[R] B) = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_toBialgHom | null |
coe_toAlgEquiv : ⇑(e : A ≃ₐ[R] B) = e :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_toAlgEquiv | null |
toCoalgEquiv_toCoalgHom : ((e : A ≃ₐc[R] B) : A →ₗc[R] B) = (e : A →ₐc[R] B) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toCoalgEquiv_toCoalgHom | null |
toBialgHom_toAlgHom : ((e : A →ₐc[R] B) : A →ₐ[R] B) = e := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toBialgHom_toAlgHom | null |
@[ext]
ext (h : ∀ x, e x = e' x) : e = e' :=
DFunLike.ext _ _ h | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | ext | null |
protected congr_arg {x x'} : x = x' → e x = e x' :=
DFunLike.congr_arg e | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | congr_arg | null |
protected congr_fun (h : e = e') (x : A) : e x = e' x :=
DFunLike.congr_fun h x | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | congr_fun | null |
Simps.apply {R : Type u} [CommSemiring R] {α : Type v} {β : Type w}
[Semiring α] [Semiring β] [Algebra R α]
[Algebra R β] [CoalgebraStruct R α] [CoalgebraStruct R β]
(f : α ≃ₐc[R] β) : α → β := f | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | Simps.apply | See Note [custom simps projection] |
Simps.symm_apply {R : Type*} [CommSemiring R]
{A : Type*} {B : Type*} [Semiring A] [Semiring B] [Algebra R A] [Algebra R B]
[CoalgebraStruct R A] [CoalgebraStruct R B]
(e : A ≃ₐc[R] B) : B → A :=
e.symm
initialize_simps_projections BialgEquiv (toFun → apply, invFun → symm_apply)
variable (A R) in | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | Simps.symm_apply | See Note [custom simps projection] |
@[refl, simps!]
refl : A ≃ₐc[R] A :=
{ CoalgEquiv.refl R A, BialgHom.id R A with }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | refl | The identity map is a bialgebra equivalence. |
refl_toCoalgEquiv : refl R A = CoalgEquiv.refl R A := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | refl_toCoalgEquiv | null |
refl_toBialgHom : refl R A = BialgHom.id R A :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | refl_toBialgHom | null |
@[symm]
symm (e : A ≃ₐc[R] B) : B ≃ₐc[R] A :=
{ (e : A ≃ₗc[R] B).symm, (e : A ≃* B).symm with }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | symm | Bialgebra equivalences are symmetric. |
symm_toCoalgEquiv (e : A ≃ₐc[R] B) :
e.symm = (e : A ≃ₗc[R] B).symm := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | symm_toCoalgEquiv | null |
invFun_eq_symm : e.invFun = e.symm :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | invFun_eq_symm | null |
coe_toEquiv_symm : e.toEquiv.symm = e.symm := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_toEquiv_symm | null |
toEquiv_symm : e.symm.toEquiv = e.toEquiv.symm :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toEquiv_symm | null |
coe_toEquiv : ⇑e.toEquiv = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_toEquiv | null |
coe_symm_toEquiv : ⇑e.toEquiv.symm = e.symm :=
rfl
variable {e₁₂ : A ≃ₐc[R] B} {e₂₃ : B ≃ₐc[R] C} | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_symm_toEquiv | null |
@[trans, simps!]
trans (e₁₂ : A ≃ₐc[R] B) (e₂₃ : B ≃ₐc[R] C) : A ≃ₐc[R] C :=
{ (e₁₂ : A ≃ₗc[R] B).trans (e₂₃ : B ≃ₗc[R] C), (e₁₂ : A ≃* B).trans (e₂₃ : B ≃* C) with }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | trans | Bialgebra equivalences are transitive. |
trans_toCoalgEquiv :
(e₁₂.trans e₂₃ : A ≃ₗc[R] C) = (e₁₂ : A ≃ₗc[R] B).trans (e₂₃ : B ≃ₗc[R] C) := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | trans_toCoalgEquiv | null |
trans_toBialgHom :
(e₁₂.trans e₂₃ : A →ₐc[R] C) = (e₂₃ : B →ₐc[R] C).comp e₁₂ := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | trans_toBialgHom | null |
coe_toEquiv_trans : (e₁₂ : A ≃ B).trans e₂₃ = (e₁₂.trans e₂₃ : A ≃ C) :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_toEquiv_trans | null |
apply_symm_apply (e : A ≃ₐc[R] B) : ∀ x, e (e.symm x) = x := e.toEquiv.apply_symm_apply
@[simp] | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | apply_symm_apply | null |
symm_apply_apply (e : A ≃ₐc[R] B) : ∀ x, e.symm (e x) = x := e.toEquiv.symm_apply_apply
@[simp] lemma comp_symm (e : A ≃ₐc[R] B) : (e : A →ₐc[R] B).comp e.symm = .id R B :=
BialgHom.coe_algHom_injective e.toAlgEquiv.comp_symm
@[simp] lemma symm_comp (e : A ≃ₐc[R] B) : (e.symm : B →ₐc[R] A).comp e = .id R A :=
BialgHom.coe_algHom_injective e.toAlgEquiv.symm_comp
@[simp] lemma toRingEquiv_toRingHom (e : A ≃ₐc[R] B) : ((e : A ≃+* B) : A →+* B) = e := rfl
@[simp] lemma toAlgEquiv_toRingHom (e : A ≃ₐc[R] B) : ((e : A ≃ₐ[R] B) : A →+* B) = e := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | symm_apply_apply | null |
ofBialgHom (f : A →ₐc[R] B) (g : B →ₐc[R] A) (h₁ : f.comp g = BialgHom.id R B)
(h₂ : g.comp f = BialgHom.id R A) : A ≃ₐc[R] B where
__ := f
toFun := f
invFun := g
left_inv := BialgHom.ext_iff.1 h₂
right_inv := BialgHom.ext_iff.1 h₁
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | ofBialgHom | If an coalgebra morphism has an inverse, it is an coalgebra isomorphism. |
coe_ofBialgHom (f : A →ₐc[R] B) (g : B →ₐc[R] A) (h₁ h₂) :
ofBialgHom f g h₁ h₂ = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_ofBialgHom | null |
ofBialgHom_symm (f : A →ₐc[R] B) (g : B →ₐc[R] A) (h₁ h₂) :
(ofBialgHom f g h₁ h₂).symm = ofBialgHom g f h₂ h₁ :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | ofBialgHom_symm | null |
@[simps apply] ofAlgEquiv (f : A ≃ₐ[R] B)
(counit_comp : (Bialgebra.counitAlgHom R B).comp f = Bialgebra.counitAlgHom R A)
(map_comp_comul : (Algebra.TensorProduct.map f f).comp (Bialgebra.comulAlgHom R A) =
(Bialgebra.comulAlgHom R B).comp f) : A ≃ₐc[R] B where
__ := f
map_smul' := map_smul f
counit_comp := congr($(counit_comp).toLinearMap)
map_comp_comul := congr($(map_comp_comul).toLinearMap)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | ofAlgEquiv | Construct a bialgebra equiv from an algebra equiv respecting counit and comultiplication. |
toLinearMap_ofAlgEquiv (f : A ≃ₐ[R] B) (counit_comp map_comp_comul) :
(ofAlgEquiv f counit_comp map_comp_comul : A →ₗ[R] B) = f := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | toLinearMap_ofAlgEquiv | null |
@[simps! apply]
noncomputable ofBijective (f : A →ₐc[R] B) (hf : Bijective f) : A ≃ₐc[R] B :=
.ofAlgEquiv (.ofBijective (f : A →ₐ[R] B) hf) (by ext; simp) (by ext; simp)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | ofBijective | Promotes a bijective bialgebra homomorphism to a bialgebra equivalence. |
coe_ofBijective (f : A →ₐc[R] B) (hf : Bijective f) : (ofBijective f hf : A → B) = f := rfl | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Equiv",
"Mathlib.RingTheory.Bialgebra.Hom"
] | Mathlib/RingTheory/Bialgebra/Equiv.lean | coe_ofBijective | null |
BialgHom (R A B : Type*) [CommSemiring R]
[Semiring A] [Algebra R A] [Semiring B] [Algebra R B]
[CoalgebraStruct R A] [CoalgebraStruct R B] extends A →ₗc[R] B, A →* B | structure | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | BialgHom | Given `R`-algebras `A, B` with comultiplication maps `Δ_A, Δ_B` and counit maps
`ε_A, ε_B`, an `R`-bialgebra homomorphism `A →ₐc[R] B` is an `R`-algebra map `f` such that
`ε_B ∘ f = ε_A` and `(f ⊗ f) ∘ Δ_A = Δ_B ∘ f`. |
BialgHomClass (F : Type*) (R A B : outParam Type*)
[CommSemiring R] [Semiring A] [Algebra R A] [Semiring B] [Algebra R B]
[CoalgebraStruct R A] [CoalgebraStruct R B] [FunLike F A B] : Prop
extends CoalgHomClass F R A B, MonoidHomClass F A B | class | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | BialgHomClass | Reinterpret a `BialgHom` as a `MonoidHom` -/
add_decl_doc BialgHom.toMonoidHom
@[inherit_doc BialgHom]
infixr:25 " →ₐc " => BialgHom _
@[inherit_doc]
notation:25 A " →ₐc[" R "] " B => BialgHom R A B
/-- `BialgHomClass F R A B` asserts `F` is a type of bundled bialgebra homomorphisms
from `A` to `B`. |
@[coe]
toBialgHom (f : F) : A →ₐc[R] B :=
{ CoalgHomClass.toCoalgHom f, AlgHomClass.toAlgHom f with
toFun := f } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | toBialgHom | Turn an element of a type `F` satisfying `BialgHomClass F R A B` into an actual
`BialgHom`. This is declared as the default coercion from `F` to `A →ₐc[R] B`. |
instCoeToBialgHom :
CoeHead F (A →ₐc[R] B) :=
⟨BialgHomClass.toBialgHom⟩ | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | instCoeToBialgHom | null |
@[simp]
counitAlgHom_comp (f : F) :
(counitAlgHom R B).comp (f : A →ₐ[R] B) = counitAlgHom R A :=
AlgHom.toLinearMap_injective (CoalgHomClass.counit_comp f)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | counitAlgHom_comp | null |
map_comp_comulAlgHom (f : F) :
(Algebra.TensorProduct.map f f).comp (comulAlgHom R A) = (comulAlgHom R B).comp f :=
AlgHom.toLinearMap_injective (CoalgHomClass.map_comp_comul f) | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | map_comp_comulAlgHom | null |
funLike : FunLike (A →ₐc[R] B) A B where
coe f := f.toFun
coe_injective' f g h := by
rcases f with ⟨_, _⟩
rcases g with ⟨_, _⟩
simp_all | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | funLike | null |
bialgHomClass : BialgHomClass (A →ₐc[R] B) R A B where
map_add := fun f => f.map_add'
map_smulₛₗ := fun f => f.map_smul'
counit_comp := fun f => f.counit_comp
map_comp_comul := fun f => f.map_comp_comul
map_mul := fun f => f.map_mul'
map_one := fun f => f.map_one' | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | bialgHomClass | null |
Simps.apply {R α β : Type*} [CommSemiring R]
[Semiring α] [Algebra R α] [Semiring β]
[Algebra R β] [CoalgebraStruct R α] [CoalgebraStruct R β]
(f : α →ₐc[R] β) : α → β := f
initialize_simps_projections BialgHom (toFun → apply)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | Simps.apply | See Note [custom simps projection] |
protected coe_coe {F : Type*} [FunLike F A B] [BialgHomClass F R A B] (f : F) :
⇑(f : A →ₐc[R] B) = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_coe | null |
coe_mk {f : A →ₗc[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₐc[R] B) : A → B) = f :=
rfl
@[norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_mk | null |
coe_mks {f : A → B} (h₀ h₁ h₂ h₃ h₄ h₅) :
⇑(⟨⟨⟨⟨f, h₀⟩, h₁⟩, h₂, h₃⟩, h₄, h₅⟩ : A →ₐc[R] B) = f :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_mks | null |
coe_coalgHom_mk {f : A →ₗc[R] B} (h h₁) :
((⟨f, h, h₁⟩ : A →ₐc[R] B) : A →ₗc[R] B) = f := by
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_coalgHom_mk | null |
coe_toCoalgHom (f : A →ₐc[R] B) : ⇑(f : A →ₗc[R] B) = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_toCoalgHom | null |
toCoalgHom_apply (f : A →ₐc[R] B) (a : A) : f.toCoalgHom a = f a := rfl
@[simp, norm_cast] | lemma | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | toCoalgHom_apply | null |
coe_toLinearMap (f : A →ₐc[R] B) : ⇑(f : A →ₗ[R] B) = f :=
rfl
@[norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_toLinearMap | null |
coe_toAlgHom (f : A →ₐc[R] B) : ⇑(f : A →ₐ[R] B) = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_toAlgHom | null |
toAlgHom_toLinearMap (f : A →ₐc[R] B) :
((f : A →ₐ[R] B) : A →ₗ[R] B) = f := by
rfl
variable (φ : A →ₐc[R] B) | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | toAlgHom_toLinearMap | null |
coe_fn_injective : @Function.Injective (A →ₐc[R] B) (A → B) (↑) :=
DFunLike.coe_injective | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_fn_injective | null |
coe_fn_inj {φ₁ φ₂ : A →ₐc[R] B} : (φ₁ : A → B) = φ₂ ↔ φ₁ = φ₂ :=
DFunLike.coe_fn_eq | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_fn_inj | null |
coe_coalgHom_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₗc[R] B) :=
fun φ₁ φ₂ H => coe_fn_injective <|
show ((φ₁ : A →ₗc[R] B) : A → B) = ((φ₂ : A →ₗc[R] B) : A → B) from congr_arg _ H | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_coalgHom_injective | null |
coe_algHom_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₐ[R] B) :=
fun φ₁ φ₂ H => coe_fn_injective <|
show ((φ₁ : A →ₐ[R] B) : A → B) = ((φ₂ : A →ₐ[R] B) : A → B) from congr_arg _ H | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_algHom_injective | null |
coe_linearMap_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₗ[R] B) :=
CoalgHom.coe_linearMap_injective.comp coe_coalgHom_injective | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_linearMap_injective | null |
protected congr_fun {φ₁ φ₂ : A →ₐc[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x :=
DFunLike.congr_fun H x | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | congr_fun | null |
protected congr_arg (φ : A →ₐc[R] B) {x y : A} (h : x = y) : φ x = φ y :=
DFunLike.congr_arg φ h
@[ext] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | congr_arg | null |
ext {φ₁ φ₂ : A →ₐc[R] B} (H : ∀ x, φ₁ x = φ₂ x) : φ₁ = φ₂ :=
DFunLike.ext _ _ H
@[ext high] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | ext | null |
ext_of_ring {f g : R →ₐc[R] A} (h : f 1 = g 1) : f = g :=
coe_linearMap_injective (by ext; assumption)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | ext_of_ring | null |
mk_coe {f : A →ₐc[R] B} (h₀ h₁ h₂ h₃ h₄ h₅) :
(⟨⟨⟨⟨f, h₀⟩, h₁⟩, h₂, h₃⟩, h₄, h₅⟩ : A →ₐc[R] B) = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | mk_coe | null |
protected copy (f : A →ₐc[R] B) (f' : A → B) (h : f' = ⇑f) : A →ₐc[R] B :=
{ toCoalgHom := (f : A →ₗc[R] B).copy f' h
map_one' := by simp_all
map_mul' := by intros; simp_all }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | copy | Copy of a `BialgHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. |
coe_copy (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : ⇑(f.copy f' h) = f' :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_copy | null |
copy_eq (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : f.copy f' h = f :=
DFunLike.ext' h | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | copy_eq | null |
@[simps!] protected id : A →ₐc[R] A :=
{ CoalgHom.id R A, AlgHom.id R A with }
variable {R A}
@[simp, norm_cast] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | id | Identity map as a `BialgHom`. |
coe_id : ⇑(BialgHom.id R A) = id :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | coe_id | null |
id_toCoalgHom : BialgHom.id R A = CoalgHom.id R A :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | id_toCoalgHom | null |
id_toAlgHom : BialgHom.id R A = AlgHom.id R A :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom",
"Mathlib.RingTheory.Bialgebra.Basic"
] | Mathlib/RingTheory/Bialgebra/Hom.lean | id_toAlgHom | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.