File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

full_name: SimplicialObject.Splitting.IndexSet
code: /-- The index set which appears in the definition of split simplicial objects. -/
def IndexSet (Δ : SimplexCategoryᵒᵖ) 
goal: Type

full_name: SimplicialObject.Splitting.IndexSet.mk
code: /-- The element in `Splitting.IndexSet Δ` attached to an epimorphism `f : Δ ⟶ Δ'`. -/
@[simps]
def mk {Δ Δ' : SimplexCategory} (f : Δ ⟶ Δ') [Epi f] : IndexSet (op Δ) 
goal: SimplicialObject.Splitting.IndexSet (Opposite.op Δ)

full_name: SimplicialObject.Splitting.IndexSet.mk_fst
code: /-- The element in `Splitting.IndexSet Δ` attached to an epimorphism `f : Δ ⟶ Δ'`. -/
@[simps]
def mk {Δ Δ' : SimplexCategory} (f : Δ ⟶ Δ') [Epi f] : IndexSet (op Δ) 
goal: (SimplicialObject.Splitting.IndexSet.mk f).fst = Opposite.op Δ'

full_name: SimplicialObject.Splitting.IndexSet.mk_snd_coe
code: /-- The element in `Splitting.IndexSet Δ` attached to an epimorphism `f : Δ ⟶ Δ'`. -/
@[simps]
def mk {Δ Δ' : SimplexCategory} (f : Δ ⟶ Δ') [Epi f] : IndexSet (op Δ) 
goal: ↑(SimplicialObject.Splitting.IndexSet.mk f).snd = f

full_name: SimplicialObject.Splitting.IndexSet.e
code: /-- The epimorphism in `SimplexCategory` associated to `A : Splitting.IndexSet Δ` -/
def e 
goal: Opposite.unop Δ ⟶ Opposite.unop A.fst

full_name: SimplicialObject.Splitting.IndexSet.instEpiSimplexCategoryE
code: instance : Epi A.e 
goal: CategoryTheory.Epi A.e

full_name: SimplicialObject.Splitting.IndexSet.ext'
code: theorem ext' : A = ⟨A.1, ⟨A.e, A.2.2⟩⟩ 
goal: A = ⟨A.fst, ⟨A.e, ⋯⟩⟩

full_name: SimplicialObject.Splitting.IndexSet.ext
code: theorem ext (A₁ A₂ : IndexSet Δ) (h₁ : A₁.1 = A₂.1) (h₂ : A₁.e ≫ eqToHom (by rw [h₁]) = A₂.e) :
    A₁ = A₂ 
goal: A₁ = A₂

full_name: SimplicialObject.Splitting.IndexSet.instFintype
code: instance : Fintype (IndexSet Δ) 
goal: Fintype (SimplicialObject.Splitting.IndexSet Δ)

full_name: SimplicialObject.Splitting.IndexSet.id_snd_coe
code: /-- The distinguished element in `Splitting.IndexSet Δ` which corresponds to the
identity of `Δ`. -/
@[simps]
def id : IndexSet Δ 
goal: ↑(SimplicialObject.Splitting.IndexSet.id Δ).snd = 𝟙 (Opposite.unop Δ)

full_name: SimplicialObject.Splitting.IndexSet.id_fst
code: /-- The distinguished element in `Splitting.IndexSet Δ` which corresponds to the
identity of `Δ`. -/
@[simps]
def id : IndexSet Δ 
goal: (SimplicialObject.Splitting.IndexSet.id Δ).fst = Δ

full_name: SimplicialObject.Splitting.IndexSet.id
code: /-- The distinguished element in `Splitting.IndexSet Δ` which corresponds to the
identity of `Δ`. -/
@[simps]
def id : IndexSet Δ 
goal: SimplicialObject.Splitting.IndexSet Δ

full_name: SimplicialObject.Splitting.IndexSet.instInhabited
code: instance : Inhabited (IndexSet Δ) 
goal: Inhabited (SimplicialObject.Splitting.IndexSet Δ)

full_name: SimplicialObject.Splitting.IndexSet.EqId
code: /-- The condition that an element `Splitting.IndexSet Δ` is the distinguished
element `Splitting.IndexSet.Id Δ`. -/
@[simp]
def EqId : Prop 
goal: Prop

full_name: SimplicialObject.Splitting.IndexSet.eqId_iff_eq
code: theorem eqId_iff_eq : A.EqId ↔ A.1 = Δ 
goal: A.EqId ↔ A.fst = Δ

full_name: SimplicialObject.Splitting.IndexSet.eqId_iff_len_eq
code: theorem eqId_iff_len_eq : A.EqId ↔ A.1.unop.len = Δ.unop.len 
goal: A.EqId ↔ (Opposite.unop A.fst).len = (Opposite.unop Δ).len

full_name: SimplicialObject.Splitting.IndexSet.eqId_iff_len_le
code: theorem eqId_iff_len_le : A.EqId ↔ Δ.unop.len ≤ A.1.unop.len 
goal: A.EqId ↔ (Opposite.unop Δ).len ≤ (Opposite.unop A.fst).len

full_name: SimplicialObject.Splitting.IndexSet.eqId_iff_mono
code: theorem eqId_iff_mono : A.EqId ↔ Mono A.e 
goal: A.EqId ↔ CategoryTheory.Mono A.e

full_name: SimplicialObject.Splitting.IndexSet.epiComp_fst
code: /-- Given `A : IndexSet Δ₁`, if `p.unop : unop Δ₂ ⟶ unop Δ₁` is an epi, this
is the obvious element in `A : IndexSet Δ₂` associated to the composition
of epimorphisms `p.unop ≫ A.e`. -/
@[simps]
def epiComp {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂) [Epi p.unop] :
    IndexSet Δ₂ 
goal: (A.epiComp p).fst = A.fst

full_name: SimplicialObject.Splitting.IndexSet.epiComp_snd_coe
code: /-- Given `A : IndexSet Δ₁`, if `p.unop : unop Δ₂ ⟶ unop Δ₁` is an epi, this
is the obvious element in `A : IndexSet Δ₂` associated to the composition
of epimorphisms `p.unop ≫ A.e`. -/
@[simps]
def epiComp {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂) [Epi p.unop] :
    IndexSet Δ₂ 
goal: ↑(A.epiComp p).snd = p.unop ≫ A.e

full_name: SimplicialObject.Splitting.IndexSet.epiComp
code: /-- Given `A : IndexSet Δ₁`, if `p.unop : unop Δ₂ ⟶ unop Δ₁` is an epi, this
is the obvious element in `A : IndexSet Δ₂` associated to the composition
of epimorphisms `p.unop ≫ A.e`. -/
@[simps]
def epiComp {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂) [Epi p.unop] :
    IndexSet Δ₂ 
goal: SimplicialObject.Splitting.IndexSet Δ₂

full_name: SimplicialObject.Splitting.IndexSet.pull
code: /-- When `A : IndexSet Δ` and `θ : Δ → Δ'` is a morphism in `SimplexCategoryᵒᵖ`,
an element in `IndexSet Δ'` can be defined by using the epi-mono factorisation
of `θ.unop ≫ A.e`. -/
def pull : IndexSet Δ' 
goal: SimplicialObject.Splitting.IndexSet Δ'

full_name: SimplicialObject.Splitting.IndexSet.fac_pull
code: @[reassoc]
theorem fac_pull : (A.pull θ).e ≫ image.ι (θ.unop ≫ A.e) = θ.unop ≫ A.e 
goal: (A.pull θ).e ≫ CategoryTheory.Limits.image.ι (θ.unop ≫ A.e) = θ.unop ≫ A.e

full_name: SimplicialObject.Splitting.summand
code: /-- Given a sequences of objects `N : ℕ → C` in a category `C`, this is
a family of objects indexed by the elements `A : Splitting.IndexSet Δ`.
The `Δ`-simplices of a split simplicial objects shall identify to the
coproduct of objects in such a family. -/
@[simp, nolint unusedArguments]
def summand (A : IndexSet Δ) : C 
goal: C

full_name: SimplicialObject.Splitting.cofan'
code: /-- The cofan for `summand N Δ` induced by morphisms `N n ⟶ X_ [n]` for all `n : ℕ`. -/
def cofan' (Δ : SimplexCategoryᵒᵖ) : Cofan (summand N Δ) 
goal: CategoryTheory.Limits.Cofan (SimplicialObject.Splitting.summand N Δ)

full_name: SimplicialObject.Splitting
code: /-- A splitting of a simplicial object `X` consists of the datum of a sequence
of objects `N`, a sequence of morphisms `ι : N n ⟶ X _[n]` such that
for all `Δ : SimplexCategoryᵒᵖ`, the canonical map `Splitting.map X ι Δ`
is an isomorphism. -/
structure Splitting (X : SimplicialObject C) where
  /-- The "nondegenerate simplices" `N n` for all `n : ℕ`. -/
  N : ℕ → C
  /-- The "inclusion" `N n ⟶ X _[n]` for all `n : ℕ`. -/
  ι : ∀ n, N n ⟶ X _[n]
  /-- For each `Δ`, `X.obj Δ` identifies to the coproduct of the objects `N A.1.unop.len`
  for all `A : IndexSet Δ`.  -/
  isColimit' : ∀ Δ : SimplexCategoryᵒᵖ, IsColimit (Splitting.cofan' N X ι Δ)
goal: Type (max u_1 u_2)

full_name: SimplicialObject.Splitting.N
code: /-- A splitting of a simplicial object `X` consists of the datum of a sequence
of objects `N`, a sequence of morphisms `ι : N n ⟶ X _[n]` such that
for all `Δ : SimplexCategoryᵒᵖ`, the canonical map `Splitting.map X ι Δ`
is an isomorphism. -/
structure Splitting (X : SimplicialObject C) where
  /-- The "nondegenerate simplices" `N n` for all `n : ℕ`. -/
  N : ℕ → C
  /-- The "inclusion" `N n ⟶ X _[n]` for all `n : ℕ`. -/
  ι : ∀ n, N n ⟶ X _[n]
  /-- For each `Δ`, `X.obj Δ` identifies to the coproduct of the objects `N A.1.unop.len`
  for all `A : IndexSet Δ`.  -/
  isColimit' : ∀ Δ : SimplexCategoryᵒᵖ, IsColimit (Splitting.cofan' N X ι Δ)
goal: ℕ → C

full_name: SimplicialObject.Splitting.ι
code: /-- A splitting of a simplicial object `X` consists of the datum of a sequence
of objects `N`, a sequence of morphisms `ι : N n ⟶ X _[n]` such that
for all `Δ : SimplexCategoryᵒᵖ`, the canonical map `Splitting.map X ι Δ`
is an isomorphism. -/
structure Splitting (X : SimplicialObject C) where
  /-- The "nondegenerate simplices" `N n` for all `n : ℕ`. -/
  N : ℕ → C
  /-- The "inclusion" `N n ⟶ X _[n]` for all `n : ℕ`. -/
  ι : ∀ n, N n ⟶ X _[n]
  /-- For each `Δ`, `X.obj Δ` identifies to the coproduct of the objects `N A.1.unop.len`
  for all `A : IndexSet Δ`.  -/
  isColimit' : ∀ Δ : SimplexCategoryᵒᵖ, IsColimit (Splitting.cofan' N X ι Δ)
goal: self.N n ⟶ X _[n]

full_name: SimplicialObject.Splitting.isColimit'
code: /-- A splitting of a simplicial object `X` consists of the datum of a sequence
of objects `N`, a sequence of morphisms `ι : N n ⟶ X _[n]` such that
for all `Δ : SimplexCategoryᵒᵖ`, the canonical map `Splitting.map X ι Δ`
is an isomorphism. -/
structure Splitting (X : SimplicialObject C) where
  /-- The "nondegenerate simplices" `N n` for all `n : ℕ`. -/
  N : ℕ → C
  /-- The "inclusion" `N n ⟶ X _[n]` for all `n : ℕ`. -/
  ι : ∀ n, N n ⟶ X _[n]
  /-- For each `Δ`, `X.obj Δ` identifies to the coproduct of the objects `N A.1.unop.len`
  for all `A : IndexSet Δ`.  -/
  isColimit' : ∀ Δ : SimplexCategoryᵒᵖ, IsColimit (Splitting.cofan' N X ι Δ)
goal: CategoryTheory.Limits.IsColimit (SimplicialObject.Splitting.cofan' self.N X self.ι Δ)

full_name: SimplicialObject.Splitting.cofan
code: /-- The cofan for `summand s.N Δ` induced by a splitting of a simplicial object.  -/
def cofan (Δ : SimplexCategoryᵒᵖ) : Cofan (summand s.N Δ) 
goal: CategoryTheory.Limits.Cofan (SimplicialObject.Splitting.summand s.N Δ)

full_name: SimplicialObject.Splitting.isColimit
code: /-- The cofan `s.cofan Δ` is colimit. -/
def isColimit (Δ : SimplexCategoryᵒᵖ) : IsColimit (s.cofan Δ) 
goal: CategoryTheory.Limits.IsColimit (s.cofan Δ)

full_name: SimplicialObject.Splitting.cofan_inj_eq
code: @[reassoc]
theorem cofan_inj_eq {Δ : SimplexCategoryᵒᵖ} (A : IndexSet Δ) :
    (s.cofan Δ).inj  A = s.ι A.1.unop.len ≫ X.map A.e.op 
goal: (s.cofan Δ).inj A = s.ι (Opposite.unop A.fst).len ≫ X.map A.e.op

full_name: SimplicialObject.Splitting.cofan_inj_id
code: theorem cofan_inj_id (n : ℕ) : (s.cofan _).inj (IndexSet.id (op [n])) = s.ι n 
goal: (s.cofan (Opposite.op [n])).inj (SimplicialObject.Splitting.IndexSet.id (Opposite.op [n])) = s.ι n

full_name: SimplicialObject.Splitting.φ
code: /-- As it is stated in `Splitting.hom_ext`, a morphism `f : X ⟶ Y` from a split
simplicial object to any simplicial object is determined by its restrictions
`s.φ f n : s.N n ⟶ Y _[n]` to the distinguished summands in each degree `n`. -/
@[simp]
def φ (f : X ⟶ Y) (n : ℕ) : s.N n ⟶ Y _[n] 
goal: s.N n ⟶ Y _[n]

full_name: SimplicialObject.Splitting.cofan_inj_comp_app
code: @[reassoc (attr := simp)]
theorem cofan_inj_comp_app (f : X ⟶ Y) {Δ : SimplexCategoryᵒᵖ} (A : IndexSet Δ) :
    (s.cofan Δ).inj A ≫ f.app Δ = s.φ f A.1.unop.len ≫ Y.map A.e.op 
goal: (s.cofan Δ).inj A ≫ f.app Δ = s.φ f (Opposite.unop A.fst).len ≫ Y.map A.e.op

full_name: SimplicialObject.Splitting.hom_ext'
code: theorem hom_ext' {Z : C} {Δ : SimplexCategoryᵒᵖ} (f g : X.obj Δ ⟶ Z)
    (h : ∀ A : IndexSet Δ, (s.cofan Δ).inj A ≫ f = (s.cofan Δ).inj A ≫ g) : f = g 
goal: f = g

full_name: SimplicialObject.Splitting.hom_ext
code: theorem hom_ext (f g : X ⟶ Y) (h : ∀ n : ℕ, s.φ f n = s.φ g n) : f = g 
goal: f = g

full_name: SimplicialObject.Splitting.desc
code: /-- The map `X.obj Δ ⟶ Z` obtained by providing a family of morphisms on all the
terms of decomposition given by a splitting `s : Splitting X`  -/
def desc {Z : C} (Δ : SimplexCategoryᵒᵖ) (F : ∀ A : IndexSet Δ, s.N A.1.unop.len ⟶ Z) :
    X.obj Δ ⟶ Z 
goal: X.obj Δ ⟶ Z

full_name: SimplicialObject.Splitting.ι_desc
code: @[reassoc (attr := simp)]
theorem ι_desc {Z : C} (Δ : SimplexCategoryᵒᵖ) (F : ∀ A : IndexSet Δ, s.N A.1.unop.len ⟶ Z)
    (A : IndexSet Δ) : (s.cofan Δ).inj A ≫ s.desc Δ F = F A 
goal: (s.cofan Δ).inj A ≫ s.desc Δ F = F A

full_name: SimplicialObject.Splitting.ofIso_N
code: /-- A simplicial object that is isomorphic to a split simplicial object is split. -/
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
goal: ∀ (a : ℕ), (s.ofIso e).N a = s.N a

full_name: SimplicialObject.Splitting.ofIso_ι
code: /-- A simplicial object that is isomorphic to a split simplicial object is split. -/
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
goal: (s.ofIso e).ι n = s.ι n ≫ e.hom.app (Opposite.op [n])

full_name: SimplicialObject.Splitting.ofIso_isColimit'
code: /-- A simplicial object that is isomorphic to a split simplicial object is split. -/
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
goal: (s.ofIso e).isColimit' Δ = (s.isColimit Δ).ofIsoColimit (CategoryTheory.Limits.Cofan.ext (e.app Δ) ⋯)

full_name: SimplicialObject.Splitting.ofIso
code: /-- A simplicial object that is isomorphic to a split simplicial object is split. -/
@[simps]
def ofIso (e : X ≅ Y) : Splitting Y 
goal: SimplicialObject.Splitting Y

full_name: SimplicialObject.Splitting.cofan_inj_epi_naturality
code: @[reassoc]
theorem cofan_inj_epi_naturality {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂)
    [Epi p.unop] : (s.cofan Δ₁).inj A ≫ X.map p = (s.cofan Δ₂).inj (A.epiComp p) 
goal: (s.cofan Δ₁).inj A ≫ X.map p = (s.cofan Δ₂).inj (A.epiComp p)

full_name: SimplicialObject.Split.X
code: /-- The category `SimplicialObject.Split C` is the category of simplicial objects
in `C` equipped with a splitting, and morphisms are morphisms of simplicial objects
which are compatible with the splittings. -/
@[ext]
structure Split where
  /-- the underlying simplicial object -/
  X : SimplicialObject C
  /-- a splitting of the simplicial object -/
  s : Splitting X
goal: CategoryTheory.SimplicialObject C

full_name: SimplicialObject.Split
code: /-- The category `SimplicialObject.Split C` is the category of simplicial objects
in `C` equipped with a splitting, and morphisms are morphisms of simplicial objects
which are compatible with the splittings. -/
@[ext]
structure Split where
  /-- the underlying simplicial object -/
  X : SimplicialObject C
  /-- a splitting of the simplicial object -/
  s : Splitting X
goal: Type (max u_1 u_2)

full_name: SimplicialObject.Split.s
code: /-- The category `SimplicialObject.Split C` is the category of simplicial objects
in `C` equipped with a splitting, and morphisms are morphisms of simplicial objects
which are compatible with the splittings. -/
@[ext]
structure Split where
  /-- the underlying simplicial object -/
  X : SimplicialObject C
  /-- a splitting of the simplicial object -/
  s : Splitting X
goal: SimplicialObject.Splitting self.X

full_name: SimplicialObject.Split.mk'_s
code: /-- The object in `SimplicialObject.Split C` attached to a splitting `s : Splitting X`
of a simplicial object `X`. -/
@[simps]
def mk' {X : SimplicialObject C} (s : Splitting X) : Split C 
goal: (SimplicialObject.Split.mk' s).s = s

full_name: SimplicialObject.Split.mk'
code: /-- The object in `SimplicialObject.Split C` attached to a splitting `s : Splitting X`
of a simplicial object `X`. -/
@[simps]
def mk' {X : SimplicialObject C} (s : Splitting X) : Split C 
goal: SimplicialObject.Split C

full_name: SimplicialObject.Split.mk'_X
code: /-- The object in `SimplicialObject.Split C` attached to a splitting `s : Splitting X`
of a simplicial object `X`. -/
@[simps]
def mk' {X : SimplicialObject C} (s : Splitting X) : Split C 
goal: (SimplicialObject.Split.mk' s).X = X

full_name: SimplicialObject.Split.Hom.comm
code: /-- Morphisms in `SimplicialObject.Split C` are morphisms of simplicial objects that
are compatible with the splittings. -/
structure Hom (S₁ S₂ : Split C) where
  /-- the morphism between the underlying simplicial objects -/
  F : S₁.X ⟶ S₂.X
  /-- the morphism between the "nondegenerate" `n`-simplices for all `n : ℕ` -/
  f : ∀ n : ℕ, S₁.s.N n ⟶ S₂.s.N n
  comm : ∀ n : ℕ, S₁.s.ι n ≫ F.app (op [n]) = f n ≫ S₂.s.ι n := by aesop_cat
goal: S₁.s.ι n ≫ self.F.app (Opposite.op [n]) = self.f n ≫ S₂.s.ι n

full_name: SimplicialObject.Split.Hom.F
code: /-- Morphisms in `SimplicialObject.Split C` are morphisms of simplicial objects that
are compatible with the splittings. -/
structure Hom (S₁ S₂ : Split C) where
  /-- the morphism between the underlying simplicial objects -/
  F : S₁.X ⟶ S₂.X
  /-- the morphism between the "nondegenerate" `n`-simplices for all `n : ℕ` -/
  f : ∀ n : ℕ, S₁.s.N n ⟶ S₂.s.N n
  comm : ∀ n : ℕ, S₁.s.ι n ≫ F.app (op [n]) = f n ≫ S₂.s.ι n := by aesop_cat
goal: S₁.X ⟶ S₂.X

full_name: SimplicialObject.Split.Hom
code: /-- Morphisms in `SimplicialObject.Split C` are morphisms of simplicial objects that
are compatible with the splittings. -/
structure Hom (S₁ S₂ : Split C) where
  /-- the morphism between the underlying simplicial objects -/
  F : S₁.X ⟶ S₂.X
  /-- the morphism between the "nondegenerate" `n`-simplices for all `n : ℕ` -/
  f : ∀ n : ℕ, S₁.s.N n ⟶ S₂.s.N n
  comm : ∀ n : ℕ, S₁.s.ι n ≫ F.app (op [n]) = f n ≫ S₂.s.ι n := by aesop_cat
goal: Type u_2

full_name: SimplicialObject.Split.Hom.f
code: /-- Morphisms in `SimplicialObject.Split C` are morphisms of simplicial objects that
are compatible with the splittings. -/
structure Hom (S₁ S₂ : Split C) where
  /-- the morphism between the underlying simplicial objects -/
  F : S₁.X ⟶ S₂.X
  /-- the morphism between the "nondegenerate" `n`-simplices for all `n : ℕ` -/
  f : ∀ n : ℕ, S₁.s.N n ⟶ S₂.s.N n
  comm : ∀ n : ℕ, S₁.s.ι n ≫ F.app (op [n]) = f n ≫ S₂.s.ι n := by aesop_cat
goal: S₁.s.N n ⟶ S₂.s.N n

full_name: SimplicialObject.Split.Hom.ext
code: @[ext]
theorem Hom.ext {S₁ S₂ : Split C} (Φ₁ Φ₂ : Hom S₁ S₂) (h : ∀ n : ℕ, Φ₁.f n = Φ₂.f n) : Φ₁ = Φ₂ 
goal: Φ₁ = Φ₂

full_name: SimplicialObject.instCategorySplit
code: instance : Category (Split C) 
goal: CategoryTheory.Category.{u_2, max u_2 u_1} (SimplicialObject.Split C)

full_name: SimplicialObject.Split.hom_ext
code: @[ext]
theorem hom_ext {S₁ S₂ : Split C} (Φ₁ Φ₂ : S₁ ⟶ S₂) (h : ∀ n : ℕ, Φ₁.f n = Φ₂.f n) : Φ₁ = Φ₂ 
goal: Φ₁ = Φ₂

full_name: SimplicialObject.Split.congr_F
code: theorem congr_F {S₁ S₂ : Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂) : Φ₁.f = Φ₂.f 
goal: Φ₁.f = Φ₂.f

full_name: SimplicialObject.Split.congr_f
code: theorem congr_f {S₁ S₂ : Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂) (n : ℕ) : Φ₁.f n = Φ₂.f n 
goal: Φ₁.f n = Φ₂.f n

full_name: SimplicialObject.Split.id_F
code: @[simp]
theorem id_F (S : Split C) : (𝟙 S : S ⟶ S).F = 𝟙 S.X 
goal: (𝟙 S).F = 𝟙 S.X

full_name: SimplicialObject.Split.id_f
code: @[simp]
theorem id_f (S : Split C) (n : ℕ) : (𝟙 S : S ⟶ S).f n = 𝟙 (S.s.N n) 
goal: (𝟙 S).f n = 𝟙 (S.s.N n)

full_name: SimplicialObject.Split.comp_F
code: @[simp]
theorem comp_F {S₁ S₂ S₃ : Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃) :
    (Φ₁₂ ≫ Φ₂₃).F = Φ₁₂.F ≫ Φ₂₃.F 
goal: (Φ₁₂ ≫ Φ₂₃).F = Φ₁₂.F ≫ Φ₂₃.F

full_name: SimplicialObject.Split.comp_f
code: @[simp]
theorem comp_f {S₁ S₂ S₃ : Split C} (Φ₁₂ : S₁ ⟶ S₂) (Φ₂₃ : S₂ ⟶ S₃) (n : ℕ) :
    (Φ₁₂ ≫ Φ₂₃).f n = Φ₁₂.f n ≫ Φ₂₃.f n 
goal: (Φ₁₂ ≫ Φ₂₃).f n = Φ₁₂.f n ≫ Φ₂₃.f n

full_name: SimplicialObject.Split.cofan_inj_naturality_symm
code: @[reassoc (attr := simp 1100)]
theorem cofan_inj_naturality_symm {S₁ S₂ : Split C} (Φ : S₁ ⟶ S₂) {Δ : SimplexCategoryᵒᵖ}
    (A : Splitting.IndexSet Δ) :
    (S₁.s.cofan Δ).inj A ≫ Φ.F.app Δ = Φ.f A.1.unop.len ≫ (S₂.s.cofan Δ).inj A 
goal: (S₁.s.cofan Δ).inj A ≫ Φ.F.app Δ = Φ.f (Opposite.unop A.fst).len ≫ (S₂.s.cofan Δ).inj A

full_name: SimplicialObject.Split.forget
code: /-- The functor `SimplicialObject.Split C ⥤ SimplicialObject C` which forgets
the splitting. -/
@[simps]
def forget : Split C ⥤ SimplicialObject C 
goal: SimplicialObject.Split C ⥤ CategoryTheory.SimplicialObject C

full_name: SimplicialObject.Split.forget_obj
code: /-- The functor `SimplicialObject.Split C ⥤ SimplicialObject C` which forgets
the splitting. -/
@[simps]
def forget : Split C ⥤ SimplicialObject C 
goal: (SimplicialObject.Split.forget C).obj S = S.X

full_name: SimplicialObject.Split.forget_map
code: /-- The functor `SimplicialObject.Split C ⥤ SimplicialObject C` which forgets
the splitting. -/
@[simps]
def forget : Split C ⥤ SimplicialObject C 
goal: ∀ {X Y : SimplicialObject.Split C} (Φ : X ⟶ Y), (SimplicialObject.Split.forget C).map Φ = Φ.F

full_name: SimplicialObject.Split.evalN_map
code: /-- The functor `SimplicialObject.Split C ⥤ C` which sends a simplicial object equipped
with a splitting to its nondegenerate `n`-simplices. -/
@[simps]
def evalN (n : ℕ) : Split C ⥤ C 
goal: ∀ {X Y : SimplicialObject.Split C} (Φ : X ⟶ Y), (SimplicialObject.Split.evalN C n).map Φ = Φ.f n

full_name: SimplicialObject.Split.evalN_obj
code: /-- The functor `SimplicialObject.Split C ⥤ C` which sends a simplicial object equipped
with a splitting to its nondegenerate `n`-simplices. -/
@[simps]
def evalN (n : ℕ) : Split C ⥤ C 
goal: (SimplicialObject.Split.evalN C n).obj S = S.s.N n

full_name: SimplicialObject.Split.evalN
code: /-- The functor `SimplicialObject.Split C ⥤ C` which sends a simplicial object equipped
with a splitting to its nondegenerate `n`-simplices. -/
@[simps]
def evalN (n : ℕ) : Split C ⥤ C 
goal: SimplicialObject.Split C ⥤ C

full_name: SimplicialObject.Split.natTransCofanInj_app
code: /-- The inclusion of each summand in the coproduct decomposition of simplices
in split simplicial objects is a natural transformation of functors
`SimplicialObject.Split C ⥤ C` -/
@[simps]
def natTransCofanInj {Δ : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) :
    evalN C A.1.unop.len ⟶ forget C ⋙ (evaluation SimplexCategoryᵒᵖ C).obj Δ 
goal: (SimplicialObject.Split.natTransCofanInj C A).app S = (S.s.cofan Δ).inj A

full_name: SimplicialObject.Split.natTransCofanInj
code: /-- The inclusion of each summand in the coproduct decomposition of simplices
in split simplicial objects is a natural transformation of functors
`SimplicialObject.Split C ⥤ C` -/
@[simps]
def natTransCofanInj {Δ : SimplexCategoryᵒᵖ} (A : Splitting.IndexSet Δ) :
    evalN C A.1.unop.len ⟶ forget C ⋙ (evaluation SimplexCategoryᵒᵖ C).obj Δ 
goal: SimplicialObject.Split.evalN C (Opposite.unop A.fst).len ⟶
  SimplicialObject.Split.forget C ⋙ (CategoryTheory.evaluation SimplexCategoryᵒᵖ C).obj Δ