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 ⌀ |
|---|---|---|---|---|---|---|
@[coe]
toCoalgEquiv [EquivLike F A B] [CoalgEquivClass F R A B] (f : F) : A ≃ₗc[R] B :=
{ (f : A →ₗc[R] B), (f : A ≃ₗ[R] B) with } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toCoalgEquiv | Reinterpret an element of a type of coalgebra equivalences as a coalgebra equivalence. |
instCoeToCoalgEquiv
[EquivLike F A B] [CoalgEquivClass F R A B] : CoeHead F (A ≃ₗc[R] B) where
coe f := toCoalgEquiv f | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | instCoeToCoalgEquiv | Reinterpret an element of a type of coalgebra equivalences as a coalgebra equivalence. |
toEquiv : (A ≃ₗc[R] B) → A ≃ B := fun f => f.toLinearEquiv.toEquiv | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toEquiv | The equivalence of types underlying a coalgebra equivalence. |
toEquiv_injective : Function.Injective (toEquiv : (A ≃ₗc[R] B) → A ≃ B) :=
fun ⟨_, _, _, _⟩ ⟨_, _, _, _⟩ h =>
(CoalgEquiv.mk.injEq _ _ _ _ _ _ _ _).mpr
⟨CoalgHom.ext (congr_fun (Equiv.mk.inj h).1), (Equiv.mk.inj h).2⟩
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/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.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toEquiv_inj | null |
toCoalgHom_injective : Function.Injective (toCoalgHom : (A ≃ₗc[R] B) → A →ₗc[R] B) :=
fun _ _ H => toEquiv_injective <| Equiv.ext <| CoalgHom.congr_fun H | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toCoalgHom_injective | null |
@[simp, norm_cast]
toCoalgHom_inj {e₁ e₂ : A ≃ₗc[R] B} : (↑e₁ : A →ₗc[R] B) = e₂ ↔ e₁ = e₂ :=
toCoalgHom_injective.eq_iff
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toCoalgHom_inj | null |
coe_mk {f h h₀ h₁ h₂ h₃ h₄ h₅} :
(⟨⟨⟨⟨f, h⟩, h₀⟩, h₁, h₂⟩, h₃, h₄, h₅⟩ : A ≃ₗc[R] B) = f := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_mk | null |
@[simp, norm_cast]
coe_coe : ⇑(e : A →ₗc[R] B) = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_coe | null |
toLinearEquiv_eq_coe (f : A ≃ₗc[R] B) : f.toLinearEquiv = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toLinearEquiv_eq_coe | null |
toCoalgHom_eq_coe (f : A ≃ₗc[R] B) : f.toCoalgHom = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toCoalgHom_eq_coe | null |
coe_toLinearEquiv : ⇑(e : A ≃ₗ[R] B) = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_toLinearEquiv | null |
coe_toCoalgHom : ⇑(e : A →ₗc[R] B) = e :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_toCoalgHom | null |
toLinearEquiv_toLinearMap : ((e : A ≃ₗ[R] B) : A →ₗ[R] B) = (e : A →ₗc[R] B) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toLinearEquiv_toLinearMap | null |
@[ext]
ext (h : ∀ x, e x = e' x) : e = e' :=
DFunLike.ext _ _ h | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | ext | null |
protected congr_arg {x x'} : x = x' → e x = e x' :=
DFunLike.congr_arg e | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/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.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | congr_fun | null |
@[symm]
symm (e : A ≃ₗc[R] B) : B ≃ₗc[R] A :=
{ (e : A ≃ₗ[R] B).symm with
counit_comp := (LinearEquiv.comp_toLinearMap_symm_eq _ _).2 e.counit_comp.symm
map_comp_comul := by
change (TensorProduct.congr (e : A ≃ₗ[R] B) (e : A ≃ₗ[R] B)).symm.toLinearMap ∘ₗ comul
= comul ∘ₗ (e : A ≃ₗ[R] B).symm
rw [LinearEquiv.toLinearMap_symm_comp_eq]
simp only [TensorProduct.congr, toLinearEquiv_toLinearMap,
LinearEquiv.ofLinear_toLinearMap, ← LinearMap.comp_assoc, CoalgHomClass.map_comp_comul,
LinearEquiv.eq_comp_toLinearMap_symm] } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | symm | Coalgebra equivalences are symmetric. |
Simps.apply {R : Type*} [CommSemiring R] {α β : Type*}
[AddCommMonoid α] [AddCommMonoid β] [Module R α]
[Module R β] [CoalgebraStruct R α] [CoalgebraStruct R β]
(f : α ≃ₗc[R] β) : α → β := f | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | Simps.apply | See Note [custom simps projection] |
Simps.symm_apply {R : Type*} [CommSemiring R]
{A : Type*} {B : Type*} [AddCommMonoid A] [AddCommMonoid B] [Module R A] [Module R B]
[CoalgebraStruct R A] [CoalgebraStruct R B]
(e : A ≃ₗc[R] B) : B → A :=
e.symm
initialize_simps_projections CoalgEquiv (toFun → apply, invFun → symm_apply)
variable (A R) in | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | Simps.symm_apply | See Note [custom simps projection] |
@[refl, simps!]
refl : A ≃ₗc[R] A :=
{ CoalgHom.id R A, LinearEquiv.refl R A with }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | refl | The identity map is a coalgebra equivalence. |
refl_toLinearEquiv : refl R A = LinearEquiv.refl R A := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | refl_toLinearEquiv | null |
refl_toCoalgHom : refl R A = CoalgHom.id R A :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | refl_toCoalgHom | null |
symm_toLinearEquiv (e : A ≃ₗc[R] B) :
e.symm = (e : A ≃ₗ[R] B).symm := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | symm_toLinearEquiv | null |
coe_symm_toLinearEquiv (e : A ≃ₗc[R] B) :
⇑(e : A ≃ₗ[R] B).symm = e.symm := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_symm_toLinearEquiv | null |
symm_toCoalgHom (e : A ≃ₗc[R] B) :
((e.symm : B →ₗc[R] A) : B →ₗ[R] A) = (e : A ≃ₗ[R] B).symm := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | symm_toCoalgHom | null |
symm_apply_apply (e : A ≃ₗc[R] B) (x) :
e.symm (e x) = x :=
LinearEquiv.symm_apply_apply (e : A ≃ₗ[R] B) x
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | symm_apply_apply | null |
apply_symm_apply (e : A ≃ₗc[R] B) (x) :
e (e.symm x) = x :=
LinearEquiv.apply_symm_apply (e : A ≃ₗ[R] B) x
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | apply_symm_apply | null |
invFun_eq_symm : e.invFun = e.symm :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | invFun_eq_symm | null |
coe_toEquiv_symm : e.toEquiv.symm = e.symm := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_toEquiv_symm | null |
toEquiv_symm : e.symm.toEquiv = e.toEquiv.symm :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toEquiv_symm | null |
coe_toEquiv : ⇑e.toEquiv = e :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/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.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_symm_toEquiv | null |
@[trans, simps!]
trans (e₁₂ : A ≃ₗc[R] B) (e₂₃ : B ≃ₗc[R] C) : A ≃ₗc[R] C :=
{ (e₂₃ : B →ₗc[R] C).comp (e₁₂ : A →ₗc[R] B), e₁₂.toLinearEquiv ≪≫ₗ e₂₃.toLinearEquiv with } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | trans | Coalgebra equivalences are transitive. |
trans_toLinearEquiv :
(e₁₂.trans e₂₃ : A ≃ₗ[R] C) = (e₁₂ : A ≃ₗ[R] B) ≪≫ₗ e₂₃ := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | trans_toLinearEquiv | null |
trans_toCoalgHom :
(e₁₂.trans e₂₃ : A →ₗc[R] C) = e₂₃.comp e₁₂ := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | trans_toCoalgHom | null |
coe_toEquiv_trans : (e₁₂ : A ≃ B).trans e₂₃ = (e₁₂.trans e₂₃ : A ≃ C) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_toEquiv_trans | null |
ofCoalgHom (f : A →ₗc[R] B) (g : B →ₗc[R] A) (h₁ : f.comp g = CoalgHom.id R B)
(h₂ : g.comp f = CoalgHom.id R A) : A ≃ₗc[R] B where
__ := f
toFun := f
invFun := g
left_inv := CoalgHom.ext_iff.1 h₂
right_inv := CoalgHom.ext_iff.1 h₁
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | ofCoalgHom | If an coalgebra morphism has an inverse, it is an coalgebra isomorphism. |
coe_ofCoalgHom (f : A →ₗc[R] B) (g : B →ₗc[R] A) (h₁ h₂) :
ofCoalgHom f g h₁ h₂ = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_ofCoalgHom | null |
ofCoalgHom_symm (f : A →ₗc[R] B) (g : B →ₗc[R] A) (h₁ h₂) :
(ofCoalgHom f g h₁ h₂).symm = ofCoalgHom g f h₂ h₁ :=
rfl
variable {f : A →ₗc[R] B} (hf : Function.Bijective f) | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | ofCoalgHom_symm | null |
@[simps apply]
noncomputable ofBijective : A ≃ₗc[R] B where
toFun := f
__ := f
__ := LinearEquiv.ofBijective (f : A →ₗ[R] B) hf
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | ofBijective | Promotes a bijective coalgebra homomorphism to a coalgebra equivalence. |
coe_ofBijective : (CoalgEquiv.ofBijective hf : A → B) = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | coe_ofBijective | null |
@[reducible] toCoalgebra (f : A ≃ₗc[R] B) :
Coalgebra R B where
coassoc := by
simp only [← ((f : A ≃ₗ[R] B).comp_toLinearMap_symm_eq _ _).2 f.map_comp_comul,
← LinearMap.comp_assoc]
congr 1
ext x
simpa only [toCoalgHom_eq_coe, CoalgHom.toLinearMap_eq_coe, LinearMap.coe_comp,
LinearEquiv.coe_coe, Function.comp_apply, ← (ℛ R _).eq, map_sum, TensorProduct.map_tmul,
LinearMap.coe_coe, CoalgHom.coe_coe, LinearMap.rTensor_tmul, coe_symm_toLinearEquiv,
symm_apply_apply, LinearMap.lTensor_comp_map, TensorProduct.sum_tmul,
TensorProduct.assoc_tmul, TensorProduct.tmul_sum] using (sum_map_tmul_tmul_eq f f f x).symm
rTensor_counit_comp_comul := by
simp_rw [(f.toLinearEquiv.eq_comp_toLinearMap_symm _ _).2 f.counit_comp,
← (f.toLinearEquiv.comp_toLinearMap_symm_eq _ _).2 f.map_comp_comul, ← LinearMap.comp_assoc,
f.toLinearEquiv.comp_toLinearMap_symm_eq]
ext x
simp [← (ℛ R _).eq, coe_symm_toLinearEquiv]
lTensor_counit_comp_comul := by
simp_rw [(f.toLinearEquiv.eq_comp_toLinearMap_symm _ _).2 f.counit_comp,
← (f.toLinearEquiv.comp_toLinearMap_symm_eq _ _).2 f.map_comp_comul, ← LinearMap.comp_assoc,
f.toLinearEquiv.comp_toLinearMap_symm_eq]
ext x
simp [← (ℛ R _).eq, coe_symm_toLinearEquiv] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Hom"
] | Mathlib/RingTheory/Coalgebra/Equiv.lean | toCoalgebra | Let `A` be an `R`-coalgebra and let `B` be an `R`-module with a `CoalgebraStruct`.
A linear equivalence `A ≃ₗ[R] B` that respects the `CoalgebraStruct`s defines an `R`-coalgebra
structure on `B`. |
CoalgHom (R A B : Type*) [CommSemiring R]
[AddCommMonoid A] [Module R A] [AddCommMonoid B] [Module R B]
[CoalgebraStruct R A] [CoalgebraStruct R B] extends A →ₗ[R] B where
counit_comp : counit ∘ₗ toLinearMap = counit
map_comp_comul : TensorProduct.map toLinearMap toLinearMap ∘ₗ comul = comul ∘ₗ toLinearMap
@[inherit_doc CoalgHom]
infixr:25 " →ₗc " => CoalgHom _
@[inherit_doc]
notation:25 A " →ₗc[" R "] " B => CoalgHom R A B | structure | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | CoalgHom | Given `R`-modules `A, B` with comultiplication maps `Δ_A, Δ_B` and counit maps
`ε_A, ε_B`, an `R`-coalgebra homomorphism `A →ₗc[R] B` is an `R`-linear map `f` such that
`ε_B ∘ f = ε_A` and `(f ⊗ f) ∘ Δ_A = Δ_B ∘ f`. |
CoalgHomClass (F : Type*) (R A B : outParam Type*)
[CommSemiring R] [AddCommMonoid A] [Module R A] [AddCommMonoid B] [Module R B]
[CoalgebraStruct R A] [CoalgebraStruct R B] [FunLike F A B] : Prop
extends SemilinearMapClass F (RingHom.id R) A B where
counit_comp : ∀ f : F, counit ∘ₗ (f : A →ₗ[R] B) = counit
map_comp_comul : ∀ f : F, TensorProduct.map (f : A →ₗ[R] B)
(f : A →ₗ[R] B) ∘ₗ comul = comul ∘ₗ (f : A →ₗ[R] B)
attribute [simp] CoalgHomClass.counit_comp CoalgHomClass.map_comp_comul | class | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | CoalgHomClass | `CoalgHomClass F R A B` asserts `F` is a type of bundled coalgebra homomorphisms
from `A` to `B`. |
@[coe]
toCoalgHom (f : F) : A →ₗc[R] B :=
{ (f : A →ₗ[R] B) with
toFun := f
counit_comp := CoalgHomClass.counit_comp f
map_comp_comul := CoalgHomClass.map_comp_comul f } | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | toCoalgHom | Turn an element of a type `F` satisfying `CoalgHomClass F R A B` into an actual
`CoalgHom`. This is declared as the default coercion from `F` to `A →ₗc[R] B`. |
instCoeToCoalgHom : CoeHead F (A →ₗc[R] B) :=
⟨CoalgHomClass.toCoalgHom⟩
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | instCoeToCoalgHom | null |
counit_comp_apply (f : F) (x : A) : counit (f x) = counit (R := R) x :=
LinearMap.congr_fun (counit_comp f) _
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | counit_comp_apply | null |
map_comp_comul_apply (f : F) (x : A) :
TensorProduct.map f f (σ₁₂ := .id _) (comul x) = comul (R := R) (f x) :=
LinearMap.congr_fun (map_comp_comul f) _ | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | map_comp_comul_apply | 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 ⟨⟨⟨_, _⟩, _⟩, _, _⟩
congr | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | funLike | null |
coalgHomClass : CoalgHomClass (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 | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coalgHomClass | null |
Simps.apply {R α β : Type*} [CommSemiring R]
[AddCommMonoid α] [Module R α] [AddCommMonoid β]
[Module R β] [CoalgebraStruct R α] [CoalgebraStruct R β]
(f : α →ₗc[R] β) : α → β := f
initialize_simps_projections CoalgHom (toFun → apply)
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | Simps.apply | See Note [custom simps projection] |
protected coe_coe {F : Type*} [FunLike F A B] [CoalgHomClass F R A B] (f : F) :
⇑(f : A →ₗc[R] B) = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_coe | null |
coe_mk {f : A →ₗ[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₗc[R] B) : A → B) = f :=
rfl
@[norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_mk | null |
coe_mks {f : A → B} (h₁ h₂ h₃ h₄) : ⇑(⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩ : A →ₗc[R] B) = f :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_mks | null |
coe_linearMap_mk {f : A →ₗ[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₗc[R] B) : A →ₗ[R] B) = f :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_linearMap_mk | null |
toLinearMap_eq_coe (f : A →ₗc[R] B) : f.toLinearMap = f :=
rfl
@[simp, norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | toLinearMap_eq_coe | null |
coe_toLinearMap (f : A →ₗc[R] B) : ⇑(f : A →ₗ[R] B) = f :=
rfl
@[norm_cast] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_toLinearMap | null |
coe_toAddMonoidHom (f : A →ₗc[R] B) : ⇑(f : A →+ B) = f :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_toAddMonoidHom | null |
coe_fn_injective : @Function.Injective (A →ₗc[R] B) (A → B) (↑) :=
DFunLike.coe_injective | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_fn_injective | null |
coe_fn_inj {φ₁ φ₂ : A →ₗc[R] B} : (φ₁ : A → B) = φ₂ ↔ φ₁ = φ₂ :=
DFunLike.coe_fn_eq | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_fn_inj | null |
coe_linearMap_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.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_linearMap_injective | null |
coe_addMonoidHom_injective : Function.Injective ((↑) : (A →ₗc[R] B) → A →+ B) :=
LinearMap.toAddMonoidHom_injective.comp coe_linearMap_injective | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_addMonoidHom_injective | null |
protected congr_fun {φ₁ φ₂ : A →ₗc[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x :=
DFunLike.congr_fun H x | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/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.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | congr_arg | null |
ext {φ₁ φ₂ : A →ₗc[R] B} (H : ∀ x, φ₁ x = φ₂ x) : φ₁ = φ₂ :=
DFunLike.ext _ _ H
@[ext high] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/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.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | ext_of_ring | null |
mk_coe {f : A →ₗc[R] B} (h₁ h₂ h₃ h₄) : (⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩ : A →ₗc[R] B) = f :=
ext fun _ => rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | mk_coe | null |
protected copy (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : A →ₗc[R] B :=
{ toLinearMap := (f : A →ₗ[R] B).copy f' h
counit_comp := by ext; simp_all
map_comp_comul := by simp only [(f : A →ₗ[R] B).copy_eq f' h,
CoalgHomClass.map_comp_comul] }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | copy | Copy of a `CoalgHom` 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.Basic"
] | Mathlib/RingTheory/Coalgebra/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
variable (R A) | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | copy_eq | null |
@[simps!] protected id : A →ₗc[R] A :=
{ LinearMap.id with
counit_comp := by ext; rfl
map_comp_comul := by simp only [map_id, LinearMap.id_comp, LinearMap.comp_id] }
variable {R A}
@[simp, norm_cast] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | id | Identity map as a `CoalgHom`. |
coe_id : ⇑(CoalgHom.id R A) = id :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_id | null |
id_toLinearMap : (CoalgHom.id R A : A →ₗ[R] A) = LinearMap.id := rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | id_toLinearMap | null |
@[simps!] comp (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) : A →ₗc[R] C :=
{ (φ₁ : B →ₗ[R] C) ∘ₗ (φ₂ : A →ₗ[R] B) with
counit_comp := by ext; simp
map_comp_comul := by ext; simp [map_comp] }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | comp | Composition of coalgebra homomorphisms. |
coe_comp (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) : ⇑(φ₁.comp φ₂) = φ₁ ∘ φ₂ := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | coe_comp | null |
comp_toLinearMap (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) :
φ₁.comp φ₂ = (φ₁ : B →ₗ[R] C) ∘ₗ (φ₂ : A →ₗ[R] B) := rfl
variable (φ : A →ₗc[R] B)
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | comp_toLinearMap | null |
comp_id : φ.comp (CoalgHom.id R A) = φ :=
ext fun _x => rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | comp_id | null |
id_comp : (CoalgHom.id R B).comp φ = φ :=
ext fun _x => rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | id_comp | null |
comp_assoc (φ₁ : C →ₗc[R] D) (φ₂ : B →ₗc[R] C) (φ₃ : A →ₗc[R] B) :
(φ₁.comp φ₂).comp φ₃ = φ₁.comp (φ₂.comp φ₃) :=
ext fun _x => rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | comp_assoc | null |
map_smul_of_tower {R'} [SMul R' A] [SMul R' B] [LinearMap.CompatibleSMul A B R' R] (r : R')
(x : A) : φ (r • x) = r • φ x :=
φ.toLinearMap.map_smul_of_tower r x
@[simps -isSimp toSemigroup_toMul_mul toOne_one] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | map_smul_of_tower | null |
End : Monoid (A →ₗc[R] A) where
mul := comp
mul_assoc _ _ _ := rfl
one := CoalgHom.id R A
one_mul _ := ext fun _ => rfl
mul_one _ := ext fun _ => rfl
@[simp] | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | End | null |
one_apply (x : A) : (1 : A →ₗc[R] A) x = x :=
rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | one_apply | null |
mul_apply (φ ψ : A →ₗc[R] A) (x : A) : (φ * ψ) x = φ (ψ x) :=
rfl | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | mul_apply | null |
noncomputable counitCoalgHom : A →ₗc[R] R :=
{ counit with
counit_comp := by ext; simp
map_comp_comul := by
ext
simp only [LinearMap.coe_comp, Function.comp_apply, CommSemiring.comul_apply,
← LinearMap.lTensor_comp_rTensor, rTensor_counit_comul, LinearMap.lTensor_tmul] }
@[simp] | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | counitCoalgHom | The counit of a coalgebra as a `CoalgHom`. |
counitCoalgHom_apply (x : A) :
counitCoalgHom R A x = counit x := rfl
@[simp] | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | counitCoalgHom_apply | null |
counitCoalgHom_toLinearMap :
counitCoalgHom R A = counit (R := R) (A := A) := rfl
variable {R} | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | counitCoalgHom_toLinearMap | null |
subsingleton_to_ring : Subsingleton (A →ₗc[R] R) :=
⟨fun f g => CoalgHom.ext fun x => by
have hf := CoalgHomClass.counit_comp_apply f x
have hg := CoalgHomClass.counit_comp_apply g x
simp_all only [CommSemiring.counit_apply]⟩
@[ext high] | instance | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | subsingleton_to_ring | null |
ext_to_ring (f g : A →ₗc[R] R) : f = g := Subsingleton.elim _ _
variable {A B} | theorem | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | ext_to_ring | null |
@[simps]
Repr.induced {a : A} (repr : Repr R a)
{F : Type*} [FunLike F A B] [CoalgHomClass F R A B]
(φ : F) : Repr R (φ a) where
index := repr.index
left := φ ∘ repr.left
right := φ ∘ repr.right
eq := (congr($((CoalgHomClass.map_comp_comul φ).symm) a).trans <|
by rw [LinearMap.comp_apply, ← repr.eq, map_sum]; rfl).symm | def | RingTheory | [
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/Hom.lean | Repr.induced | If `φ : A → B` is a coalgebra map and `a = ∑ xᵢ ⊗ yᵢ`, then `φ a = ∑ φ xᵢ ⊗ φ yᵢ` |
instCoalgebra : Coalgebra R (MonoidAlgebra A X) := Finsupp.instCoalgebra R X A | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | instCoalgebra | null |
instIsCocomm [IsCocomm R A] : IsCocomm R (MonoidAlgebra A X) := Finsupp.instIsCocomm R X A
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | instIsCocomm | null |
counit_single (x : X) (a : A) :
Coalgebra.counit (single x a) = Coalgebra.counit (R := R) a :=
Finsupp.counit_single _ _ _ _ _
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | counit_single | null |
comul_single (x : X) (a : A) :
Coalgebra.comul (R := R) (single x a) =
TensorProduct.map (lsingle x) (lsingle x) (Coalgebra.comul a) :=
Finsupp.comul_single _ _ _ _ _ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | comul_single | null |
instCoalgebra : Coalgebra R A[X] := Finsupp.instCoalgebra R X A | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | instCoalgebra | null |
instIsCocomm [IsCocomm R A] : IsCocomm R A[X] := Finsupp.instIsCocomm R X A
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | instIsCocomm | null |
counit_single (x : X) (a : A) :
Coalgebra.counit (single x a) = Coalgebra.counit (R := R) a :=
Finsupp.counit_single _ _ _ _ _
@[simp] | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | counit_single | null |
comul_single (x : X) (a : A) :
Coalgebra.comul (R := R) (single x a) =
TensorProduct.map (lsingle x) (lsingle x) (Coalgebra.comul a) :=
Finsupp.comul_single _ _ _ _ _ | lemma | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | comul_single | null |
instCoalgebra : Coalgebra R A[T;T⁻¹] := inferInstanceAs <| Coalgebra R A[ℤ] | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | instCoalgebra | null |
instIsCocomm [IsCocomm R A] : IsCocomm R A[T;T⁻¹] := inferInstanceAs <| IsCocomm R A[ℤ]
variable {R A}
@[simp] | instance | RingTheory | [
"Mathlib.Algebra.Polynomial.Laurent",
"Mathlib.RingTheory.Coalgebra.Basic"
] | Mathlib/RingTheory/Coalgebra/MonoidAlgebra.lean | instIsCocomm | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.