File: Mathlib/RingTheory/Bialgebra/Equiv.lean

full_name: BialgEquiv
code: /-- An equivalence of bialgebras is an invertible bialgebra homomorphism. -/
structure 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
goal: Type (max v w)

full_name: _aux_Mathlib_RingTheory_Bialgebra_Equiv___unexpand_BialgEquiv_1
code: @[inherit_doc BialgEquiv]
notation:50 A " ≃ₐc[" R "] " B => BialgEquiv R A B
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_RingTheory_Bialgebra_Equiv___macroRules_term_≃ₐc[_]__1»
code: @[inherit_doc BialgEquiv]
notation:50 A " ≃ₐc[" R "] " B => BialgEquiv R A B
goal: Lean.Macro

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

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

full_name: BialgEquivClass.toBialgEquiv
code: /-- Reinterpret an element of a type of bialgebra equivalences as a bialgebra equivalence. -/
@[coe]
def toBialgEquiv (f : F) : A ≃ₐc[R] B 
goal: A ≃ₐc[R] B

full_name: BialgEquivClass.instCoeToBialgEquiv
code: /-- Reinterpret an element of a type of bialgebra equivalences as a bialgebra equivalence. -/
instance instCoeToBialgEquiv : CoeHead F (A ≃ₐc[R] B) 
goal: CoeHead F (A ≃ₐc[R] B)

full_name: BialgEquivClass.toAlgEquivClass
code: instance (priority := 100) toAlgEquivClass : AlgEquivClass F R A B 
goal: AlgEquivClass F R A B

full_name: BialgEquiv.toBialgHom
code: /-- The bialgebra morphism underlying a bialgebra equivalence. -/
def toBialgHom (f : A ≃ₐc[R] B) : A →ₐc[R] B 
goal: A →ₐc[R] B

full_name: BialgEquiv.toAlgEquiv
code: /-- The algebra equivalence underlying a bialgebra equivalence. -/
def toAlgEquiv (f : A ≃ₐc[R] B) : A ≃ₐ[R] B 
goal: A ≃ₐ[R] B

full_name: BialgEquiv.toEquiv
code: /-- The equivalence of types underlying a bialgebra equivalence. -/
def toEquiv : (A ≃ₐc[R] B) → A ≃ B 
goal: (A ≃ₐc[R] B) → A ≃ B

full_name: BialgEquiv.toEquiv_injective
code: theorem toEquiv_injective : Function.Injective (toEquiv : (A ≃ₐc[R] B) → A ≃ B) 
goal: Function.Injective BialgEquiv.toEquiv

full_name: BialgEquiv.toEquiv_inj
code: @[simp]
theorem toEquiv_inj {e₁ e₂ : A ≃ₐc[R] B} : e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂ 
goal: e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂

full_name: BialgEquiv.toBialgHom_injective
code: theorem toBialgHom_injective : Function.Injective (toBialgHom : (A ≃ₐc[R] B) → A →ₐc[R] B) 
goal: Function.Injective BialgEquiv.toBialgHom

full_name: BialgEquiv.instEquivLike
code: instance : EquivLike (A ≃ₐc[R] B) A B 
goal: EquivLike (A ≃ₐc[R] B) A B

full_name: BialgEquiv.instFunLike
code: instance : FunLike (A ≃ₐc[R] B) A B 
goal: FunLike (A ≃ₐc[R] B) A B

full_name: BialgEquiv.instBialgEquivClass
code: instance : BialgEquivClass (A ≃ₐc[R] B) R A B 
goal: BialgEquivClass (A ≃ₐc[R] B) R A B

full_name: BialgEquiv.toBialgHom_inj
code: @[simp, norm_cast]
theorem toBialgHom_inj {e₁ e₂ : A ≃ₐc[R] B} : (↑e₁ : A →ₐc[R] B) = e₂ ↔ e₁ = e₂ 
goal: ↑e₁ = ↑e₂ ↔ e₁ = e₂

full_name: BialgEquiv.coe_mk
code: @[simp]
theorem coe_mk {f h h₀ h₁ h₂ h₃ h₄ h₅ h₆} :
    (⟨⟨⟨⟨⟨f, h⟩, h₀⟩, 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₂, invFun := h₃, left_inv := h₄,
      right_inv := h₅, map_mul' := h₆ } =
  f

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

full_name: BialgEquiv.coe_coe
code: @[simp, norm_cast]
theorem coe_coe : ⇑(e : A →ₐc[R] B) = e 
goal: ⇑↑e = ⇑e

full_name: BialgEquiv.toCoalgEquiv_eq_coe
code: @[simp]
theorem toCoalgEquiv_eq_coe (f : A ≃ₐc[R] B) : f.toCoalgEquiv = f 
goal: f.toCoalgEquiv = ↑f

full_name: BialgEquiv.toBialgHom_eq_coe
code: @[simp]
theorem toBialgHom_eq_coe (f : A ≃ₐc[R] B) : f.toBialgHom = f 
goal: f.toBialgHom = ↑f

full_name: BialgEquiv.toAlgEquiv_eq_coe
code: @[simp]
theorem toAlgEquiv_eq_coe (f : A ≃ₐc[R] B) : f.toAlgEquiv = f 
goal: f.toAlgEquiv = ↑f

full_name: BialgEquiv.coe_toCoalgEquiv
code: @[simp]
theorem coe_toCoalgEquiv : ⇑(e : A ≃ₐ[R] B) = e 
goal: ⇑↑e = ⇑e

full_name: BialgEquiv.coe_toBialgHom
code: @[simp]
theorem coe_toBialgHom : ⇑(e : A →ₐc[R] B) = e 
goal: ⇑↑e = ⇑e

full_name: BialgEquiv.coe_toAlgEquiv
code: @[simp]
theorem coe_toAlgEquiv : ⇑(e : A ≃ₐ[R] B) = e 
goal: ⇑↑e = ⇑e

full_name: BialgEquiv.toCoalgEquiv_toCoalgHom
code: theorem toCoalgEquiv_toCoalgHom : ((e : A ≃ₐc[R] B) : A →ₗc[R] B) = (e : A →ₐc[R] B) 
goal: ↑e = ↑↑e

full_name: BialgEquiv.toBialgHom_toAlgHom
code: theorem toBialgHom_toAlgHom : ((e : A →ₐc[R] B) : A →ₐ[R] B) = e 
goal: ↑↑e = ↑e

full_name: BialgEquiv.ext
code: @[ext]
theorem ext (h : ∀ x, e x = e' x) : e = e' 
goal: e = e'

full_name: BialgEquiv.ext_iff
code: theorem ext_iff : e = e' ↔ ∀ x, e x = e' x 
goal: e = e' ↔ ∀ (x : A), e x = e' x

full_name: BialgEquiv.congr_arg
code: protected theorem congr_arg {x x'} : x = x' → e x = e x' 
goal: x = x' → e x = e x'

full_name: BialgEquiv.congr_fun
code: protected theorem congr_fun (h : e = e') (x : A) : e x = e' x 
goal: e x = e' x

full_name: BialgEquiv.refl
code: /-- The identity map is a bialgebra equivalence. -/
@[refl, simps!]
def refl : A ≃ₐc[R] A 
goal: A ≃ₐc[R] A

full_name: BialgEquiv.refl_apply
code: /-- The identity map is a bialgebra equivalence. -/
@[refl, simps!]
def refl : A ≃ₐc[R] A 
goal: (BialgEquiv.refl R A) a = a

full_name: BialgEquiv.refl_invFun
code: /-- The identity map is a bialgebra equivalence. -/
@[refl, simps!]
def refl : A ≃ₐc[R] A 
goal: ∀ (a : A), (BialgEquiv.refl R A).invFun a = a

full_name: BialgEquiv.refl_toCoalgEquiv
code: @[simp]
theorem refl_toCoalgEquiv : refl R A = CoalgEquiv.refl R A 
goal: ↑(BialgEquiv.refl R A) = CoalgEquiv.refl R A

full_name: BialgEquiv.refl_toBialgHom
code: @[simp]
theorem refl_toBialgHom : refl R A = BialgHom.id R A 
goal: ↑(BialgEquiv.refl R A) = BialgHom.id R A

full_name: BialgEquiv.symm
code: /-- Bialgebra equivalences are symmetric. -/
@[symm]
def symm (e : A ≃ₐc[R] B) : B ≃ₐc[R] A 
goal: B ≃ₐc[R] A

full_name: BialgEquiv.symm_toCoalgEquiv
code: @[simp]
theorem symm_toCoalgEquiv (e : A ≃ₐc[R] B) :
    e.symm = (e : A ≃ₗc[R] B).symm 
goal: ↑e.symm = (↑e).symm

full_name: BialgEquiv.Simps.symm_apply
code: /-- See Note [custom simps projection] -/
def 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 
goal: B → A

full_name: BialgEquiv.invFun_eq_symm
code: theorem invFun_eq_symm : e.invFun = e.symm 
goal: e.invFun = ⇑e.symm

full_name: BialgEquiv.coe_toEquiv_symm
code: @[simp]
theorem coe_toEquiv_symm : e.toEquiv.symm = e.symm 
goal: e.toEquiv.symm = ↑e.symm

full_name: BialgEquiv.trans
code: /-- Bialgebra equivalences are transitive. -/
@[trans, simps!]
def trans (e₁₂ : A ≃ₐc[R] B) (e₂₃ : B ≃ₐc[R] C) : A ≃ₐc[R] C 
goal: A ≃ₐc[R] C

full_name: BialgEquiv.trans_invFun
code: /-- Bialgebra equivalences are transitive. -/
@[trans, simps!]
def trans (e₁₂ : A ≃ₐc[R] B) (e₂₃ : B ≃ₐc[R] C) : A ≃ₐc[R] C 
goal: ∀ (a : C), (e₁₂.trans e₂₃).invFun a = (↑↑e₁₂).symm ((↑↑e₂₃).symm a)

full_name: BialgEquiv.trans_apply
code: /-- Bialgebra equivalences are transitive. -/
@[trans, simps!]
def trans (e₁₂ : A ≃ₐc[R] B) (e₂₃ : B ≃ₐc[R] C) : A ≃ₐc[R] C 
goal: ∀ (a : A), (e₁₂.trans e₂₃) a = ↑e₂₃ (↑e₁₂ a)

full_name: BialgEquiv.trans_toCoalgEquiv
code: @[simp]
theorem trans_toCoalgEquiv :
    (e₁₂.trans e₂₃ : A ≃ₗc[R] C) = (e₁₂ : A ≃ₗc[R] B).trans (e₂₃ : B ≃ₗc[R] C) 
goal: ↑(e₁₂.trans e₂₃) = (↑e₁₂).trans ↑e₂₃

full_name: BialgEquiv.trans_toBialgHom
code: @[simp]
theorem trans_toBialgHom :
    (e₁₂.trans e₂₃ : A →ₐc[R] C) = (e₂₃ : B →ₐc[R] C).comp e₁₂ 
goal: ↑(e₁₂.trans e₂₃) = (↑e₂₃).comp ↑e₁₂

full_name: BialgEquiv.coe_toEquiv_trans
code: @[simp]
theorem coe_toEquiv_trans : (e₁₂ : A ≃ B).trans e₂₃ = (e₁₂.trans e₂₃ : A ≃ C) 
goal: (↑e₁₂).trans ↑e₂₃ = ↑(e₁₂.trans e₂₃)