File: Mathlib/RingTheory/Coalgebra/Equiv.lean

full_name: CoalgEquiv
code: /-- An equivalence of coalgebras is an invertible coalgebra homomorphism. -/
structure CoalgEquiv (R : Type*) [CommSemiring R] (A B : Type*)
    [AddCommMonoid A] [AddCommMonoid B] [Module R A] [Module R B]
    [CoalgebraStruct R A] [CoalgebraStruct R B] extends A →ₗc[R] B, A ≃ₗ[R] B where
goal: Type (max u_6 u_7)

full_name: _aux_Mathlib_RingTheory_Coalgebra_Equiv___unexpand_CoalgEquiv_1
code: @[inherit_doc CoalgEquiv]
notation:50 A " ≃ₗc[" R "] " B => CoalgEquiv R A B
goal: Lean.PrettyPrinter.Unexpander

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

full_name: CoalgEquivClass
code: /-- `CoalgEquivClass F R A B` asserts `F` is a type of bundled coalgebra equivalences
from `A` to `B`.  -/
class CoalgEquivClass (F : Type*) (R A B : outParam Type*) [CommSemiring R]
    [AddCommMonoid A] [AddCommMonoid B] [Module R A] [Module R B]
    [CoalgebraStruct R A] [CoalgebraStruct R B] [EquivLike F A B]
    extends CoalgHomClass F R A B, SemilinearEquivClass F (RingHom.id R) A B : Prop
goal: Prop

full_name: CoalgEquivClass.toCoalgEquiv
code: /-- Reinterpret an element of a type of coalgebra equivalences as a coalgebra equivalence. -/
@[coe]
def toCoalgEquiv [EquivLike F A B] [CoalgEquivClass F R A B] (f : F) : A ≃ₗc[R] B 
goal: A ≃ₗc[R] B

full_name: CoalgEquivClass.instCoeToCoalgEquiv
code: /-- Reinterpret an element of a type of coalgebra equivalences as a coalgebra equivalence. -/
instance instCoeToCoalgEquiv
    [EquivLike F A B] [CoalgEquivClass F R A B] : CoeHead F (A ≃ₗc[R] B) 
goal: CoeHead F (A ≃ₗc[R] B)

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

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

full_name: CoalgEquiv.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: CoalgEquiv.toCoalgHom_injective
code: theorem toCoalgHom_injective : Function.Injective (toCoalgHom : (A ≃ₗc[R] B) → A →ₗc[R] B) 
goal: Function.Injective CoalgEquiv.toCoalgHom

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

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

full_name: CoalgEquiv.instCoalgEquivClass
code: instance : CoalgEquivClass (A ≃ₗc[R] B) R A B 
goal: CoalgEquivClass (A ≃ₗc[R] B) R A B

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

full_name: CoalgEquiv.coe_mk
code: @[simp]
theorem coe_mk {f h h₀ h₁ h₂ h₃ h₄ h₅} :
    (⟨⟨⟨⟨f, 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₅ } =
  f

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

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

full_name: CoalgEquiv.toLinearEquiv_eq_coe
code: @[simp]
theorem toLinearEquiv_eq_coe (f : A ≃ₗc[R] B) : f.toLinearEquiv = f 
goal: f.toLinearEquiv = ↑f

full_name: CoalgEquiv.toCoalgHom_eq_coe
code: @[simp]
theorem toCoalgHom_eq_coe (f : A ≃ₗc[R] B) : f.toCoalgHom = f 
goal: f.toCoalgHom = ↑f

full_name: CoalgEquiv.coe_toLinearEquiv
code: @[simp]
theorem coe_toLinearEquiv : ⇑(e : A ≃ₗ[R] B) = e 
goal: ⇑↑e = ⇑e

full_name: CoalgEquiv.coe_toCoalgHom
code: @[simp]
theorem coe_toCoalgHom : ⇑(e : A →ₗc[R] B) = e 
goal: ⇑↑e = ⇑e

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

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

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

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

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

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

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

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

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

full_name: CoalgEquiv.refl_toCoalgHom
code: @[simp]
theorem refl_toCoalgHom : refl R A = CoalgHom.id R A 
goal: ↑(CoalgEquiv.refl R A) = CoalgHom.id R A

full_name: CoalgEquiv.symm
code: /-- Coalgebra equivalences are symmetric. -/
@[symm]
def symm (e : A ≃ₗc[R] B) : B ≃ₗc[R] A 
goal: B ≃ₗc[R] A

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

full_name: CoalgEquiv.symm_toCoalgHom
code: @[simp]
theorem symm_toCoalgHom (e : A ≃ₗc[R] B) :
    ((e.symm : B →ₗc[R] A) : B →ₗ[R] A) = (e : A ≃ₗ[R] B).symm 
goal: ↑↑e.symm = ↑(↑e).symm

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

full_name: CoalgEquiv.invFun_eq_symm
code: @[simp]
theorem invFun_eq_symm : e.invFun = e.symm 
goal: e.invFun = ⇑e.symm

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

full_name: CoalgEquiv.trans_invFun
code: /-- Coalgebra 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: CoalgEquiv.trans_apply
code: /-- Coalgebra 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: CoalgEquiv.trans
code: /-- Coalgebra 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: CoalgEquiv.trans_toLinearEquiv
code: theorem trans_toLinearEquiv :
    (e₁₂.trans e₂₃ : A ≃ₗ[R] C) = (e₁₂ : A ≃ₗ[R] B) ≪≫ₗ e₂₃ 
goal: ↑(e₁₂.trans e₂₃) = ↑e₁₂ ≪≫ₗ ↑e₂₃

full_name: CoalgEquiv.trans_toCoalgHom
code: @[simp]
theorem trans_toCoalgHom :
    (e₁₂.trans e₂₃ : A →ₗc[R] C) = e₂₃.comp e₁₂ 
goal: ↑(e₁₂.trans e₂₃) = e₂₃.comp ↑e₁₂

full_name: CoalgEquiv.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₂₃)