ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/AlgebraicTopology/SingularSet.lean

full_name: TopCat.toSSet
code: /-- The functor associating the *singular simplicial set* to a topological space.

Let `X` be a topological space.
Then the singular simplicial set of `X`
has as `n`-simplices the continuous maps `[n].toTop → X`.
Here, `[n].toTop` is the standard topological `n`-simplex,
defined as `{ f : Fin (n+1) → ℝ≥0 // ∑ i, f i = 1 }` with its subspace topology. -/
noncomputable def TopCat.toSSet : TopCat ⥤ SSet 
goal: TopCat ⥤ SSet

full_name: SSet.toTop
code: /-- The *geometric realization functor* is
the left Kan extension of `SimplexCategory.toTop` along the Yoneda embedding.

It is left adjoint to `TopCat.toSSet`, as witnessed by `sSetTopAdj`. -/
noncomputable def SSet.toTop : SSet ⥤ TopCat 
goal: SSet ⥤ TopCat

full_name: sSetTopAdj
code: /-- Geometric realization is left adjoint to the singular simplicial set construction. -/
noncomputable def sSetTopAdj : SSet.toTop ⊣ TopCat.toSSet 
goal: SSet.toTop ⊣ TopCat.toSSet

full_name: SSet.toTopSimplex
code: /-- The geometric realization of the representable simplicial sets agree
  with the usual topological simplices. -/
noncomputable def SSet.toTopSimplex :
    (yoneda : SimplexCategory ⥤ _) ⋙ SSet.toTop ≅ SimplexCategory.toTop 
goal: CategoryTheory.yoneda ⋙ SSet.toTop ≅ SimplexCategory.toTop
File: Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean

full_name: SSet.instChosenFiniteProducts
code: noncomputable instance : ChosenFiniteProducts SSet.{u} 
goal: CategoryTheory.ChosenFiniteProducts SSet

full_name: SSet.leftUnitor_hom_app_apply
code: @[simp]
lemma leftUnitor_hom_app_apply (K : SSet.{u}) {Δ : SimplexCategoryᵒᵖ} (x : (𝟙_ _ ⊗ K).obj Δ) :
    (λ_ K).hom.app Δ x = x.2 
goal: (λ_ K).hom.app Δ x = x.2

full_name: SSet.leftUnitor_inv_app_apply
code: @[simp]
lemma leftUnitor_inv_app_apply (K : SSet.{u}) {Δ : SimplexCategoryᵒᵖ} (x : K.obj Δ) :
    (λ_ K).inv.app Δ x = ⟨PUnit.unit, x⟩ 
goal: (λ_ K).inv.app Δ x = (PUnit.unit, x)

full_name: SSet.rightUnitor_hom_app_apply
code: @[simp]
lemma rightUnitor_hom_app_apply (K : SSet.{u}) {Δ : SimplexCategoryᵒᵖ} (x : (K ⊗ 𝟙_ _).obj Δ) :
    (ρ_ K).hom.app Δ x = x.1 
goal: (ρ_ K).hom.app Δ x = x.1

full_name: SSet.rightUnitor_inv_app_apply
code: @[simp]
lemma rightUnitor_inv_app_apply (K : SSet.{u}) {Δ : SimplexCategoryᵒᵖ} (x : K.obj Δ) :
    (ρ_ K).inv.app Δ x = ⟨x, PUnit.unit⟩ 
goal: (ρ_ K).inv.app Δ x = (x, PUnit.unit)

full_name: SSet.tensorHom_app_apply
code: @[simp]
lemma tensorHom_app_apply {K K' L L' : SSet.{u}} (f : K ⟶ K') (g : L ⟶ L')
    {Δ : SimplexCategoryᵒᵖ} (x : (K ⊗ L).obj Δ) :
    (f ⊗ g).app Δ x = ⟨f.app Δ x.1, g.app Δ x.2⟩ 
goal: (f ⊗ g).app Δ x = (f.app Δ x.1, g.app Δ x.2)

full_name: SSet.whiskerLeft_app_apply
code: @[simp]
lemma whiskerLeft_app_apply (K : SSet.{u}) {L L' : SSet.{u}} (g : L ⟶ L')
    {Δ : SimplexCategoryᵒᵖ} (x : (K ⊗ L).obj Δ) :
    (K ◁ g).app Δ x = ⟨x.1, g.app Δ x.2⟩ 
goal: (K ◁ g).app Δ x = (x.1, g.app Δ x.2)

full_name: SSet.whiskerRight_app_apply
code: @[simp]
lemma whiskerRight_app_apply {K K' : SSet.{u}} (f : K ⟶ K') (L : SSet.{u})
    {Δ : SimplexCategoryᵒᵖ} (x : (K ⊗ L).obj Δ) :
    (f ▷ L).app Δ x = ⟨f.app Δ x.1, x.2⟩ 
goal: (f ▷ L).app Δ x = (f.app Δ x.1, x.2)

full_name: SSet.associator_hom_app_apply
code: @[simp]
lemma associator_hom_app_apply (K L M : SSet.{u}) {Δ : SimplexCategoryᵒᵖ}
    (x : ((K ⊗ L) ⊗ M).obj Δ) :
    (α_ K L M).hom.app Δ x = ⟨x.1.1, x.1.2, x.2⟩ 
goal: (α_ K L M).hom.app Δ x = (x.1.1, x.1.2, x.2)

full_name: SSet.associator_inv_app_apply
code: @[simp]
lemma associator_inv_app_apply (K L M : SSet.{u}) {Δ : SimplexCategoryᵒᵖ}
    (x : (K ⊗ L ⊗ M).obj Δ) :
    (α_ K L M).inv.app Δ x = ⟨⟨x.1, x.2.1⟩, x.2.2⟩ 
goal: (α_ K L M).inv.app Δ x = ((x.1, x.2.1), x.2.2)

full_name: SSet.unitHomEquiv
code: /-- The bijection `(𝟙_ SSet ⟶ K) ≃ K _[0]`. -/
def unitHomEquiv (K : SSet.{u}) : (𝟙_ _ ⟶ K) ≃ K _[0] 
goal: (𝟙_ SSet ⟶ K) ≃ K _[0]
File: Mathlib/Condensed/Module.lean

full_name: CondensedMod
code: /--
The category of condensed `R`-modules, defined as sheaves of `R`-modules over
`CompHaus` with respect to the coherent Grothendieck topology.
-/
abbrev CondensedMod 
goal: Type (u + 2)

full_name: instAbelianCondensedMod
code: noncomputable instance : Abelian (CondensedMod.{u} R) 
goal: CategoryTheory.Abelian (CondensedMod R)

full_name: Condensed.forget
code: /-- The forgetful functor from condensed `R`-modules to condensed sets. -/
def Condensed.forget : CondensedMod R ⥤ CondensedSet 
goal: CondensedMod R ⥤ CondensedSet

full_name: Condensed.free
code: /--
The left adjoint to the forgetful functor. The *free condensed `R`-module* on a condensed set.
-/
noncomputable
def Condensed.free : CondensedSet ⥤ CondensedMod R 
goal: CondensedSet ⥤ CondensedMod R

full_name: Condensed.freeForgetAdjunction
code: /-- The condensed version of the free-forgetful adjunction. -/
noncomputable
def Condensed.freeForgetAdjunction : free R ⊣ forget R 
goal: Condensed.free R ⊣ Condensed.forget R

full_name: CondensedAb
code: /--
The category of condensed abelian groups is defined as condensed `ℤ`-modules.
-/
abbrev CondensedAb 
goal: Type (u + 2)

full_name: Condensed.abForget
code: /-- The forgetful functor from condensed abelian groups to condensed sets. -/
abbrev Condensed.abForget : CondensedAb ⥤ CondensedSet 
goal: CondensedAb ⥤ CondensedSet

full_name: Condensed.freeAb
code: /-- The free condensed abelian group on a condensed set. -/
noncomputable abbrev Condensed.freeAb : CondensedSet ⥤ CondensedAb 
goal: CondensedSet ⥤ CondensedAb

full_name: Condensed.setAbAdjunction
code: /-- The free-forgetful adjunction for condensed abelian groups. -/
noncomputable abbrev Condensed.setAbAdjunction : freeAb ⊣ abForget 
goal: Condensed.freeAb ⊣ Condensed.abForget

full_name: CondensedMod.hom_naturality_apply
code: @[simp]
lemma hom_naturality_apply {X Y : CondensedMod.{u} R} (f : X ⟶ Y)  {S T : CompHausᵒᵖ} (g : S ⟶ T)
    (x : X.val.obj S) : f.val.app T (X.val.map g x) = Y.val.map g (f.val.app S x) 
goal: (f.val.app T) ((X.val.map g) x) = (Y.val.map g) ((f.val.app S) x)
File: Mathlib/AlgebraicTopology/Quasicategory.lean

full_name: SSet.Quasicategory.hornFilling'
code: /-- A simplicial set `S` is a *quasicategory* if it satisfies the following horn-filling condition:
for every `n : ℕ` and `0 < i < n`,
every map of simplicial sets `σ₀ : Λ[n, i] → S` can be extended to a map `σ : Δ[n] → S`.

[Kerodon, 003A] -/
class Quasicategory (S : SSet) : Prop where
  hornFilling' : ∀ ⦃n : ℕ⦄ ⦃i : Fin (n+3)⦄ (σ₀ : Λ[n+2, i] ⟶ S)
    (_h0 : 0 < i) (_hn : i < Fin.last (n+2)),
      ∃ σ : Δ[n+2] ⟶ S, σ₀ = hornInclusion (n+2) i ≫ σ
goal: ∃ σ, σ₀ = CategoryTheory.CategoryStruct.comp (SSet.hornInclusion (n + 2) i) σ

full_name: SSet.Quasicategory
code: /-- A simplicial set `S` is a *quasicategory* if it satisfies the following horn-filling condition:
for every `n : ℕ` and `0 < i < n`,
every map of simplicial sets `σ₀ : Λ[n, i] → S` can be extended to a map `σ : Δ[n] → S`.

[Kerodon, 003A] -/
class Quasicategory (S : SSet) : Prop where
  hornFilling' : ∀ ⦃n : ℕ⦄ ⦃i : Fin (n+3)⦄ (σ₀ : Λ[n+2, i] ⟶ S)
    (_h0 : 0 < i) (_hn : i < Fin.last (n+2)),
      ∃ σ : Δ[n+2] ⟶ S, σ₀ = hornInclusion (n+2) i ≫ σ
goal: Prop

full_name: SSet.Quasicategory.hornFilling
code: lemma Quasicategory.hornFilling {S : SSet} [Quasicategory S] ⦃n : ℕ⦄ ⦃i : Fin (n+1)⦄
    (h0 : 0 < i) (hn : i < Fin.last n)
    (σ₀ : Λ[n, i] ⟶ S) : ∃ σ : Δ[n] ⟶ S, σ₀ = hornInclusion n i ≫ σ 
goal: ∃ σ, σ₀ = CategoryTheory.CategoryStruct.comp (SSet.hornInclusion n i) σ

full_name: SSet.instQuasicategoryOfKanComplex
code: /-- Every Kan complex is a quasicategory.

[Kerodon, 003C] -/
instance (S : SSet) [KanComplex S] : Quasicategory S 
goal: S.Quasicategory

full_name: SSet.quasicategory_of_filler
code: lemma quasicategory_of_filler (S : SSet)
    (filler : ∀ ⦃n : ℕ⦄ ⦃i : Fin (n+3)⦄ (σ₀ : Λ[n+2, i] ⟶ S)
      (_h0 : 0 < i) (_hn : i < Fin.last (n+2)),
      ∃ σ : S _[n+2], ∀ (j) (h : j ≠ i), S.δ j σ = σ₀.app _ (horn.face i j h)) :
    Quasicategory S 
goal: S.Quasicategory
File: Mathlib/AlgebraicTopology/TopologicalSimplex.lean

full_name: SimplexCategory.instFintypeObjForget
code: instance (x : SimplexCategory) : Fintype (ConcreteCategory.forget.obj x) 
goal: Fintype (CategoryTheory.ConcreteCategory.forget.obj x)

full_name: SimplexCategory.toTopObj
code: /-- The topological simplex associated to `x : SimplexCategory`.
  This is the object part of the functor `SimplexCategory.toTop`. -/
def toTopObj (x : SimplexCategory) 
goal: Set ((CategoryTheory.forget SimplexCategory).obj x → NNReal)

full_name: SimplexCategory.instCoeFunElemForallObjForgetNNRealToTopObj
code: instance (x : SimplexCategory) : CoeFun x.toTopObj fun _ => x → ℝ≥0 
goal: CoeFun ↑x.toTopObj fun x_1 => (CategoryTheory.forget SimplexCategory).obj x → NNReal

full_name: SimplexCategory.toTopObj.ext
code: @[ext]
theorem toTopObj.ext {x : SimplexCategory} (f g : x.toTopObj) : (f : x → ℝ≥0) = g → f = g 
goal: ↑f = ↑g → f = g

full_name: SimplexCategory.toTopMap
code: /-- A morphism in `SimplexCategory` induces a map on the associated topological spaces. -/
def toTopMap {x y : SimplexCategory} (f : x ⟶ y) (g : x.toTopObj) : y.toTopObj 
goal: ↑y.toTopObj

full_name: SimplexCategory.coe_toTopMap
code: @[simp]
theorem coe_toTopMap {x y : SimplexCategory} (f : x ⟶ y) (g : x.toTopObj) (i : y) :
    toTopMap f g i = ∑ j ∈ Finset.univ.filter (f · = i), g j 
goal: ↑(SimplexCategory.toTopMap f g) i = ∑ j ∈ Finset.filter (fun x_1 => f x_1 = i) Finset.univ, ↑g j

full_name: SimplexCategory.continuous_toTopMap
code: @[continuity]
theorem continuous_toTopMap {x y : SimplexCategory} (f : x ⟶ y) : Continuous (toTopMap f) 
goal: Continuous (SimplexCategory.toTopMap f)

full_name: SimplexCategory.toTop_map
code: /-- The functor associating the topological `n`-simplex to `[n] : SimplexCategory`. -/
@[simps obj map]
def toTop : SimplexCategory ⥤ TopCat 
goal: ∀ {X Y : SimplexCategory} (f : X ⟶ Y),
  SimplexCategory.toTop.map f = { toFun := SimplexCategory.toTopMap f, continuous_toFun := ⋯ }

full_name: SimplexCategory.toTop
code: /-- The functor associating the topological `n`-simplex to `[n] : SimplexCategory`. -/
@[simps obj map]
def toTop : SimplexCategory ⥤ TopCat 
goal: CategoryTheory.Functor SimplexCategory TopCat

full_name: SimplexCategory.toTop_obj
code: /-- The functor associating the topological `n`-simplex to `[n] : SimplexCategory`. -/
@[simps obj map]
def toTop : SimplexCategory ⥤ TopCat 
goal: SimplexCategory.toTop.obj x = TopCat.of ↑x.toTopObj
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/FundamentalGroup.lean

full_name: FundamentalGroup
code: /-- The fundamental group is the automorphism group (vertex group) of the basepoint
in the fundamental groupoid. -/
def FundamentalGroup (X : Type u) [TopologicalSpace X] (x : X) 
goal: Type u

full_name: instGroupFundamentalGroup
code: instance (X : Type u) [TopologicalSpace X] (x : X) : Group (FundamentalGroup X x) 
goal: Group (FundamentalGroup X x)

full_name: instInhabitedFundamentalGroup
code: instance (X : Type u) [TopologicalSpace X] (x : X) : Inhabited (FundamentalGroup X x) 
goal: Inhabited (FundamentalGroup X x)

full_name: FundamentalGroup.fundamentalGroupMulEquivOfPath
code: /-- Get an isomorphism between the fundamental groups at two points given a path -/
def fundamentalGroupMulEquivOfPath (p : Path x₀ x₁) :
    FundamentalGroup X x₀ ≃* FundamentalGroup X x₁ 
goal: FundamentalGroup X x₀ ≃* FundamentalGroup X x₁

full_name: FundamentalGroup.fundamentalGroupMulEquivOfPathConnected
code: /-- The fundamental group of a path connected space is independent of the choice of basepoint. -/
def fundamentalGroupMulEquivOfPathConnected [PathConnectedSpace X] :
    FundamentalGroup X x₀ ≃* FundamentalGroup X x₁ 
goal: FundamentalGroup X x₀ ≃* FundamentalGroup X x₁

full_name: FundamentalGroup.toArrow
code: /-- An element of the fundamental group as an arrow in the fundamental groupoid. -/
abbrev toArrow {X : TopCat} {x : X} (p : FundamentalGroup X x) :
    FundamentalGroupoid.mk x ⟶ FundamentalGroupoid.mk x 
goal: { as := x } ⟶ { as := x }

full_name: FundamentalGroup.toPath
code: /-- An element of the fundamental group as a quotient of homotopic paths. -/
abbrev toPath {X : TopCat} {x : X} (p : FundamentalGroup X x) : Path.Homotopic.Quotient x x 
goal: Path.Homotopic.Quotient x x

full_name: FundamentalGroup.fromArrow
code: /-- An element of the fundamental group, constructed from an arrow in the fundamental groupoid. -/
abbrev fromArrow {X : TopCat} {x : X}
    (p : FundamentalGroupoid.mk x ⟶ FundamentalGroupoid.mk x) :
    FundamentalGroup X x 
goal: FundamentalGroup (↑X) x

full_name: FundamentalGroup.fromPath
code: /-- An element of the fundamental group, constructed from a quotient of homotopic paths. -/
abbrev fromPath {X : TopCat} {x : X} (p : Path.Homotopic.Quotient x x) : FundamentalGroup X x 
goal: FundamentalGroup (↑X) x
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/SimplyConnected.lean

full_name: simply_connected_def
code: /-- A simply connected space is one whose fundamental groupoid is equivalent to `Discrete Unit` -/
@[mk_iff simply_connected_def]
class SimplyConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  equiv_unit : Nonempty (FundamentalGroupoid X ≌ Discrete Unit)
goal: SimplyConnectedSpace X ↔ Nonempty (FundamentalGroupoid X ≌ CategoryTheory.Discrete Unit)

full_name: SimplyConnectedSpace.equiv_unit
code: /-- A simply connected space is one whose fundamental groupoid is equivalent to `Discrete Unit` -/
@[mk_iff simply_connected_def]
class SimplyConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  equiv_unit : Nonempty (FundamentalGroupoid X ≌ Discrete Unit)
goal: Nonempty (FundamentalGroupoid X ≌ CategoryTheory.Discrete Unit)

full_name: SimplyConnectedSpace
code: /-- A simply connected space is one whose fundamental groupoid is equivalent to `Discrete Unit` -/
@[mk_iff simply_connected_def]
class SimplyConnectedSpace (X : Type*) [TopologicalSpace X] : Prop where
  equiv_unit : Nonempty (FundamentalGroupoid X ≌ Discrete Unit)
goal: Prop

full_name: simply_connected_iff_unique_homotopic
code: theorem simply_connected_iff_unique_homotopic (X : Type*) [TopologicalSpace X] :
    SimplyConnectedSpace X ↔
      Nonempty X ∧ ∀ x y : X, Nonempty (Unique (Path.Homotopic.Quotient x y)) 
goal: SimplyConnectedSpace X ↔ Nonempty X ∧ ∀ (x y : X), Nonempty (Unique (Path.Homotopic.Quotient x y))

full_name: SimplyConnectedSpace.instSubsingletonQuotient
code: instance (x y : X) : Subsingleton (Path.Homotopic.Quotient x y) 
goal: Subsingleton (Path.Homotopic.Quotient x y)

full_name: SimplyConnectedSpace.instPathConnectedSpace
code: instance (priority := 100) : PathConnectedSpace X 
goal: PathConnectedSpace X

full_name: SimplyConnectedSpace.paths_homotopic
code: /-- In a simply connected space, any two paths are homotopic -/
theorem paths_homotopic {x y : X} (p₁ p₂ : Path x y) : Path.Homotopic p₁ p₂ 
goal: p₁.Homotopic p₂

full_name: SimplyConnectedSpace.ofContractible
code: instance (priority := 100) ofContractible (Y : Type u) [TopologicalSpace Y] [ContractibleSpace Y] :
    SimplyConnectedSpace Y 
goal: SimplyConnectedSpace Y

full_name: simply_connected_iff_paths_homotopic
code: /-- A space is simply connected iff it is path connected, and there is at most one path
  up to homotopy between any two points. -/
theorem simply_connected_iff_paths_homotopic {Y : Type*} [TopologicalSpace Y] :
    SimplyConnectedSpace Y ↔
      PathConnectedSpace Y ∧ ∀ x y : Y, Subsingleton (Path.Homotopic.Quotient x y) 
goal: SimplyConnectedSpace Y ↔ PathConnectedSpace Y ∧ ∀ (x y : Y), Subsingleton (Path.Homotopic.Quotient x y)

full_name: simply_connected_iff_paths_homotopic'
code: /-- Another version of `simply_connected_iff_paths_homotopic` -/
theorem simply_connected_iff_paths_homotopic' {Y : Type*} [TopologicalSpace Y] :
    SimplyConnectedSpace Y ↔
      PathConnectedSpace Y ∧ ∀ {x y : Y} (p₁ p₂ : Path x y), Path.Homotopic p₁ p₂ 
goal: SimplyConnectedSpace Y ↔ PathConnectedSpace Y ∧ ∀ {x y : Y} (p₁ p₂ : Path x y), p₁.Homotopic p₂
File: Mathlib/AlgebraicTopology/FundamentalGroupoid/PUnit.lean

full_name: Path.instSubsingletonPUnitUnit
code: instance : Subsingleton (Path PUnit.unit PUnit.unit) 
goal: Subsingleton (Path PUnit.unit PUnit.unit)

full_name: FundamentalGroupoid.instSubsingletonHomPUnit
code: instance {x y : FundamentalGroupoid PUnit} : Subsingleton (x ⟶ y) 
goal: Subsingleton (x ⟶ y)

full_name: FundamentalGroupoid.punitEquivDiscretePUnit
code: /-- Equivalence of groupoids between fundamental groupoid of punit and punit -/
def punitEquivDiscretePUnit : FundamentalGroupoid PUnit.{u + 1} ≌ Discrete PUnit.{v + 1} 
goal: FundamentalGroupoid PUnit.{u + 1} ≌ CategoryTheory.Discrete PUnit.{v + 1}
File: Mathlib/AlgebraicTopology/DoldKan/Notations.lean

full_name: DoldKan._aux_Mathlib_AlgebraicTopology_DoldKan_Notations___unexpand_AlgebraicTopology_AlternatingFaceMapComplex_obj_1
code: @[inherit_doc]
scoped[DoldKan] notation "K[" X "]" => AlgebraicTopology.AlternatingFaceMapComplex.obj X
goal: Lean.PrettyPrinter.Unexpander

full_name: DoldKan.«_aux_Mathlib_AlgebraicTopology_DoldKan_Notations___macroRules_DoldKan_termK[_]_1»
code: @[inherit_doc]
scoped[DoldKan] notation "K[" X "]" => AlgebraicTopology.AlternatingFaceMapComplex.obj X
goal: Lean.Macro

full_name: DoldKan._aux_Mathlib_AlgebraicTopology_DoldKan_Notations___unexpand_AlgebraicTopology_NormalizedMooreComplex_obj_1
code: @[inherit_doc]
scoped[DoldKan] notation "N[" X "]" => AlgebraicTopology.NormalizedMooreComplex.obj X
goal: Lean.PrettyPrinter.Unexpander

full_name: DoldKan.«_aux_Mathlib_AlgebraicTopology_DoldKan_Notations___macroRules_DoldKan_termN[_]_1»
code: @[inherit_doc]
scoped[DoldKan] notation "N[" X "]" => AlgebraicTopology.NormalizedMooreComplex.obj X
goal: Lean.Macro
File: Mathlib/AlgebraicTopology/DoldKan/Equivalence.lean

full_name: CategoryTheory.Abelian.DoldKan.N
code: /-- The functor `N` for the equivalence is `normalizedMooreComplex A` -/
def N : SimplicialObject A ⥤ ChainComplex A ℕ 
goal: CategoryTheory.SimplicialObject A ⥤ ChainComplex A ℕ

full_name: CategoryTheory.Abelian.DoldKan.Γ
code: /-- The functor `Γ` for the equivalence is the same as in the pseudoabelian case. -/
def Γ : ChainComplex A ℕ ⥤ SimplicialObject A 
goal: ChainComplex A ℕ ⥤ CategoryTheory.SimplicialObject A

full_name: CategoryTheory.Abelian.DoldKan.comparisonN_hom_app_f
code: /-- The comparison isomorphism between `normalizedMooreComplex A` and
the functor `Idempotents.DoldKan.N` from the pseudoabelian case -/
@[simps!]
def comparisonN : (N : SimplicialObject A ⥤ _) ≅ Idempotents.DoldKan.N 
goal: (CategoryTheory.Abelian.DoldKan.comparisonN.hom.app X).f i =
  ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).unitIso.hom.app
          (CategoryTheory.Abelian.DoldKan.N.obj X)).f
      i ≫
    ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).inverse.map
          ((AlgebraicTopology.DoldKan.N₁_iso_normalizedMooreComplex_comp_toKaroubi A).inv.app X)).f
      i

full_name: CategoryTheory.Abelian.DoldKan.comparisonN
code: /-- The comparison isomorphism between `normalizedMooreComplex A` and
the functor `Idempotents.DoldKan.N` from the pseudoabelian case -/
@[simps!]
def comparisonN : (N : SimplicialObject A ⥤ _) ≅ Idempotents.DoldKan.N 
goal: CategoryTheory.Abelian.DoldKan.N ≅ CategoryTheory.Idempotents.DoldKan.N

full_name: CategoryTheory.Abelian.DoldKan.comparisonN_inv_app_f
code: /-- The comparison isomorphism between `normalizedMooreComplex A` and
the functor `Idempotents.DoldKan.N` from the pseudoabelian case -/
@[simps!]
def comparisonN : (N : SimplicialObject A ⥤ _) ≅ Idempotents.DoldKan.N 
goal: (CategoryTheory.Abelian.DoldKan.comparisonN.inv.app X).f i =
  ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).inverse.map
          ((AlgebraicTopology.DoldKan.N₁_iso_normalizedMooreComplex_comp_toKaroubi A).hom.app X)).f
      i ≫
    ((CategoryTheory.Idempotents.toKaroubiEquivalence (ChainComplex A ℕ)).unitIso.inv.app
          (CategoryTheory.Abelian.DoldKan.N.obj X)).f
      i

full_name: CategoryTheory.Abelian.DoldKan.equivalence_functor
code: /-- The Dold-Kan equivalence for abelian categories -/
@[simps! functor]
def equivalence : SimplicialObject A ≌ ChainComplex A ℕ 
goal: CategoryTheory.Abelian.DoldKan.equivalence.functor = CategoryTheory.Abelian.DoldKan.N

full_name: CategoryTheory.Abelian.DoldKan.equivalence
code: /-- The Dold-Kan equivalence for abelian categories -/
@[simps! functor]
def equivalence : SimplicialObject A ≌ ChainComplex A ℕ 
goal: CategoryTheory.SimplicialObject A ≌ ChainComplex A ℕ

full_name: CategoryTheory.Abelian.DoldKan.equivalence_inverse
code: theorem equivalence_inverse : (equivalence : SimplicialObject A ≌ _).inverse = Γ 
goal: CategoryTheory.Abelian.DoldKan.equivalence.inverse = CategoryTheory.Abelian.DoldKan.Γ
File: Mathlib/AlgebraicTopology/DoldKan/EquivalenceAdditive.lean

full_name: CategoryTheory.Preadditive.DoldKan.N
code: /-- The functor `Karoubi (SimplicialObject C) ⥤ Karoubi (ChainComplex C ℕ)` of
the Dold-Kan equivalence for additive categories. -/
@[simp]
def N : Karoubi (SimplicialObject C) ⥤ Karoubi (ChainComplex C ℕ) 
goal: CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C) ⥤
  CategoryTheory.Idempotents.Karoubi (ChainComplex C ℕ)

full_name: CategoryTheory.Preadditive.DoldKan.Γ
code: /-- The inverse functor `Karoubi (ChainComplex C ℕ) ⥤ Karoubi (SimplicialObject C)` of
the Dold-Kan equivalence for additive categories. -/
@[simp]
def Γ : Karoubi (ChainComplex C ℕ) ⥤ Karoubi (SimplicialObject C) 
goal: CategoryTheory.Idempotents.Karoubi (ChainComplex C ℕ) ⥤
  CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C)

full_name: CategoryTheory.Preadditive.DoldKan.equivalence_functor
code: /-- The Dold-Kan equivalence `Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ)`
for additive categories. -/
@[simps]
def equivalence : Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ) 
goal: CategoryTheory.Preadditive.DoldKan.equivalence.functor = CategoryTheory.Preadditive.DoldKan.N

full_name: CategoryTheory.Preadditive.DoldKan.equivalence
code: /-- The Dold-Kan equivalence `Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ)`
for additive categories. -/
@[simps]
def equivalence : Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ) 
goal: CategoryTheory.Idempotents.Karoubi (CategoryTheory.SimplicialObject C) ≌
  CategoryTheory.Idempotents.Karoubi (ChainComplex C ℕ)

full_name: CategoryTheory.Preadditive.DoldKan.equivalence_inverse
code: /-- The Dold-Kan equivalence `Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ)`
for additive categories. -/
@[simps]
def equivalence : Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ) 
goal: CategoryTheory.Preadditive.DoldKan.equivalence.inverse = CategoryTheory.Preadditive.DoldKan.Γ

full_name: CategoryTheory.Preadditive.DoldKan.equivalence_unitIso
code: /-- The Dold-Kan equivalence `Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ)`
for additive categories. -/
@[simps]
def equivalence : Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ) 
goal: CategoryTheory.Preadditive.DoldKan.equivalence.unitIso = AlgebraicTopology.DoldKan.Γ₂N₂

full_name: CategoryTheory.Preadditive.DoldKan.equivalence_counitIso
code: /-- The Dold-Kan equivalence `Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ)`
for additive categories. -/
@[simps]
def equivalence : Karoubi (SimplicialObject C) ≌ Karoubi (ChainComplex C ℕ) 
goal: CategoryTheory.Preadditive.DoldKan.equivalence.counitIso = AlgebraicTopology.DoldKan.N₂Γ₂