ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AlgebraicTopology.DoldKan.natTransPInfty_f_app
@[simps!]
noncomputable def natTransPInfty_f (n : ℕ) 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] (n : ℕ) (X : CategoryTheory.SimplicialObject C)
Goal: (AlgebraicTopology.DoldKan.natTransPInfty_f C n).app X = AlgebraicTopology.DoldKan.PInfty.f n
-- AlgebraicTopology.DoldKan.map_PInfty_f
@[simp]
theorem map_PInfty_f {D : Type*} [Category D] [Preadditive D] (G : C ⥤ D) [G.Additive]
    (X : SimplicialObject C) (n : ℕ) :
    (PInfty : K[((whiskering C D).obj G).obj X] ⟶ _).f n =
      G.map ((PInfty : AlternatingFaceMapComplex.obj X ⟶ _).f n) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_4, u_1} C] [CategoryTheory.Preadditive C] {D : Type u_2} [CategoryTheory.Category.{u_3, u_2} D] [CategoryTheory.Preadditive D] (G : C ⥤ D) [G.Additive] (X : CategoryTheory.SimplicialObject C) (n : ℕ)
Goal: AlgebraicTopology.DoldKan.PInfty.f n = G.map (AlgebraicTopology.DoldKan.PInfty.f n)
-- AlgebraicTopology.DoldKan.karoubi_PInfty_f
theorem karoubi_PInfty_f {Y : Karoubi (SimplicialObject C)} (n : ℕ) :
    ((PInfty : K[(karoubiFunctorCategoryEmbedding _ _).obj Y] ⟶ _).f n).f =
      Y.p.app (op [n]) ≫ (PInfty : K[Y.X] ⟶ _).f n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Preadditive C] {Y : CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C)} (n : ℕ)
Goal: (AlgebraicTopology.DoldKan.PInfty.f n).f = Y.p.app (Opposite.op [n]) ≫ AlgebraicTopology.DoldKan.PInfty.f n
-- SimplexCategory.ext
@[ext]
theorem ext (a b : SimplexCategory) : a.len = b.len → a = b 
Arguments: (a b : SimplexCategory)
Goal: a.len = b.len → a = b
-- SimplexCategory.len_mk
@[simp]
theorem len_mk (n : ℕ) : [n].len = n 
Arguments: (n : ℕ)
Goal: (SimplexCategory.mk n).len = n
-- SimplexCategory.mk_len
@[simp]
theorem mk_len (n : SimplexCategory) : ([n.len] : SimplexCategory) = n 
Arguments: (n : SimplexCategory)
Goal: SimplexCategory.mk n.len = n
-- SimplexCategory.Hom.ext'
theorem ext' {a b : SimplexCategory} (f g : SimplexCategory.Hom a b) :
    f.toOrderHom = g.toOrderHom → f = g 
Arguments: {a b : SimplexCategory} (f g : a.Hom b)
Goal: f.toOrderHom = g.toOrderHom → f = g
-- SimplexCategory.Hom.mk_toOrderHom
@[simp]
theorem mk_toOrderHom {a b : SimplexCategory} (f : SimplexCategory.Hom a b) : mk f.toOrderHom = f 
Arguments: {a b : SimplexCategory} (f : a.Hom b)
Goal: SimplexCategory.Hom.mk f.toOrderHom = f
-- SimplexCategory.Hom.toOrderHom_mk
@[simp]
theorem toOrderHom_mk {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1)) :
    (mk f).toOrderHom = f 
Arguments: {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1))
Goal: (SimplexCategory.Hom.mk f).toOrderHom = f
-- SimplexCategory.Hom.mk_toOrderHom_apply
theorem mk_toOrderHom_apply {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1))
    (i : Fin (a.len + 1)) : (mk f).toOrderHom i = f i 
Arguments: {a b : SimplexCategory} (f : Fin (a.len + 1) →o Fin (b.len + 1)) (i : Fin (a.len + 1))
Goal: (SimplexCategory.Hom.mk f).toOrderHom i = f i
-- SimplexCategory.id_toOrderHom
@[simp]
lemma id_toOrderHom (a : SimplexCategory) :
    Hom.toOrderHom (𝟙 a) = OrderHom.id 
Arguments: (a : SimplexCategory)
Goal: SimplexCategory.Hom.toOrderHom (𝟙 a) = OrderHom.id
-- SimplexCategory.comp_toOrderHom
@[simp]
lemma comp_toOrderHom {a b c : SimplexCategory} (f : a ⟶ b) (g : b ⟶ c) :
    (f ≫ g).toOrderHom = g.toOrderHom.comp f.toOrderHom 
Arguments: {a b c : SimplexCategory} (f : a ⟶ b) (g : b ⟶ c)
Goal: SimplexCategory.Hom.toOrderHom (f ≫ g) = (SimplexCategory.Hom.toOrderHom g).comp (SimplexCategory.Hom.toOrderHom f)
-- SimplexCategory.Hom.ext
@[ext]
theorem Hom.ext {a b : SimplexCategory} (f g : a ⟶ b) :
    f.toOrderHom = g.toOrderHom → f = g 
Arguments: {a b : SimplexCategory} (f g : a ⟶ b)
Goal: SimplexCategory.Hom.toOrderHom f = SimplexCategory.Hom.toOrderHom g → f = g
-- SimplexCategory.const_eq_id
@[simp]
lemma const_eq_id : const [0] [0] 0 = 𝟙 _ 
Goal: (SimplexCategory.mk 0).const (SimplexCategory.mk 0) 0 = 𝟙 (SimplexCategory.mk 0)
-- SimplexCategory.const_apply
@[simp]
lemma const_apply (x y : SimplexCategory) (i : Fin (y.len + 1)) (a : Fin (x.len + 1)) :
    (const x y i).toOrderHom a = i 
Arguments: (x y : SimplexCategory) (i : Fin (y.len + 1)) (a : Fin (x.len + 1))
Goal: (SimplexCategory.Hom.toOrderHom (x.const y i)) a = i
-- SimplexCategory.const_comp
@[simp]
theorem const_comp (x : SimplexCategory) {y z : SimplexCategory}
    (f : y ⟶ z) (i : Fin (y.len + 1)) :
    const x y i ≫ f = const x z (f.toOrderHom i) 
Arguments: (x : SimplexCategory) {y z : SimplexCategory} (f : y ⟶ z) (i : Fin (y.len + 1))
Goal: x.const y i ≫ f = x.const z ((SimplexCategory.Hom.toOrderHom f) i)
-- SimplexCategory.hom_zero_zero
theorem hom_zero_zero (f : ([0] : SimplexCategory) ⟶ [0]) : f = 𝟙 _ 
Arguments: (f : SimplexCategory.mk 0 ⟶ SimplexCategory.mk 0)
Goal: f = 𝟙 (SimplexCategory.mk 0)
-- SimplexCategory.δ_comp_δ
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i) 
Arguments: {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j)
Goal: SimplexCategory.δ i ≫ SimplexCategory.δ j.succ = SimplexCategory.δ j ≫ SimplexCategory.δ i.castSucc
-- SimplexCategory.δ_comp_δ'
theorem δ_comp_δ' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : Fin.castSucc i < j) :
    δ i ≫ δ j =
      δ (j.pred fun (hj : j = 0) => by simp [hj, Fin.not_lt_zero] at H) ≫
        δ (Fin.castSucc i) 
Arguments: {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : i.castSucc < j)
Goal: SimplexCategory.δ i ≫ SimplexCategory.δ j = SimplexCategory.δ (j.pred ⋯) ≫ SimplexCategory.δ i.castSucc
-- SimplexCategory.δ_comp_δ''
theorem δ_comp_δ'' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ Fin.castSucc j) :
    δ (i.castLT (Nat.lt_of_le_of_lt (Fin.le_iff_val_le_val.mp H) j.is_lt)) ≫ δ j.succ =
      δ j ≫ δ i 
Arguments: {n : ℕ} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : i ≤ j.castSucc)
Goal: SimplexCategory.δ (i.castLT ⋯) ≫ SimplexCategory.δ j.succ = SimplexCategory.δ j ≫ SimplexCategory.δ i
-- SimplexCategory.δ_comp_δ_self
@[reassoc]
theorem δ_comp_δ_self {n} {i : Fin (n + 2)} : δ i ≫ δ (Fin.castSucc i) = δ i ≫ δ i.succ 
Arguments: {n : ℕ} {i : Fin (n + 2)}
Goal: SimplexCategory.δ i ≫ SimplexCategory.δ i.castSucc = SimplexCategory.δ i ≫ SimplexCategory.δ i.succ
-- SimplexCategory.δ_comp_δ_self'
@[reassoc]
theorem δ_comp_δ_self' {n} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : j = Fin.castSucc i) :
    δ i ≫ δ j = δ i ≫ δ i.succ 
Arguments: {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 3)} (H : j = i.castSucc)
Goal: SimplexCategory.δ i ≫ SimplexCategory.δ j = SimplexCategory.δ i ≫ SimplexCategory.δ i.succ
-- SimplexCategory.δ_comp_σ_of_le
@[reassoc]
theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
    δ (Fin.castSucc i) ≫ σ j.succ = σ j ≫ δ i 
Arguments: {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ j.castSucc)
Goal: SimplexCategory.δ i.castSucc ≫ SimplexCategory.σ j.succ = SimplexCategory.σ j ≫ SimplexCategory.δ i
-- SimplexCategory.δ_comp_σ_self
@[reassoc]
theorem δ_comp_σ_self {n} {i : Fin (n + 1)} :
    δ (Fin.castSucc i) ≫ σ i = 𝟙 ([n] : SimplexCategory) 
Arguments: {n : ℕ} {i : Fin (n + 1)}
Goal: SimplexCategory.δ i.castSucc ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)
-- SimplexCategory.δ_comp_σ_self'
@[reassoc]
theorem δ_comp_σ_self' {n} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = Fin.castSucc i) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) 
Arguments: {n : ℕ} {j : Fin (n + 2)} {i : Fin (n + 1)} (H : j = i.castSucc)
Goal: SimplexCategory.δ j ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)
-- SimplexCategory.δ_comp_σ_succ
@[reassoc]
theorem δ_comp_σ_succ {n} {i : Fin (n + 1)} : δ i.succ ≫ σ i = 𝟙 ([n] : SimplexCategory) 
Arguments: {n : ℕ} {i : Fin (n + 1)}
Goal: SimplexCategory.δ i.succ ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)
-- SimplexCategory.δ_comp_σ_succ'
@[reassoc]
theorem δ_comp_σ_succ' {n} (j : Fin (n + 2)) (i : Fin (n + 1)) (H : j = i.succ) :
    δ j ≫ σ i = 𝟙 ([n] : SimplexCategory) 
Arguments: {n : ℕ} (j : Fin (n + 2)) (i : Fin (n + 1)) (H : j = i.succ)
Goal: SimplexCategory.δ j ≫ SimplexCategory.σ i = 𝟙 (SimplexCategory.mk n)
-- SimplexCategory.δ_comp_σ_of_gt
@[reassoc]
theorem δ_comp_σ_of_gt {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : Fin.castSucc j < i) :
    δ i.succ ≫ σ (Fin.castSucc j) = σ j ≫ δ i 
Arguments: {n : ℕ} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : j.castSucc < i)
Goal: SimplexCategory.δ i.succ ≫ SimplexCategory.σ j.castSucc = SimplexCategory.σ j ≫ SimplexCategory.δ i
-- SimplexCategory.δ_comp_σ_of_gt'
@[reassoc]
theorem δ_comp_σ_of_gt' {n} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i) :
    δ i ≫ σ j = σ (j.castLT ((add_lt_add_iff_right 1).mp (lt_of_lt_of_le H i.is_le))) ≫
      δ (i.pred fun (hi : i = 0) => by simp only [Fin.not_lt_zero, hi] at H) 
Arguments: {n : ℕ} {i : Fin (n + 3)} {j : Fin (n + 2)} (H : j.succ < i)
Goal: SimplexCategory.δ i ≫ SimplexCategory.σ j = SimplexCategory.σ (j.castLT ⋯) ≫ SimplexCategory.δ (i.pred ⋯)
-- SimplexCategory.σ_comp_σ
@[reassoc]
theorem σ_comp_σ {n} {i j : Fin (n + 1)} (H : i ≤ j) :
    σ (Fin.castSucc i) ≫ σ j = σ j.succ ≫ σ i 
Arguments: {n : ℕ} {i j : Fin (n + 1)} (H : i ≤ j)
Goal: SimplexCategory.σ i.castSucc ≫ SimplexCategory.σ j = SimplexCategory.σ j.succ ≫ SimplexCategory.σ i
-- SimplexCategory.factor_δ_spec
lemma factor_δ_spec {m n : ℕ} (f : ([m] : SimplexCategory) ⟶ [n+1]) (j : Fin (n+2))
    (hj : ∀ (k : Fin (m+1)), f.toOrderHom k ≠ j) :
    factor_δ f j ≫ δ j = f 
Arguments: {m n : ℕ} (f : SimplexCategory.mk m ⟶ SimplexCategory.mk (n + 1)) (j : Fin (n + 2)) (hj : ∀ (k : Fin (m + 1)), (SimplexCategory.Hom.toOrderHom f) k ≠ j)
Goal: SimplexCategory.factor_δ f j ≫ SimplexCategory.δ j = f
-- SimplexCategory.skeletalFunctor_obj
@[simps obj map]
def skeletalFunctor : SimplexCategory ⥤ NonemptyFinLinOrd 
Arguments: (a : SimplexCategory)
Goal: SimplexCategory.skeletalFunctor.obj a = NonemptyFinLinOrd.of (Fin (a.len + 1))
-- SimplexCategory.skeletalFunctor_map
@[simps obj map]
def skeletalFunctor : SimplexCategory ⥤ NonemptyFinLinOrd 
Goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y), SimplexCategory.skeletalFunctor.map f = SimplexCategory.Hom.toOrderHom f
-- SimplexCategory.skeletalFunctor.coe_map
theorem skeletalFunctor.coe_map {Δ₁ Δ₂ : SimplexCategory} (f : Δ₁ ⟶ Δ₂) :
    ↑(skeletalFunctor.map f) = f.toOrderHom 
Arguments: {Δ₁ Δ₂ : SimplexCategory} (f : Δ₁ ⟶ Δ₂)
Goal: SimplexCategory.skeletalFunctor.map f = SimplexCategory.Hom.toOrderHom f
-- SimplexCategory.skeletal
theorem skeletal : Skeletal SimplexCategory 
Goal: CategoryTheory.Skeletal SimplexCategory
-- SimplexCategory.isSkeletonOf
lemma isSkeletonOf :
    IsSkeletonOf NonemptyFinLinOrd SimplexCategory skeletalFunctor 
Goal: CategoryTheory.IsSkeletonOf NonemptyFinLinOrd SimplexCategory SimplexCategory.skeletalFunctor
-- SimplexCategory.mono_iff_injective
theorem mono_iff_injective {n m : SimplexCategory} {f : n ⟶ m} :
    Mono f ↔ Function.Injective f.toOrderHom 
Arguments: {n m : SimplexCategory} {f : n ⟶ m}
Goal: CategoryTheory.Mono f ↔ Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f)
-- SimplexCategory.epi_iff_surjective
theorem epi_iff_surjective {n m : SimplexCategory} {f : n ⟶ m} :
    Epi f ↔ Function.Surjective f.toOrderHom 
Arguments: {n m : SimplexCategory} {f : n ⟶ m}
Goal: CategoryTheory.Epi f ↔ Function.Surjective ⇑(SimplexCategory.Hom.toOrderHom f)
-- SimplexCategory.len_le_of_mono
theorem len_le_of_mono {x y : SimplexCategory} {f : x ⟶ y} : Mono f → x.len ≤ y.len 
Arguments: {x y : SimplexCategory} {f : x ⟶ y}
Goal: CategoryTheory.Mono f → x.len ≤ y.len
-- SimplexCategory.le_of_mono
theorem le_of_mono {n m : ℕ} {f : ([n] : SimplexCategory) ⟶ [m]} : CategoryTheory.Mono f → n ≤ m 
Arguments: {n m : ℕ} {f : SimplexCategory.mk n ⟶ SimplexCategory.mk m}
Goal: CategoryTheory.Mono f → n ≤ m
-- SimplexCategory.len_le_of_epi
theorem len_le_of_epi {x y : SimplexCategory} {f : x ⟶ y} : Epi f → y.len ≤ x.len 
Arguments: {x y : SimplexCategory} {f : x ⟶ y}
Goal: CategoryTheory.Epi f → y.len ≤ x.len
-- SimplexCategory.le_of_epi
theorem le_of_epi {n m : ℕ} {f : ([n] : SimplexCategory) ⟶ [m]} : Epi f → m ≤ n 
Arguments: {n m : ℕ} {f : SimplexCategory.mk n ⟶ SimplexCategory.mk m}
Goal: CategoryTheory.Epi f → m ≤ n
-- SimplexCategory.isIso_of_bijective
theorem isIso_of_bijective {x y : SimplexCategory} {f : x ⟶ y}
    (hf : Function.Bijective f.toOrderHom.toFun) : IsIso f 
Arguments: {x y : SimplexCategory} {f : x ⟶ y} (hf : Function.Bijective (SimplexCategory.Hom.toOrderHom f).toFun)
Goal: CategoryTheory.IsIso f
-- SimplexCategory.iso_eq_iso_refl
theorem iso_eq_iso_refl {x : SimplexCategory} (e : x ≅ x) : e = Iso.refl x 
Arguments: {x : SimplexCategory} (e : x ≅ x)
Goal: e = CategoryTheory.Iso.refl x
-- SimplexCategory.eq_id_of_isIso
theorem eq_id_of_isIso {x : SimplexCategory} (f : x ⟶ x) [IsIso f] : f = 𝟙 _ 
Arguments: {x : SimplexCategory} (f : x ⟶ x) [CategoryTheory.IsIso f]
Goal: f = 𝟙 x
-- SimplexCategory.eq_σ_comp_of_not_injective'
theorem eq_σ_comp_of_not_injective' {n : ℕ} {Δ' : SimplexCategory} (θ : mk (n + 1) ⟶ Δ')
    (i : Fin (n + 1)) (hi : θ.toOrderHom (Fin.castSucc i) = θ.toOrderHom i.succ) :
    ∃ θ' : mk n ⟶ Δ', θ = σ i ≫ θ' 
Arguments: {n : ℕ} {Δ' : SimplexCategory} (θ : SimplexCategory.mk (n + 1) ⟶ Δ') (i : Fin (n + 1)) (hi : (SimplexCategory.Hom.toOrderHom θ) i.castSucc = (SimplexCategory.Hom.toOrderHom θ) i.succ)
Goal: ∃ θ', θ = SimplexCategory.σ i ≫ θ'
-- SimplexCategory.eq_σ_comp_of_not_injective
theorem eq_σ_comp_of_not_injective {n : ℕ} {Δ' : SimplexCategory} (θ : mk (n + 1) ⟶ Δ')
    (hθ : ¬Function.Injective θ.toOrderHom) :
    ∃ (i : Fin (n + 1)) (θ' : mk n ⟶ Δ'), θ = σ i ≫ θ' 
Arguments: {n : ℕ} {Δ' : SimplexCategory} (θ : SimplexCategory.mk (n + 1) ⟶ Δ') (hθ : ¬Function.Injective ⇑(SimplexCategory.Hom.toOrderHom θ))
Goal: ∃ i θ', θ = SimplexCategory.σ i ≫ θ'
-- SimplexCategory.eq_comp_δ_of_not_surjective'
theorem eq_comp_δ_of_not_surjective' {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ mk (n + 1))
    (i : Fin (n + 2)) (hi : ∀ x, θ.toOrderHom x ≠ i) : ∃ θ' : Δ ⟶ mk n, θ = θ' ≫ δ i 
Arguments: {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ SimplexCategory.mk (n + 1)) (i : Fin (n + 2)) (hi : ∀ (x : Fin (Δ.len + 1)), (SimplexCategory.Hom.toOrderHom θ) x ≠ i)
Goal: ∃ θ', θ = θ' ≫ SimplexCategory.δ i
-- SimplexCategory.eq_comp_δ_of_not_surjective
theorem eq_comp_δ_of_not_surjective {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ mk (n + 1))
    (hθ : ¬Function.Surjective θ.toOrderHom) :
    ∃ (i : Fin (n + 2)) (θ' : Δ ⟶ mk n), θ = θ' ≫ δ i 
Arguments: {n : ℕ} {Δ : SimplexCategory} (θ : Δ ⟶ SimplexCategory.mk (n + 1)) (hθ : ¬Function.Surjective ⇑(SimplexCategory.Hom.toOrderHom θ))
Goal: ∃ i θ', θ = θ' ≫ SimplexCategory.δ i
-- SimplexCategory.eq_id_of_mono
theorem eq_id_of_mono {x : SimplexCategory} (i : x ⟶ x) [Mono i] : i = 𝟙 _ 
Arguments: {x : SimplexCategory} (i : x ⟶ x) [CategoryTheory.Mono i]
Goal: i = 𝟙 x
-- SimplexCategory.eq_id_of_epi
theorem eq_id_of_epi {x : SimplexCategory} (i : x ⟶ x) [Epi i] : i = 𝟙 _ 
Arguments: {x : SimplexCategory} (i : x ⟶ x) [CategoryTheory.Epi i]
Goal: i = 𝟙 x
-- SimplexCategory.eq_σ_of_epi
theorem eq_σ_of_epi {n : ℕ} (θ : mk (n + 1) ⟶ mk n) [Epi θ] : ∃ i : Fin (n + 1), θ = σ i 
Arguments: {n : ℕ} (θ : SimplexCategory.mk (n + 1) ⟶ SimplexCategory.mk n) [CategoryTheory.Epi θ]
Goal: ∃ i, θ = SimplexCategory.σ i
-- SimplexCategory.eq_δ_of_mono
theorem eq_δ_of_mono {n : ℕ} (θ : mk n ⟶ mk (n + 1)) [Mono θ] : ∃ i : Fin (n + 2), θ = δ i 
Arguments: {n : ℕ} (θ : SimplexCategory.mk n ⟶ SimplexCategory.mk (n + 1)) [CategoryTheory.Mono θ]
Goal: ∃ i, θ = SimplexCategory.δ i
-- SimplexCategory.len_lt_of_mono
theorem len_lt_of_mono {Δ' Δ : SimplexCategory} (i : Δ' ⟶ Δ) [hi : Mono i] (hi' : Δ ≠ Δ') :
    Δ'.len < Δ.len 
Arguments: {Δ' Δ : SimplexCategory} (i : Δ' ⟶ Δ) [hi : CategoryTheory.Mono i] (hi' : Δ ≠ Δ')
Goal: Δ'.len < Δ.len
-- SimplexCategory.image_eq
theorem image_eq {Δ Δ' Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ Δ'} [Epi e] {i : Δ' ⟶ Δ''}
    [Mono i] (fac : e ≫ i = φ) : image φ = Δ' 
Arguments: {Δ Δ' Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ Δ'} [CategoryTheory.Epi e] {i : Δ' ⟶ Δ''} [CategoryTheory.Mono i] (fac : e ≫ i = φ)
Goal: CategoryTheory.Limits.image φ = Δ'
-- SimplexCategory.image_ι_eq
theorem image_ι_eq {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ image φ} [Epi e]
    {i : image φ ⟶ Δ''} [Mono i] (fac : e ≫ i = φ) : image.ι φ = i 
Arguments: {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ CategoryTheory.Limits.image φ} [CategoryTheory.Epi e] {i : CategoryTheory.Limits.image φ ⟶ Δ''} [CategoryTheory.Mono i] (fac : e ≫ i = φ)
Goal: CategoryTheory.Limits.image.ι φ = i
-- SimplexCategory.factorThruImage_eq
theorem factorThruImage_eq {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ image φ} [Epi e]
    {i : image φ ⟶ Δ''} [Mono i] (fac : e ≫ i = φ) : factorThruImage φ = e 
Arguments: {Δ Δ'' : SimplexCategory} {φ : Δ ⟶ Δ''} {e : Δ ⟶ CategoryTheory.Limits.image φ} [CategoryTheory.Epi e] {i : CategoryTheory.Limits.image φ ⟶ Δ''} [CategoryTheory.Mono i] (fac : e ≫ i = φ)
Goal: CategoryTheory.Limits.factorThruImage φ = e
-- SimplexCategory.toCat_obj
@[simps! obj map]
def toCat : SimplexCategory ⥤ Cat.{0} 
Arguments: (X : SimplexCategory)
Goal: SimplexCategory.toCat.obj X =
  CategoryTheory.Cat.of
    ↑((CategoryTheory.forget₂ PartOrd Preord).obj
        ((CategoryTheory.forget₂ Lat PartOrd).obj
          ((CategoryTheory.forget₂ LinOrd Lat).obj
            ((CategoryTheory.forget₂ NonemptyFinLinOrd LinOrd).obj (NonemptyFinLinOrd.of (Fin (X.len + 1)))))))
-- SimplexCategory.toCat_map
@[simps! obj map]
def toCat : SimplexCategory ⥤ Cat.{0} 
Goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y), SimplexCategory.toCat.map f = ⋯.functor
-- Cardinal.mk_subtype_le_of_countable_eventually_mem_aux
lemma mk_subtype_le_of_countable_eventually_mem_aux {α ι : Type u} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l]
    {t : Set α} (ht : ∀ x ∈ t, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #t ≤ a 
Arguments: {α ι : Type u} {a : Cardinal.{u}} [Countable ι] {f : ι → Set α} {l : Filter ι} [l.NeBot] {t : Set α} (ht : ∀ x ∈ t, ∀ᶠ (i : ι) in l, x ∈ f i) (h'f : ∀ (i : ι), #↑(f i) ≤ a)
Goal: #↑t ≤ a
-- Cardinal.mk_subtype_le_of_countable_eventually_mem
lemma mk_subtype_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l]
    {t : Set α} (ht : ∀ x ∈ t, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #t ≤ a 
Arguments: {α : Type u} {ι : Type v} {a : Cardinal.{u}} [Countable ι] {f : ι → Set α} {l : Filter ι} [l.NeBot] {t : Set α} (ht : ∀ x ∈ t, ∀ᶠ (i : ι) in l, x ∈ f i) (h'f : ∀ (i : ι), #↑(f i) ≤ a)
Goal: #↑t ≤ a
-- Cardinal.mk_le_of_countable_eventually_mem
lemma mk_le_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) ≤ a) : #α ≤ a 
Arguments: {α : Type u} {ι : Type v} {a : Cardinal.{u}} [Countable ι] {f : ι → Set α} {l : Filter ι} [l.NeBot] (ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i) (h'f : ∀ (i : ι), #↑(f i) ≤ a)
Goal: #α ≤ a
-- Cardinal.mk_of_countable_eventually_mem
lemma mk_of_countable_eventually_mem {α : Type u} {ι : Type v} {a : Cardinal}
    [Countable ι] {f : ι → Set α} {l : Filter ι} [NeBot l] (ht : ∀ x, ∀ᶠ i in l, x ∈ f i)
    (h'f : ∀ i, #(f i) = a) : #α = a 
Arguments: {α : Type u} {ι : Type v} {a : Cardinal.{u}} [Countable ι] {f : ι → Set α} {l : Filter ι} [l.NeBot] (ht : ∀ (x : α), ∀ᶠ (i : ι) in l, x ∈ f i) (h'f : ∀ (i : ι), #↑(f i) = a)
Goal: #α = a
-- Cardinal.partENatOfENat_toENat
@[simp]
theorem partENatOfENat_toENat (c : Cardinal) : (toENat c : PartENat) = toPartENat c 
Arguments: (c : Cardinal.{u_1})
Goal: ↑(Cardinal.toENat c) = Cardinal.toPartENat c
-- Cardinal.toPartENat_natCast
@[simp]
theorem toPartENat_natCast (n : ℕ) : toPartENat n = n 
Arguments: (n : ℕ)
Goal: Cardinal.toPartENat ↑n = ↑n
-- Cardinal.toPartENat_apply_of_lt_aleph0
theorem toPartENat_apply_of_lt_aleph0 {c : Cardinal} (h : c < ℵ₀) : toPartENat c = toNat c 
Arguments: {c : Cardinal.{u_1}} (h : c < Cardinal.aleph0)
Goal: Cardinal.toPartENat c = ↑(Cardinal.toNat c)
-- Cardinal.toPartENat_eq_top
theorem toPartENat_eq_top {c : Cardinal} :
    toPartENat c = ⊤ ↔ ℵ₀ ≤ c 
Arguments: {c : Cardinal.{u_1}}
Goal: Cardinal.toPartENat c = ⊤ ↔ Cardinal.aleph0 ≤ c
-- Cardinal.toPartENat_apply_of_aleph0_le
theorem toPartENat_apply_of_aleph0_le {c : Cardinal} (h : ℵ₀ ≤ c) : toPartENat c = ⊤ 
Arguments: {c : Cardinal.{u_1}} (h : Cardinal.aleph0 ≤ c)
Goal: Cardinal.toPartENat c = ⊤
-- Cardinal.mk_toPartENat_of_infinite
@[simp]
theorem mk_toPartENat_of_infinite [h : Infinite α] : toPartENat #α = ⊤ 
Arguments: {α : Type u} [h : Infinite α]
Goal: Cardinal.toPartENat (Cardinal.mk α) = ⊤
-- Cardinal.aleph0_toPartENat
@[simp]
theorem aleph0_toPartENat : toPartENat ℵ₀ = ⊤ 
Goal: Cardinal.toPartENat Cardinal.aleph0 = ⊤
-- Cardinal.toPartENat_surjective
theorem toPartENat_surjective : Surjective toPartENat 
Goal: Function.Surjective ⇑Cardinal.toPartENat
-- Cardinal.toPartENat_strictMonoOn
theorem toPartENat_strictMonoOn : StrictMonoOn toPartENat (Set.Iic ℵ₀) 
Goal: StrictMonoOn (⇑Cardinal.toPartENat) (Set.Iic Cardinal.aleph0)
-- Cardinal.toPartENat_le_iff_of_le_aleph0
lemma toPartENat_le_iff_of_le_aleph0 {c c' : Cardinal} (h : c ≤ ℵ₀) :
    toPartENat c ≤ toPartENat c' ↔ c ≤ c' 
Arguments: {c c' : Cardinal.{u_1}} (h : c ≤ Cardinal.aleph0)
Goal: Cardinal.toPartENat c ≤ Cardinal.toPartENat c' ↔ c ≤ c'
-- Cardinal.toPartENat_le_iff_of_lt_aleph0
lemma toPartENat_le_iff_of_lt_aleph0 {c c' : Cardinal} (hc' : c' < ℵ₀) :
    toPartENat c ≤ toPartENat c' ↔ c ≤ c' 
Arguments: {c c' : Cardinal.{u_1}} (hc' : c' < Cardinal.aleph0)
Goal: Cardinal.toPartENat c ≤ Cardinal.toPartENat c' ↔ c ≤ c'
-- Cardinal.toPartENat_eq_iff_of_le_aleph0
lemma toPartENat_eq_iff_of_le_aleph0 {c c' : Cardinal} (hc : c ≤ ℵ₀) (hc' : c' ≤ ℵ₀) :
    toPartENat c = toPartENat c' ↔ c = c' 
Arguments: {c c' : Cardinal.{u_1}} (hc : c ≤ Cardinal.aleph0) (hc' : c' ≤ Cardinal.aleph0)
Goal: Cardinal.toPartENat c = Cardinal.toPartENat c' ↔ c = c'
-- Cardinal.toPartENat_mono
theorem toPartENat_mono {c c' : Cardinal} (h : c ≤ c') :
    toPartENat c ≤ toPartENat c' 
Arguments: {c c' : Cardinal.{u_1}} (h : c ≤ c')
Goal: Cardinal.toPartENat c ≤ Cardinal.toPartENat c'
-- Cardinal.toPartENat_lift
theorem toPartENat_lift (c : Cardinal.{v}) : toPartENat (lift.{u, v} c) = toPartENat c 
Arguments: (c : Cardinal.{v})
Goal: Cardinal.toPartENat (Cardinal.lift.{u, v} c) = Cardinal.toPartENat c
-- Cardinal.toPartENat_congr
theorem toPartENat_congr {β : Type v} (e : α ≃ β) : toPartENat #α = toPartENat #β 
Arguments: {α : Type u} {β : Type v} (e : α ≃ β)
Goal: Cardinal.toPartENat (Cardinal.mk α) = Cardinal.toPartENat (Cardinal.mk β)
-- Cardinal.mk_toPartENat_eq_coe_card
theorem mk_toPartENat_eq_coe_card [Fintype α] : toPartENat #α = Fintype.card α 
Arguments: {α : Type u} [Fintype α]
Goal: Cardinal.toPartENat (Cardinal.mk α) = ↑(Fintype.card α)
-- CategoryTheory.SimplicialCategory.homEquiv_id
class SimplicialCategory extends EnrichedCategory SSet.{v} C where
    homEquiv (K L : C) : (K ⟶ L) ≃ (𝟙_ SSet.{v} ⟶ EnrichedCategory.Hom K L)
  homEquiv_id (K : C) : homEquiv K K (𝟙 K) = eId SSet K := by aesop_cat
  homEquiv_comp {K L M : C} (f : K ⟶ L) (g : L ⟶ M) :
    homEquiv K M (f ≫ g) = (λ_ _).inv ≫ (homEquiv K L f ⊗ homEquiv L M g) ≫
      eComp SSet K L M := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.SimplicialCategory C] (K : C)
Goal: (CategoryTheory.SimplicialCategory.homEquiv K K) (𝟙 K) = CategoryTheory.eId SSet K