File: Mathlib/RingTheory/Coalgebra/Hom.lean

full_name: CoalgHom.counit_comp
code: /-- 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`. -/
structure 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
goal: Coalgebra.counit ∘ₗ self.toLinearMap = Coalgebra.counit

full_name: CoalgHom
code: /-- 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`. -/
structure 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
goal: Type (max u_2 u_3)

full_name: CoalgHom.map_comp_comul
code: /-- 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`. -/
structure 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
goal: TensorProduct.map self.toLinearMap self.toLinearMap ∘ₗ Coalgebra.comul = Coalgebra.comul ∘ₗ self.toLinearMap

full_name: «_aux_Mathlib_RingTheory_Coalgebra_Hom___macroRules_term_→ₗc__1»
code: @[inherit_doc CoalgHom]
infixr:25 " →ₗc " => CoalgHom _
goal: Lean.Macro

full_name: «_aux_Mathlib_RingTheory_Coalgebra_Hom___macroRules_term_→ₗc[_]__1»
code: @[inherit_doc]
notation:25 A " →ₗc[" R "] " B => CoalgHom R A B
goal: Lean.Macro

full_name: _aux_Mathlib_RingTheory_Coalgebra_Hom___unexpand_CoalgHom_1
code: @[inherit_doc]
notation:25 A " →ₗc[" R "] " B => CoalgHom R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: CoalgHomClass.map_comp_comul
code: /-- `CoalgHomClass F R A B` asserts `F` is a type of bundled coalgebra homomorphisms
from `A` to `B`.  -/
class 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]
    extends SemilinearMapClass F (RingHom.id R) A B : Prop 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)
goal: TensorProduct.map ↑f ↑f ∘ₗ Coalgebra.comul = Coalgebra.comul ∘ₗ ↑f

full_name: CoalgHomClass.counit_comp
code: /-- `CoalgHomClass F R A B` asserts `F` is a type of bundled coalgebra homomorphisms
from `A` to `B`.  -/
class 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]
    extends SemilinearMapClass F (RingHom.id R) A B : Prop 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)
goal: Coalgebra.counit ∘ₗ ↑f = Coalgebra.counit

full_name: CoalgHomClass
code: /-- `CoalgHomClass F R A B` asserts `F` is a type of bundled coalgebra homomorphisms
from `A` to `B`.  -/
class 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]
    extends SemilinearMapClass F (RingHom.id R) A B : Prop 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)
goal: Prop

full_name: CoalgHomClass.toCoalgHom
code: /-- 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`. -/
@[coe]
def toCoalgHom (f : F) : A →ₗc[R] B 
goal: A →ₗc[R] B

full_name: CoalgHomClass.instCoeToCoalgHom
code: instance instCoeToCoalgHom : CoeHead F (A →ₗc[R] B) 
goal: CoeHead F (A →ₗc[R] B)

full_name: CoalgHomClass.counit_comp_apply
code: @[simp]
theorem counit_comp_apply (f : F) (x : A) : counit (f x) = counit (R := R) x 
goal: Coalgebra.counit (f x) = Coalgebra.counit x

full_name: CoalgHomClass.map_comp_comul_apply
code: @[simp]
theorem map_comp_comul_apply (f : F) (x : A) :
    TensorProduct.map f f (comul x) = comul (R := R) (f x) 
goal: (TensorProduct.map ↑f ↑f) (Coalgebra.comul x) = Coalgebra.comul (f x)

full_name: CoalgHom.funLike
code: instance funLike : FunLike (A →ₗc[R] B) A B 
goal: FunLike (A →ₗc[R] B) A B

full_name: CoalgHom.coalgHomClass
code: instance coalgHomClass : CoalgHomClass (A →ₗc[R] B) R A B 
goal: CoalgHomClass (A →ₗc[R] B) R A B

full_name: CoalgHom.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply {R α β : Type*} [CommSemiring R]
    [AddCommMonoid α] [Module R α] [AddCommMonoid β]
    [Module R β] [CoalgebraStruct R α] [CoalgebraStruct R β]
    (f : α →ₗc[R] β) : α → β 
goal: α → β

full_name: CoalgHom.coe_coe
code: @[simp]
protected theorem coe_coe {F : Type*} [FunLike F A B] [CoalgHomClass F R A B] (f : F) :
    ⇑(f : A →ₗc[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: CoalgHom.coe_mk
code: @[simp]
theorem coe_mk {f : A →ₗ[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₗc[R] B) : A → B) = f 
goal: ⇑{ toLinearMap := f, counit_comp := h, map_comp_comul := h₁ } = ⇑f

full_name: CoalgHom.coe_mks
code: @[norm_cast]
theorem coe_mks {f : A → B} (h₁ h₂ h₃ h₄) : ⇑(⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩ : A →ₗc[R] B) = f 
goal: ⇑{ toFun := f, map_add' := h₁, map_smul' := h₂, counit_comp := h₃, map_comp_comul := h₄ } = f

full_name: CoalgHom.coe_linearMap_mk
code: @[simp, norm_cast]
theorem coe_linearMap_mk {f : A →ₗ[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₗc[R] B) : A →ₗ[R] B) = f 
goal: ↑{ toLinearMap := f, counit_comp := h, map_comp_comul := h₁ } = f

full_name: CoalgHom.toLinearMap_eq_coe
code: @[simp]
theorem toLinearMap_eq_coe (f : A →ₗc[R] B) : f.toLinearMap = f 
goal: f.toLinearMap = ↑f

full_name: CoalgHom.coe_toLinearMap
code: @[simp, norm_cast]
theorem coe_toLinearMap (f : A →ₗc[R] B) : ⇑(f : A →ₗ[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: CoalgHom.coe_toAddMonoidHom
code: @[norm_cast]
theorem coe_toAddMonoidHom (f : A →ₗc[R] B) : ⇑(f : A →+ B) = f 
goal: ⇑↑f = ⇑f

full_name: CoalgHom.coe_fn_injective
code: theorem coe_fn_injective : @Function.Injective (A →ₗc[R] B) (A → B) (↑) 
goal: Function.Injective DFunLike.coe

full_name: CoalgHom.coe_fn_inj
code: theorem coe_fn_inj {φ₁ φ₂ : A →ₗc[R] B} : (φ₁ : A → B) = φ₂ ↔ φ₁ = φ₂ 
goal: ⇑φ₁ = ⇑φ₂ ↔ φ₁ = φ₂

full_name: CoalgHom.coe_linearMap_injective
code: theorem coe_linearMap_injective : Function.Injective ((↑) : (A →ₗc[R] B) → A →ₗ[R] B) 
goal: Function.Injective fun x => ↑x

full_name: CoalgHom.coe_addMonoidHom_injective
code: theorem coe_addMonoidHom_injective : Function.Injective ((↑) : (A →ₗc[R] B) → A →+ B) 
goal: Function.Injective AddMonoidHomClass.toAddMonoidHom

full_name: CoalgHom.congr_fun
code: protected theorem congr_fun {φ₁ φ₂ : A →ₗc[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x 
goal: φ₁ x = φ₂ x

full_name: CoalgHom.congr_arg
code: protected theorem congr_arg (φ : A →ₗc[R] B) {x y : A} (h : x = y) : φ x = φ y 
goal: φ x = φ y

full_name: CoalgHom.ext
code: @[ext]
theorem ext {φ₁ φ₂ : A →ₗc[R] B} (H : ∀ x, φ₁ x = φ₂ x) : φ₁ = φ₂ 
goal: φ₁ = φ₂

full_name: CoalgHom.ext_iff
code: theorem ext_iff {φ₁ φ₂ : A →ₗc[R] B} : φ₁ = φ₂ ↔ ∀ x, φ₁ x = φ₂ x 
goal: φ₁ = φ₂ ↔ ∀ (x : A), φ₁ x = φ₂ x

full_name: CoalgHom.ext_of_ring
code: @[ext high]
theorem ext_of_ring {f g : R →ₗc[R] A} (h : f 1 = g 1) : f = g 
goal: f = g

full_name: CoalgHom.mk_coe
code: @[simp]
theorem mk_coe {f : A →ₗc[R] B} (h₁ h₂ h₃ h₄) : (⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩ : A →ₗc[R] B) = f 
goal: { toFun := ⇑f, map_add' := h₁, map_smul' := h₂, counit_comp := h₃, map_comp_comul := h₄ } = f

full_name: CoalgHom.copy
code: /-- Copy of a `CoalgHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : A →ₗc[R] B 
goal: A →ₗc[R] B

full_name: CoalgHom.coe_copy
code: @[simp]
theorem coe_copy (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: CoalgHom.copy_eq
code: theorem copy_eq (f : A →ₗc[R] B) (f' : A → B) (h : f' = ⇑f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: CoalgHom.id_apply
code: /-- Identity map as a `CoalgHom`. -/
@[simps!] protected def id : A →ₗc[R] A 
goal: (CoalgHom.id R A) a = a

full_name: CoalgHom.id
code: /-- Identity map as a `CoalgHom`. -/
@[simps!] protected def id : A →ₗc[R] A 
goal: A →ₗc[R] A

full_name: CoalgHom.coe_id
code: @[simp]
theorem coe_id : ⇑(CoalgHom.id R A) = id 
goal: ⇑(CoalgHom.id R A) = id

full_name: CoalgHom.id_toLinearMap
code: @[simp]
theorem id_toLinearMap : (CoalgHom.id R A : A →ₗ[R] A) = LinearMap.id 
goal: ↑(CoalgHom.id R A) = LinearMap.id

full_name: CoalgHom.comp
code: /-- Composition of coalgebra homomorphisms. -/
@[simps!] def comp (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) : A →ₗc[R] C 
goal: A →ₗc[R] C

full_name: CoalgHom.comp_apply
code: /-- Composition of coalgebra homomorphisms. -/
@[simps!] def comp (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) : A →ₗc[R] C 
goal: ∀ (a : A), (φ₁.comp φ₂) a = φ₁ (φ₂ a)

full_name: CoalgHom.coe_comp
code: @[simp]
theorem coe_comp (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) : ⇑(φ₁.comp φ₂) = φ₁ ∘ φ₂ 
goal: ⇑(φ₁.comp φ₂) = ⇑φ₁ ∘ ⇑φ₂

full_name: CoalgHom.comp_toLinearMap
code: @[simp]
theorem comp_toLinearMap (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) :
    φ₁.comp φ₂ = (φ₁ : B →ₗ[R] C) ∘ₗ (φ₂ : A →ₗ[R] B) 
goal: ↑(φ₁.comp φ₂) = ↑φ₁ ∘ₗ ↑φ₂

full_name: CoalgHom.comp_id
code: @[simp]
theorem comp_id : φ.comp (CoalgHom.id R A) = φ 
goal: φ.comp (CoalgHom.id R A) = φ

full_name: CoalgHom.id_comp
code: @[simp]
theorem id_comp : (CoalgHom.id R B).comp φ = φ 
goal: (CoalgHom.id R B).comp φ = φ

full_name: CoalgHom.comp_assoc
code: theorem comp_assoc (φ₁ : C →ₗc[R] D) (φ₂ : B →ₗc[R] C) (φ₃ : A →ₗc[R] B) :
    (φ₁.comp φ₂).comp φ₃ = φ₁.comp (φ₂.comp φ₃) 
goal: (φ₁.comp φ₂).comp φ₃ = φ₁.comp (φ₂.comp φ₃)

full_name: CoalgHom.map_smul_of_tower
code: theorem 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 
goal: φ (r • x) = r • φ x

full_name: CoalgHom.End_toSemigroup_toMul_mul
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₗc[R] A) 
goal: φ₁ * φ₂ = φ₁.comp φ₂

full_name: CoalgHom.End_toOne_one
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₗc[R] A) 
goal: 1 = CoalgHom.id R A

full_name: CoalgHom.End
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₗc[R] A) 
goal: Monoid (A →ₗc[R] A)

full_name: CoalgHom.one_apply
code: @[simp]
theorem one_apply (x : A) : (1 : A →ₗc[R] A) x = x 
goal: 1 x = x

full_name: CoalgHom.mul_apply
code: @[simp]
theorem mul_apply (φ ψ : A →ₗc[R] A) (x : A) : (φ * ψ) x = φ (ψ x) 
goal: (φ * ψ) x = φ (ψ x)

full_name: Coalgebra.counitCoalgHom
code: /-- The counit of a coalgebra as a `CoalgHom`. -/
def counitCoalgHom : A →ₗc[R] R 
goal: A →ₗc[R] R

full_name: Coalgebra.counitCoalgHom_apply
code: @[simp]
theorem counitCoalgHom_apply (x : A) :
    counitCoalgHom R A x = counit x 
goal: (Coalgebra.counitCoalgHom R A) x = Coalgebra.counit x

full_name: Coalgebra.counitCoalgHom_toLinearMap
code: @[simp]
theorem counitCoalgHom_toLinearMap :
    counitCoalgHom R A = counit (R := R) (A := A) 
goal: ↑(Coalgebra.counitCoalgHom R A) = Coalgebra.counit

full_name: Coalgebra.subsingleton_to_ring
code: instance subsingleton_to_ring : Subsingleton (A →ₗc[R] R) 
goal: Subsingleton (A →ₗc[R] R)

full_name: Coalgebra.ext_to_ring
code: @[ext high]
theorem ext_to_ring (f g : A →ₗc[R] R) : f = g 
goal: f = g