File: Mathlib/RingTheory/Bialgebra/Hom.lean

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

full_name: «_aux_Mathlib_RingTheory_Bialgebra_Hom___macroRules_term_→ₐc__1»
code: @[inherit_doc BialgHom]
infixr:25 " →ₐc " => BialgHom _
goal: Lean.Macro

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

full_name: _aux_Mathlib_RingTheory_Bialgebra_Hom___unexpand_BialgHom_1
code: @[inherit_doc]
notation:25 A " →ₐc[" R "] " B => BialgHom R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: BialgHomClass
code: /-- `BialgHomClass F R A B` asserts `F` is a type of bundled bialgebra homomorphisms
from `A` to `B`.  -/
class 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]
    extends CoalgHomClass F R A B, MonoidHomClass F A B : Prop
goal: Prop

full_name: BialgHomClass.toAlgHomClass
code: instance (priority := 100) toAlgHomClass : AlgHomClass F R A B 
goal: AlgHomClass F R A B

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

full_name: BialgHomClass.instCoeToBialgHom
code: instance instCoeToBialgHom :
    CoeHead F (A →ₐc[R] B) 
goal: CoeHead F (A →ₐc[R] B)

full_name: BialgHomClass.counitAlgHom_comp
code: @[simp]
theorem counitAlgHom_comp (f : F) :
    (counitAlgHom R B).comp (f : A →ₐ[R] B) = counitAlgHom R A 
goal: (Bialgebra.counitAlgHom R B).comp ↑f = Bialgebra.counitAlgHom R A

full_name: BialgHomClass.map_comp_comulAlgHom
code: @[simp]
theorem map_comp_comulAlgHom (f : F) :
    (Algebra.TensorProduct.map f f).comp (comulAlgHom R A) = (comulAlgHom R B).comp f 
goal: (Algebra.TensorProduct.map ↑f ↑f).comp (Bialgebra.comulAlgHom R A) = (Bialgebra.comulAlgHom R B).comp ↑f

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

full_name: BialgHom.bialgHomClass
code: instance bialgHomClass : BialgHomClass (A →ₐc[R] B) R A B 
goal: BialgHomClass (A →ₐc[R] B) R A B

full_name: BialgHom.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply {R α β : Type*} [CommSemiring R]
    [Semiring α] [Algebra R α] [Semiring β]
    [Algebra R β] [CoalgebraStruct R α] [CoalgebraStruct R β]
    (f : α →ₐc[R] β) : α → β 
goal: α → β

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

full_name: BialgHom.coe_mk
code: @[simp]
theorem coe_mk {f : A →ₗc[R] B} (h h₁) : ((⟨f, h, h₁⟩ : A →ₐc[R] B) : A → B) = f 
goal: ⇑{ toCoalgHom := f, map_one' := h, map_mul' := h₁ } = ⇑f

full_name: BialgHom.coe_mks
code: @[norm_cast]
theorem coe_mks {f : A → B} (h₀ h₁ h₂ h₃ h₄ h₅) :
    ⇑(⟨⟨⟨⟨f, h₀⟩, h₁⟩, 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₃, map_one' := h₄,
      map_mul' := h₅ } =
  f

full_name: BialgHom.coe_coalgHom_mk
code: @[simp, norm_cast]
theorem coe_coalgHom_mk {f : A →ₗc[R] B} (h h₁) :
    ((⟨f, h, h₁⟩ : A →ₐc[R] B) : A →ₗc[R] B) = f 
goal: ↑{ toCoalgHom := f, map_one' := h, map_mul' := h₁ } = f

full_name: BialgHom.coe_toCoalgHom
code: @[norm_cast]
theorem coe_toCoalgHom (f : A →ₐc[R] B) : ⇑(f : A →ₗc[R] B) = f 
goal: ⇑↑f = ⇑f

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

full_name: BialgHom.coe_toAlgHom
code: @[norm_cast]
theorem coe_toAlgHom (f : A →ₐc[R] B) : ⇑(f : A →ₐ[R] B) = f 
goal: ⇑↑f = ⇑f

full_name: BialgHom.toAlgHom_toLinearMap
code: theorem toAlgHom_toLinearMap (f : A →ₐc[R] B) :
    ((f : A →ₐ[R] B) : A →ₗ[R] B) = f 
goal: (↑↑f).toLinearMap = ↑f

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

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

full_name: BialgHom.coe_coalgHom_injective
code: theorem coe_coalgHom_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₗc[R] B) 
goal: Function.Injective CoalgHomClass.toCoalgHom

full_name: BialgHom.coe_algHom_injective
code: theorem coe_algHom_injective : Function.Injective ((↑) : (A →ₐc[R] B) → A →ₐ[R] B) 
goal: Function.Injective AlgHomClass.toAlgHom

full_name: BialgHom.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: BialgHom.congr_fun
code: protected theorem congr_fun {φ₁ φ₂ : A →ₐc[R] B} (H : φ₁ = φ₂) (x : A) : φ₁ x = φ₂ x 
goal: φ₁ x = φ₂ x

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

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

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

full_name: BialgHom.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: BialgHom.mk_coe
code: @[simp]
theorem 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 
goal: { toFun := ⇑f, map_add' := h₀, map_smul' := h₁, counit_comp := h₂, map_comp_comul := h₃, map_one' := h₄,
    map_mul' := h₅ } =
  f

full_name: BialgHom.copy
code: /-- Copy of a `BialgHom` 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: BialgHom.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: BialgHom.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: BialgHom.id_apply
code: /-- Identity map as a `BialgHom`. -/
@[simps!] protected def id : A →ₐc[R] A 
goal: (BialgHom.id R A) a = a

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

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

full_name: BialgHom.id_toCoalgHom
code: @[simp]
theorem id_toCoalgHom : BialgHom.id R A = CoalgHom.id R A 
goal: ↑(BialgHom.id R A) = CoalgHom.id R A

full_name: BialgHom.id_toAlgHom
code: @[simp]
theorem id_toAlgHom : BialgHom.id R A = AlgHom.id R A 
goal: ↑(BialgHom.id R A) = AlgHom.id R A

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

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

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

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

full_name: BialgHom.comp_toAlgHom
code: @[simp]
theorem comp_toAlgHom (φ₁ : B →ₐc[R] C) (φ₂ : A →ₐc[R] B) :
    φ₁.comp φ₂ = (φ₁ : B →ₐ[R] C).comp (φ₂ : A →ₐ[R] B) 
goal: ↑(φ₁.comp φ₂) = (↑φ₁).comp ↑φ₂

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

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

full_name: BialgHom.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: BialgHom.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: BialgHom.End_toOne_one
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₐc[R] A) 
goal: 1 = BialgHom.id R A

full_name: BialgHom.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: BialgHom.End_toSemigroup_toMul_mul
code: @[simps (config := .lemmasOnly) toSemigroup_toMul_mul toOne_one]
instance End : Monoid (A →ₐc[R] A) 
goal: φ₁ * φ₂ = φ₁.comp φ₂

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

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

full_name: Bialgebra.counitBialgHom
code: /-- The counit of a bialgebra as a `BialgHom`. -/
def counitBialgHom : A →ₐc[R] R 
goal: A →ₐc[R] R

full_name: Bialgebra.counitBialgHom_apply
code: @[simp]
theorem counitBialgHom_apply (x : A) :
    counitBialgHom R A x = Coalgebra.counit x 
goal: (Bialgebra.counitBialgHom R A) x = Coalgebra.counit x

full_name: Bialgebra.counitBialgHom_toCoalgHom
code: @[simp]
theorem counitBialgHom_toCoalgHom :
    counitBialgHom R A = Coalgebra.counitCoalgHom R A 
goal: ↑(Bialgebra.counitBialgHom R A) = Coalgebra.counitCoalgHom R A

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

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