ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Frm.coe_of
@[simp]
theorem coe_of (α : Type*) [Frame α] : ↥(of α) = α 
Arguments: (α : Type u_1) [Order.Frame α]
Goal: ↑(Frm.of α) = α
-- Frm.Iso.mk_hom_toFun
@[simps]
def Iso.mk {α β : Frm.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : Frm} (e : ↑α ≃o ↑β) (a : ↑α)
Goal: (Frm.Iso.mk e).hom a = e a
-- Frm.Iso.mk_inv_toFun
@[simps]
def Iso.mk {α β : Frm.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : Frm} (e : ↑α ≃o ↑β) (a : ↑β)
Goal: (Frm.Iso.mk e).inv a = e.symm a
-- topCatOpToFrm_obj
@[simps]
def topCatOpToFrm : TopCatᵒᵖ ⥤ Frm 
Arguments: (X : TopCatᵒᵖ)
Goal: topCatOpToFrm.obj X = Frm.of (TopologicalSpace.Opens ↑(Opposite.unop X))
-- topCatOpToFrm_map
@[simps]
def topCatOpToFrm : TopCatᵒᵖ ⥤ Frm 
Goal: ∀ {X Y : TopCatᵒᵖ} (f : X ⟶ Y), topCatOpToFrm.map f = TopologicalSpace.Opens.comap f.unop
-- HeytAlg.coe_of
@[simp]
theorem coe_of (α : Type*) [HeytingAlgebra α] : ↥(of α) = α 
Arguments: (α : Type u_1) [HeytingAlgebra α]
Goal: ↑(HeytAlg.of α) = α
-- HeytAlg.hasForgetToLat_forget₂_obj
@[simps]
instance hasForgetToLat : HasForget₂ HeytAlg BddDistLat 
Arguments: (X : HeytAlg)
Goal: CategoryTheory.HasForget₂.forget₂.obj X = BddDistLat.of ↑X
-- HeytAlg.hasForgetToLat_forget₂_map_toLatticeHom_toSupHom_toFun
@[simps]
instance hasForgetToLat : HasForget₂ HeytAlg BddDistLat 
Arguments: {X Y : HeytAlg} (f : X ⟶ Y) (a : ↑X)
Goal: (CategoryTheory.HasForget₂.forget₂.map f).toSupHom a = f a
-- HeytAlg.Iso.mk_inv_toFun
@[simps]
def Iso.mk {α β : HeytAlg.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : HeytAlg} (e : ↑α ≃o ↑β) (a : ↑β)
Goal: (HeytAlg.Iso.mk e).inv a = e.symm a
-- HeytAlg.Iso.mk_hom_toFun
@[simps]
def Iso.mk {α β : HeytAlg.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : HeytAlg} (e : ↑α ≃o ↑β) (a : ↑α)
Goal: (HeytAlg.Iso.mk e).hom a = e a
-- CompleteLat.coe_of
@[simp]
theorem coe_of (α : Type*) [CompleteLattice α] : ↥(of α) = α 
Arguments: (α : Type u_1) [CompleteLattice α]
Goal: ↑(CompleteLat.of α) = α
-- CompleteLat.Iso.mk_hom_toFun
@[simps]
def Iso.mk {α β : CompleteLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : CompleteLat} (e : ↑α ≃o ↑β) (a : ↑α)
Goal: (CompleteLat.Iso.mk e).hom.toFun a = e a
-- CompleteLat.Iso.mk_inv_toFun
@[simps]
def Iso.mk {α β : CompleteLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : CompleteLat} (e : ↑α ≃o ↑β) (a : ↑β)
Goal: (CompleteLat.Iso.mk e).inv.toFun a = e.symm a
-- CompleteLat.dual_obj
@[simps]
def dual : CompleteLat ⥤ CompleteLat 
Arguments: (X : CompleteLat)
Goal: CompleteLat.dual.obj X = CompleteLat.of (↑X)ᵒᵈ
-- CompleteLat.dual_map
@[simps]
def dual : CompleteLat ⥤ CompleteLat 
Arguments: {X Y : CompleteLat} (a : CompleteLatticeHom ↑X ↑Y)
Goal: CompleteLat.dual.map a = CompleteLatticeHom.dual a
-- CompleteLat.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : CompleteLat ≌ CompleteLat 
Goal: CompleteLat.dualEquiv.inverse = CompleteLat.dual
-- CompleteLat.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : CompleteLat ≌ CompleteLat 
Goal: CompleteLat.dualEquiv.functor = CompleteLat.dual
-- completeLat_dual_comp_forget_to_bddLat
theorem completeLat_dual_comp_forget_to_bddLat :
    CompleteLat.dual ⋙ forget₂ CompleteLat BddLat =
    forget₂ CompleteLat BddLat ⋙ BddLat.dual 
Goal: CompleteLat.dual ⋙ CategoryTheory.forget₂ CompleteLat BddLat = CategoryTheory.forget₂ CompleteLat BddLat ⋙ BddLat.dual
-- FinBddDistLat.Iso.mk_hom_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : FinBddDistLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : FinBddDistLat} (e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat) (a : ↑α.toBddDistLat.toDistLat)
Goal: (FinBddDistLat.Iso.mk e).hom.toSupHom a = e a
-- FinBddDistLat.Iso.mk_inv_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : FinBddDistLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : FinBddDistLat} (e : ↑α.toBddDistLat.toDistLat ≃o ↑β.toBddDistLat.toDistLat) (a : ↑β.toBddDistLat.toDistLat)
Goal: (FinBddDistLat.Iso.mk e).inv.toSupHom a = e.symm a
-- FinBddDistLat.dual_obj
@[simps]
def dual : FinBddDistLat ⥤ FinBddDistLat 
Arguments: (X : FinBddDistLat)
Goal: FinBddDistLat.dual.obj X = FinBddDistLat.of (↑X.toBddDistLat.toDistLat)ᵒᵈ
-- FinBddDistLat.dual_map
@[simps]
def dual : FinBddDistLat ⥤ FinBddDistLat 
Arguments: {X Y : FinBddDistLat} (a : BoundedLatticeHom ↑X.toBddDistLat.toBddLat.toLat ↑Y.toBddDistLat.toBddLat.toLat)
Goal: FinBddDistLat.dual.map a = BoundedLatticeHom.dual a
-- FinBddDistLat.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : FinBddDistLat ≌ FinBddDistLat 
Goal: FinBddDistLat.dualEquiv.inverse = FinBddDistLat.dual
-- FinBddDistLat.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : FinBddDistLat ≌ FinBddDistLat 
Goal: FinBddDistLat.dualEquiv.functor = FinBddDistLat.dual
-- finBddDistLat_dual_comp_forget_to_bddDistLat
theorem finBddDistLat_dual_comp_forget_to_bddDistLat :
    FinBddDistLat.dual ⋙ forget₂ FinBddDistLat BddDistLat =
      forget₂ FinBddDistLat BddDistLat ⋙ BddDistLat.dual 
Goal: FinBddDistLat.dual ⋙ CategoryTheory.forget₂ FinBddDistLat BddDistLat =
  CategoryTheory.forget₂ FinBddDistLat BddDistLat ⋙ BddDistLat.dual
-- Set.nil_mem_subchain
@[simp] -- porting note: new `simp`
theorem nil_mem_subchain : [] ∈ s.subchain 
Arguments: {α : Type u_1} [LT α] (s : Set α)
Goal: [] ∈ s.subchain
-- Set.cons_mem_subchain_iff
theorem cons_mem_subchain_iff :
    (a::l) ∈ s.subchain ↔ a ∈ s ∧ l ∈ s.subchain ∧ ∀ b ∈ l.head?, a < b 
Arguments: {α : Type u_1} [LT α] {s : Set α} {l : List α} {a : α}
Goal: a :: l ∈ s.subchain ↔ a ∈ s ∧ l ∈ s.subchain ∧ ∀ b ∈ l.head?, a < b
-- Set.singleton_mem_subchain_iff
@[simp]
theorem singleton_mem_subchain_iff : [a] ∈ s.subchain ↔ a ∈ s 
Arguments: {α : Type u_1} [LT α] {s : Set α} {a : α}
Goal: [a] ∈ s.subchain ↔ a ∈ s
-- Set.chainHeight_eq_iSup_subtype
theorem chainHeight_eq_iSup_subtype : s.chainHeight = ⨆ l : s.subchain, ↑l.1.length 
Arguments: {α : Type u_1} [LT α] (s : Set α)
Goal: s.chainHeight = ⨆ l, ↑(↑l).length
-- Set.exists_chain_of_le_chainHeight
theorem exists_chain_of_le_chainHeight {n : ℕ} (hn : ↑n ≤ s.chainHeight) :
    ∃ l ∈ s.subchain, length l = n 
Arguments: {α : Type u_1} [LT α] (s : Set α) {n : ℕ} (hn : ↑n ≤ s.chainHeight)
Goal: ∃ l ∈ s.subchain, l.length = n
-- Set.le_chainHeight_TFAE
theorem le_chainHeight_TFAE (n : ℕ) :
    TFAE [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, length l = n, ∃ l ∈ s.subchain, n ≤ length l] 
Arguments: {α : Type u_1} [LT α] (s : Set α) (n : ℕ)
Goal: [↑n ≤ s.chainHeight, ∃ l ∈ s.subchain, l.length = n, ∃ l ∈ s.subchain, n ≤ l.length].TFAE
-- Set.le_chainHeight_iff
theorem le_chainHeight_iff {n : ℕ} : ↑n ≤ s.chainHeight ↔ ∃ l ∈ s.subchain, length l = n 
Arguments: {α : Type u_1} [LT α] {s : Set α} {n : ℕ}
Goal: ↑n ≤ s.chainHeight ↔ ∃ l ∈ s.subchain, l.length = n
-- Set.length_le_chainHeight_of_mem_subchain
theorem length_le_chainHeight_of_mem_subchain (hl : l ∈ s.subchain) : ↑l.length ≤ s.chainHeight 
Arguments: {α : Type u_1} [LT α] {s : Set α} {l : List α} (hl : l ∈ s.subchain)
Goal: ↑l.length ≤ s.chainHeight
-- Set.chainHeight_eq_top_iff
theorem chainHeight_eq_top_iff : s.chainHeight = ⊤ ↔ ∀ n, ∃ l ∈ s.subchain, length l = n 
Arguments: {α : Type u_1} [LT α] {s : Set α}
Goal: s.chainHeight = ⊤ ↔ ∀ (n : ℕ), ∃ l ∈ s.subchain, l.length = n
-- Set.one_le_chainHeight_iff
@[simp]
theorem one_le_chainHeight_iff : 1 ≤ s.chainHeight ↔ s.Nonempty 
Arguments: {α : Type u_1} [LT α] {s : Set α}
Goal: 1 ≤ s.chainHeight ↔ s.Nonempty
-- Set.chainHeight_eq_zero_iff
@[simp]
theorem chainHeight_eq_zero_iff : s.chainHeight = 0 ↔ s = ∅ 
Arguments: {α : Type u_1} [LT α] {s : Set α}
Goal: s.chainHeight = 0 ↔ s = ∅
-- Set.chainHeight_empty
@[simp]
theorem chainHeight_empty : (∅ : Set α).chainHeight = 0 
Arguments: {α : Type u_1} [LT α]
Goal: ∅.chainHeight = 0
-- Set.chainHeight_of_isEmpty
@[simp]
theorem chainHeight_of_isEmpty [IsEmpty α] : s.chainHeight = 0 
Arguments: {α : Type u_1} [LT α] {s : Set α} [IsEmpty α]
Goal: s.chainHeight = 0
-- Set.le_chainHeight_add_nat_iff
theorem le_chainHeight_add_nat_iff {n m : ℕ} :
    ↑n ≤ s.chainHeight + m ↔ ∃ l ∈ s.subchain, n ≤ length l + m 
Arguments: {α : Type u_1} [LT α] {s : Set α} {n m : ℕ}
Goal: ↑n ≤ s.chainHeight + ↑m ↔ ∃ l ∈ s.subchain, n ≤ l.length + m
-- Set.chainHeight_add_le_chainHeight_add
theorem chainHeight_add_le_chainHeight_add (s : Set α) (t : Set β) (n m : ℕ) :
    s.chainHeight + n ≤ t.chainHeight + m ↔
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, length l + n ≤ length l' + m 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] (s : Set α) (t : Set β) (n m : ℕ)
Goal: s.chainHeight + ↑n ≤ t.chainHeight + ↑m ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length + n ≤ l'.length + m
-- Set.chainHeight_le_chainHeight_TFAE
theorem chainHeight_le_chainHeight_TFAE (s : Set α) (t : Set β) :
    TFAE [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, length l = length l',
      ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, length l ≤ length l'] 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] (s : Set α) (t : Set β)
Goal: [s.chainHeight ≤ t.chainHeight, ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length,
    ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length].TFAE
-- Set.chainHeight_le_chainHeight_iff
theorem chainHeight_le_chainHeight_iff {t : Set β} :
    s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, length l = length l' 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {s : Set α} {t : Set β}
Goal: s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length = l'.length
-- Set.chainHeight_le_chainHeight_iff_le
theorem chainHeight_le_chainHeight_iff_le {t : Set β} :
    s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, length l ≤ length l' 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] {s : Set α} {t : Set β}
Goal: s.chainHeight ≤ t.chainHeight ↔ ∀ l ∈ s.subchain, ∃ l' ∈ t.subchain, l.length ≤ l'.length
-- Set.chainHeight_mono
theorem chainHeight_mono (h : s ⊆ t) : s.chainHeight ≤ t.chainHeight 
Arguments: {α : Type u_1} [LT α] {s t : Set α} (h : s ⊆ t)
Goal: s.chainHeight ≤ t.chainHeight
-- Set.chainHeight_image
theorem chainHeight_image (f : α → β) (hf : ∀ {x y}, x < y ↔ f x < f y) (s : Set α) :
    (f '' s).chainHeight = s.chainHeight 
Arguments: {α : Type u_1} {β : Type u_2} [LT α] [LT β] (f : α → β) (hf : ∀ {x y : α}, x < y ↔ f x < f y) (s : Set α)
Goal: (f '' s).chainHeight = s.chainHeight
-- Set.chainHeight_dual
@[simp]
theorem chainHeight_dual : (ofDual ⁻¹' s).chainHeight = s.chainHeight 
Arguments: {α : Type u_1} [LT α] (s : Set α)
Goal: (⇑OrderDual.ofDual ⁻¹' s).chainHeight = s.chainHeight
-- Set.chainHeight_eq_iSup_Ici
theorem chainHeight_eq_iSup_Ici : s.chainHeight = ⨆ i ∈ s, (s ∩ Set.Ici i).chainHeight 
Arguments: {α : Type u_1} (s : Set α) [Preorder α]
Goal: s.chainHeight = ⨆ i ∈ s, (s ∩ Set.Ici i).chainHeight
-- Set.chainHeight_eq_iSup_Iic
theorem chainHeight_eq_iSup_Iic : s.chainHeight = ⨆ i ∈ s, (s ∩ Set.Iic i).chainHeight 
Arguments: {α : Type u_1} (s : Set α) [Preorder α]
Goal: s.chainHeight = ⨆ i ∈ s, (s ∩ Set.Iic i).chainHeight
-- Set.chainHeight_insert_of_forall_gt
theorem chainHeight_insert_of_forall_gt (a : α) (hx : ∀ b ∈ s, a < b) :
    (insert a s).chainHeight = s.chainHeight + 1 
Arguments: {α : Type u_1} {s : Set α} [Preorder α] (a : α) (hx : ∀ b ∈ s, a < b)
Goal: (insert a s).chainHeight = s.chainHeight + 1
-- Set.chainHeight_insert_of_forall_lt
theorem chainHeight_insert_of_forall_lt (a : α) (ha : ∀ b ∈ s, b < a) :
    (insert a s).chainHeight = s.chainHeight + 1 
Arguments: {α : Type u_1} {s : Set α} [Preorder α] (a : α) (ha : ∀ b ∈ s, b < a)
Goal: (insert a s).chainHeight = s.chainHeight + 1
-- Set.chainHeight_union_le
theorem chainHeight_union_le : (s ∪ t).chainHeight ≤ s.chainHeight + t.chainHeight 
Arguments: {α : Type u_1} {s t : Set α} [Preorder α]
Goal: (s ∪ t).chainHeight ≤ s.chainHeight + t.chainHeight
-- Set.chainHeight_union_eq
theorem chainHeight_union_eq (s t : Set α) (H : ∀ a ∈ s, ∀ b ∈ t, a < b) :
    (s ∪ t).chainHeight = s.chainHeight + t.chainHeight 
Arguments: {α : Type u_1} [Preorder α] (s t : Set α) (H : ∀ a ∈ s, ∀ b ∈ t, a < b)
Goal: (s ∪ t).chainHeight = s.chainHeight + t.chainHeight
-- Set.wellFoundedGT_of_chainHeight_ne_top
theorem wellFoundedGT_of_chainHeight_ne_top (s : Set α) (hs : s.chainHeight ≠ ⊤) :
    WellFoundedGT s 
Arguments: {α : Type u_1} [Preorder α] (s : Set α) (hs : s.chainHeight ≠ ⊤)
Goal: WellFoundedGT ↑s
-- Set.wellFoundedLT_of_chainHeight_ne_top
theorem wellFoundedLT_of_chainHeight_ne_top (s : Set α) (hs : s.chainHeight ≠ ⊤) :
    WellFoundedLT s 
Arguments: {α : Type u_1} [Preorder α] (s : Set α) (hs : s.chainHeight ≠ ⊤)
Goal: WellFoundedLT ↑s
-- FinBoolAlg.coe_of
@[simp]
theorem coe_of (α : Type*) [BooleanAlgebra α] [Fintype α] : ↥(of α) = α 
Arguments: (α : Type u_1) [BooleanAlgebra α] [Fintype α]
Goal: ↑(FinBoolAlg.of α).toBoolAlg = α
-- FinBoolAlg.hasForgetToFinPartOrd_forget₂_map
@[simps]
instance hasForgetToFinPartOrd : HasForget₂ FinBoolAlg FinPartOrd 
Arguments: {X Y : FinBoolAlg} (f : X ⟶ Y)
Goal: CategoryTheory.HasForget₂.forget₂.map f =
  let_fun this :=
    ↑(let_fun this := f;
      this);
  this
-- FinBoolAlg.hasForgetToFinPartOrd_forget₂_obj
@[simps]
instance hasForgetToFinPartOrd : HasForget₂ FinBoolAlg FinPartOrd 
Arguments: (X : FinBoolAlg)
Goal: CategoryTheory.HasForget₂.forget₂.obj X = FinPartOrd.of ↑X.toBoolAlg
-- FinBoolAlg.Iso.mk_hom_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : FinBoolAlg.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : FinBoolAlg} (e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg) (a : ↑α.toBoolAlg)
Goal: (FinBoolAlg.Iso.mk e).hom.toSupHom a = e a
-- FinBoolAlg.Iso.mk_inv_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : FinBoolAlg.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : FinBoolAlg} (e : ↑α.toBoolAlg ≃o ↑β.toBoolAlg) (a : ↑β.toBoolAlg)
Goal: (FinBoolAlg.Iso.mk e).inv.toSupHom a = e.symm a
-- FinBoolAlg.dual_map
@[simps]
def dual : FinBoolAlg ⥤ FinBoolAlg 
Arguments: {X Y : FinBoolAlg} (a : BoundedLatticeHom ↑X.toBoolAlg.toBddDistLat.toBddLat.toLat ↑Y.toBoolAlg.toBddDistLat.toBddLat.toLat)
Goal: FinBoolAlg.dual.map a = BoundedLatticeHom.dual a
-- FinBoolAlg.dual_obj
@[simps]
def dual : FinBoolAlg ⥤ FinBoolAlg 
Arguments: (X : FinBoolAlg)
Goal: FinBoolAlg.dual.obj X = FinBoolAlg.of (↑X.toBoolAlg)ᵒᵈ
-- FinBoolAlg.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : FinBoolAlg ≌ FinBoolAlg 
Goal: FinBoolAlg.dualEquiv.functor = FinBoolAlg.dual
-- FinBoolAlg.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : FinBoolAlg ≌ FinBoolAlg 
Goal: FinBoolAlg.dualEquiv.inverse = FinBoolAlg.dual
-- finBoolAlg_dual_comp_forget_to_finBddDistLat
theorem finBoolAlg_dual_comp_forget_to_finBddDistLat :
    FinBoolAlg.dual ⋙ forget₂ FinBoolAlg FinBddDistLat =
      forget₂ FinBoolAlg FinBddDistLat ⋙ FinBddDistLat.dual 
Goal: FinBoolAlg.dual ⋙ CategoryTheory.forget₂ FinBoolAlg FinBddDistLat =
  CategoryTheory.forget₂ FinBoolAlg FinBddDistLat ⋙ FinBddDistLat.dual
-- fintypeToFinBoolAlgOp_obj
@[simps]
def fintypeToFinBoolAlgOp : FintypeCat ⥤ FinBoolAlgᵒᵖ 
Arguments: (X : FintypeCat)
Goal: fintypeToFinBoolAlgOp.obj X = Opposite.op (FinBoolAlg.of (Set ↑X))
-- fintypeToFinBoolAlgOp_map
@[simps]
def fintypeToFinBoolAlgOp : FintypeCat ⥤ FinBoolAlgᵒᵖ 
Arguments: {X Y : FintypeCat} (f : X ⟶ Y)
Goal: fintypeToFinBoolAlgOp.map f =
  Quiver.Hom.op
    (let __src := { toFun := ⇑(CompleteLatticeHom.setPreimage f), map_sup' := ⋯, map_inf' := ⋯ };
    { toFun := ⇑(CompleteLatticeHom.setPreimage f), map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
-- Preord.coe_of
@[simp]
theorem coe_of (α : Type*) [Preorder α] : ↥(of α) = α 
Arguments: (α : Type u_1) [Preorder α]
Goal: ↑(Preord.of α) = α
-- Preord.Iso.mk_inv
@[simps]
def Iso.mk {α β : Preord.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : Preord} (e : ↑α ≃o ↑β)
Goal: (Preord.Iso.mk e).inv = ↑e.symm
-- Preord.Iso.mk_hom
@[simps]
def Iso.mk {α β : Preord.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : Preord} (e : ↑α ≃o ↑β)
Goal: (Preord.Iso.mk e).hom = ↑e
-- Preord.dual_map
@[simps]
def dual : Preord ⥤ Preord 
Goal: ∀ {X Y : Preord} (a : ↑X →o ↑Y), Preord.dual.map a = OrderHom.dual a
-- Preord.dual_obj
@[simps]
def dual : Preord ⥤ Preord 
Arguments: (X : Preord)
Goal: Preord.dual.obj X = Preord.of (↑X)ᵒᵈ
-- Preord.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : Preord ≌ Preord 
Goal: Preord.dualEquiv.inverse = Preord.dual
-- Preord.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : Preord ≌ Preord 
Goal: Preord.dualEquiv.functor = Preord.dual
-- preordToCat_map
@[simps]
def preordToCat : Preord.{u} ⥤ Cat 
Goal: ∀ {X Y : Preord} (f : X ⟶ Y), preordToCat.map f = ⋯.functor
-- preordToCat_obj
@[simps]
def preordToCat : Preord.{u} ⥤ Cat 
Arguments: (X : Preord)
Goal: preordToCat.obj X = CategoryTheory.Cat.of ↑X
-- BoolAlg.coe_of
@[simp]
theorem coe_of (α : Type*) [BooleanAlgebra α] : ↥(of α) = α 
Arguments: (α : Type u_1) [BooleanAlgebra α]
Goal: ↑(BoolAlg.of α) = α
-- BoolAlg.coe_toBddDistLat
@[simp]
theorem coe_toBddDistLat (X : BoolAlg) : ↥X.toBddDistLat = ↥X 
Arguments: (X : BoolAlg)
Goal: ↑X.toBddDistLat.toDistLat = ↑X
-- BoolAlg.hasForgetToHeytAlg_forget₂_map_toFun
@[simps]
instance hasForgetToHeytAlg : HasForget₂ BoolAlg HeytAlg 
Arguments: {X Y : BoolAlg} (f : BoundedLatticeHom ↑X ↑Y) (a : ↑X)
Goal: (CategoryTheory.HasForget₂.forget₂.map f) a = f a
-- BoolAlg.hasForgetToHeytAlg_forget₂_obj_α
@[simps]
instance hasForgetToHeytAlg : HasForget₂ BoolAlg HeytAlg 
Arguments: (X : BoolAlg)
Goal: ↑(CategoryTheory.HasForget₂.forget₂.obj X) = ↑X
-- BoolAlg.hasForgetToHeytAlg_forget₂_obj_str
@[simps]
instance hasForgetToHeytAlg : HasForget₂ BoolAlg HeytAlg 
Arguments: (X : BoolAlg)
Goal: (CategoryTheory.HasForget₂.forget₂.obj X).str = inferInstance
-- BoolAlg.Iso.mk_inv_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : BoolAlg.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : BoolAlg} (e : ↑α ≃o ↑β) (a : ↑β)
Goal: (BoolAlg.Iso.mk e).inv.toSupHom a = e.symm a
-- BoolAlg.Iso.mk_hom_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : BoolAlg.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : BoolAlg} (e : ↑α ≃o ↑β) (a : ↑α)
Goal: (BoolAlg.Iso.mk e).hom.toSupHom a = e a
-- BoolAlg.dual_obj
@[simps]
def dual : BoolAlg ⥤ BoolAlg 
Arguments: (X : BoolAlg)
Goal: BoolAlg.dual.obj X = BoolAlg.of (↑X)ᵒᵈ
-- BoolAlg.dual_map
@[simps]
def dual : BoolAlg ⥤ BoolAlg 
Arguments: {X Y : BoolAlg} (a : BoundedLatticeHom ↑X.toBddDistLat.toBddLat.toLat ↑Y.toBddDistLat.toBddLat.toLat)
Goal: BoolAlg.dual.map a = BoundedLatticeHom.dual a
-- BoolAlg.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : BoolAlg ≌ BoolAlg 
Goal: BoolAlg.dualEquiv.functor = BoolAlg.dual
-- BoolAlg.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : BoolAlg ≌ BoolAlg 
Goal: BoolAlg.dualEquiv.inverse = BoolAlg.dual
-- boolAlg_dual_comp_forget_to_bddDistLat
theorem boolAlg_dual_comp_forget_to_bddDistLat :
    BoolAlg.dual ⋙ forget₂ BoolAlg BddDistLat =
    forget₂ BoolAlg BddDistLat ⋙ BddDistLat.dual 
Goal: BoolAlg.dual ⋙ CategoryTheory.forget₂ BoolAlg BddDistLat = CategoryTheory.forget₂ BoolAlg BddDistLat ⋙ BddDistLat.dual
-- typeToBoolAlgOp_obj
@[simps]
def typeToBoolAlgOp : Type u ⥤ BoolAlgᵒᵖ 
Arguments: (X : Type u)
Goal: typeToBoolAlgOp.obj X = Opposite.op (BoolAlg.of (Set X))
-- typeToBoolAlgOp_map
@[simps]
def typeToBoolAlgOp : Type u ⥤ BoolAlgᵒᵖ 
Arguments: {X Y : Type u} (f : X ⟶ Y)
Goal: typeToBoolAlgOp.map f =
  Quiver.Hom.op
    (let __src := { toFun := ⇑(CompleteLatticeHom.setPreimage f), map_sup' := ⋯, map_inf' := ⋯ };
    { toFun := ⇑(CompleteLatticeHom.setPreimage f), map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ })
-- PartOrd.coe_of
@[simp]
theorem coe_of (α : Type*) [PartialOrder α] : ↥(of α) = α 
Arguments: (α : Type u_1) [PartialOrder α]
Goal: ↑(PartOrd.of α) = α
-- PartOrd.Iso.mk_inv
@[simps]
def Iso.mk {α β : PartOrd.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : PartOrd} (e : ↑α ≃o ↑β)
Goal: (PartOrd.Iso.mk e).inv = ↑e.symm
-- PartOrd.Iso.mk_hom
@[simps]
def Iso.mk {α β : PartOrd.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : PartOrd} (e : ↑α ≃o ↑β)
Goal: (PartOrd.Iso.mk e).hom = ↑e
-- PartOrd.dual_obj
@[simps]
def dual : PartOrd ⥤ PartOrd 
Arguments: (X : PartOrd)
Goal: PartOrd.dual.obj X = PartOrd.of (↑X)ᵒᵈ
-- PartOrd.dual_map
@[simps]
def dual : PartOrd ⥤ PartOrd 
Goal: ∀ {X Y : PartOrd} (a : ↑X →o ↑Y), PartOrd.dual.map a = OrderHom.dual a
-- PartOrd.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : PartOrd ≌ PartOrd 
Goal: PartOrd.dualEquiv.functor = PartOrd.dual
-- PartOrd.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : PartOrd ≌ PartOrd 
Goal: PartOrd.dualEquiv.inverse = PartOrd.dual
-- partOrd_dual_comp_forget_to_preord
theorem partOrd_dual_comp_forget_to_preord :
    PartOrd.dual ⋙ forget₂ PartOrd Preord =
      forget₂ PartOrd Preord ⋙ Preord.dual 
Goal: PartOrd.dual ⋙ CategoryTheory.forget₂ PartOrd Preord = CategoryTheory.forget₂ PartOrd Preord ⋙ Preord.dual
-- preordToPartOrdCompToDualIsoToDualCompPreordToPartOrd_inv_app_coe
@[simps! inv_app_coe, simps! (config := .lemmasOnly) hom_app_coe]
def preordToPartOrdCompToDualIsoToDualCompPreordToPartOrd :
    preordToPartOrd.{u} ⋙ PartOrd.dual ≅ Preord.dual ⋙ preordToPartOrd 
Arguments: (X : Preord) (a : ↑((Preord.dual ⋙ preordToPartOrd).obj X))
Goal: (preordToPartOrdCompToDualIsoToDualCompPreordToPartOrd.inv.app X) a = (OrderIso.dualAntisymmetrization ↑X).symm a
-- preordToPartOrdCompToDualIsoToDualCompPreordToPartOrd_hom_app_coe
@[simps! inv_app_coe, simps! (config := .lemmasOnly) hom_app_coe]
def preordToPartOrdCompToDualIsoToDualCompPreordToPartOrd :
    preordToPartOrd.{u} ⋙ PartOrd.dual ≅ Preord.dual ⋙ preordToPartOrd 
Arguments: (X : Preord) (a : ↑((preordToPartOrd ⋙ PartOrd.dual).obj X))
Goal: (preordToPartOrdCompToDualIsoToDualCompPreordToPartOrd.hom.app X) a = (OrderIso.dualAntisymmetrization ↑X) a
-- BddDistLat.coe_of
@[simp]
theorem coe_of (α : Type*) [DistribLattice α] [BoundedOrder α] : ↥(of α) = α 
Arguments: (α : Type u_1) [DistribLattice α] [BoundedOrder α]
Goal: ↑(BddDistLat.of α).toDistLat = α
-- BddDistLat.coe_toBddLat
@[simp]
theorem coe_toBddLat (X : BddDistLat) : ↥X.toBddLat = ↥X 
Arguments: (X : BddDistLat)
Goal: ↑X.toBddLat.toLat = ↑X.toDistLat
-- BddDistLat.forget_bddLat_lat_eq_forget_distLat_lat
theorem forget_bddLat_lat_eq_forget_distLat_lat :
    forget₂ BddDistLat BddLat ⋙ forget₂ BddLat Lat =
      forget₂ BddDistLat DistLat ⋙ forget₂ DistLat Lat 
Goal: CategoryTheory.forget₂ BddDistLat BddLat ⋙ CategoryTheory.forget₂ BddLat Lat =
  CategoryTheory.forget₂ BddDistLat DistLat ⋙ CategoryTheory.forget₂ DistLat Lat
-- BddDistLat.Iso.mk_inv_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : BddDistLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat) (a : ↑β.toDistLat)
Goal: (BddDistLat.Iso.mk e).inv.toSupHom a = e.symm a
-- BddDistLat.Iso.mk_hom_toLatticeHom_toSupHom_toFun
@[simps]
def Iso.mk {α β : BddDistLat.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat) (a : ↑α.toDistLat)
Goal: (BddDistLat.Iso.mk e).hom.toSupHom a = e a
-- BddDistLat.dual_map
@[simps]
def dual : BddDistLat ⥤ BddDistLat 
Arguments: {X Y : BddDistLat} (a : BoundedLatticeHom ↑X.toBddLat.toLat ↑Y.toBddLat.toLat)
Goal: BddDistLat.dual.map a = BoundedLatticeHom.dual a
-- BddDistLat.dual_obj
@[simps]
def dual : BddDistLat ⥤ BddDistLat 
Arguments: (X : BddDistLat)
Goal: BddDistLat.dual.obj X = BddDistLat.of (↑X.toDistLat)ᵒᵈ
-- BddDistLat.dualEquiv_inverse
@[simps functor inverse]
def dualEquiv : BddDistLat ≌ BddDistLat 
Goal: BddDistLat.dualEquiv.inverse = BddDistLat.dual
-- BddDistLat.dualEquiv_functor
@[simps functor inverse]
def dualEquiv : BddDistLat ≌ BddDistLat 
Goal: BddDistLat.dualEquiv.functor = BddDistLat.dual
-- bddDistLat_dual_comp_forget_to_distLat
theorem bddDistLat_dual_comp_forget_to_distLat :
    BddDistLat.dual ⋙ forget₂ BddDistLat DistLat =
      forget₂ BddDistLat DistLat ⋙ DistLat.dual 
Goal: BddDistLat.dual ⋙ CategoryTheory.forget₂ BddDistLat DistLat = CategoryTheory.forget₂ BddDistLat DistLat ⋙ DistLat.dual
-- FinPartOrd.coe_of
@[simp]
theorem coe_of (α : Type*) [PartialOrder α] [Fintype α] : ↥(of α) = α 
Arguments: (α : Type u_1) [PartialOrder α] [Fintype α]
Goal: ↑(FinPartOrd.of α).toPartOrd = α
-- FinPartOrd.Iso.mk_inv
@[simps]
def Iso.mk {α β : FinPartOrd.{u}} (e : α ≃o β) : α ≅ β 
Arguments: {α β : FinPartOrd} (e : ↑α.toPartOrd ≃o ↑β.toPartOrd)
Goal: (FinPartOrd.Iso.mk e).inv = ↑e.symm