File: Mathlib/AlgebraicTopology/CechNerve.lean

full_name: CategoryTheory.Arrow.cechNerve_obj
code: /-- The Čech nerve associated to an arrow. -/
@[simps]
def cechNerve : SimplicialObject C 
goal: f.cechNerve.obj n = CategoryTheory.Limits.widePullback f.right (fun x => f.left) fun x => f.hom

full_name: CategoryTheory.Arrow.cechNerve_map
code: /-- The Čech nerve associated to an arrow. -/
@[simps]
def cechNerve : SimplicialObject C 
goal: ∀ {X Y : SimplexCategoryᵒᵖ} (g : X ⟶ Y),
  f.cechNerve.map g =
    CategoryTheory.Limits.WidePullback.lift (CategoryTheory.Limits.WidePullback.base fun x => f.hom)
      (fun i => CategoryTheory.Limits.WidePullback.π (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g.unop) i)) ⋯

full_name: CategoryTheory.Arrow.cechNerve
code: /-- The Čech nerve associated to an arrow. -/
@[simps]
def cechNerve : SimplicialObject C 
goal: CategoryTheory.SimplicialObject C

full_name: CategoryTheory.Arrow.mapCechNerve
code: /-- The morphism between Čech nerves associated to a morphism of arrows. -/
@[simps]
def mapCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.cechNerve ⟶ g.cechNerve 
goal: f.cechNerve ⟶ g.cechNerve

full_name: CategoryTheory.Arrow.mapCechNerve_app
code: /-- The morphism between Čech nerves associated to a morphism of arrows. -/
@[simps]
def mapCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.cechNerve ⟶ g.cechNerve 
goal: (CategoryTheory.Arrow.mapCechNerve F).app n =
  CategoryTheory.Limits.WidePullback.lift ((CategoryTheory.Limits.WidePullback.base fun x => f.hom) ≫ F.right)
    (fun i => CategoryTheory.Limits.WidePullback.π (fun x => f.hom) i ≫ F.left) ⋯

full_name: CategoryTheory.Arrow.augmentedCechNerve_right
code: /-- The augmented Čech nerve associated to an arrow. -/
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
goal: f.augmentedCechNerve.right = f.right

full_name: CategoryTheory.Arrow.augmentedCechNerve_left
code: /-- The augmented Čech nerve associated to an arrow. -/
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
goal: f.augmentedCechNerve.left = f.cechNerve

full_name: CategoryTheory.Arrow.augmentedCechNerve
code: /-- The augmented Čech nerve associated to an arrow. -/
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
goal: CategoryTheory.SimplicialObject.Augmented C

full_name: CategoryTheory.Arrow.augmentedCechNerve_hom_app
code: /-- The augmented Čech nerve associated to an arrow. -/
@[simps]
def augmentedCechNerve : SimplicialObject.Augmented C 
goal: f.augmentedCechNerve.hom.app i = CategoryTheory.Limits.WidePullback.base fun x => f.hom

full_name: CategoryTheory.Arrow.mapAugmentedCechNerve_left
code: /-- The morphism between augmented Čech nerve associated to a morphism of arrows. -/
@[simps]
def mapAugmentedCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechNerve ⟶ g.augmentedCechNerve 
goal: (CategoryTheory.Arrow.mapAugmentedCechNerve F).left = CategoryTheory.Arrow.mapCechNerve F

full_name: CategoryTheory.Arrow.mapAugmentedCechNerve_right
code: /-- The morphism between augmented Čech nerve associated to a morphism of arrows. -/
@[simps]
def mapAugmentedCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechNerve ⟶ g.augmentedCechNerve 
goal: (CategoryTheory.Arrow.mapAugmentedCechNerve F).right = F.right

full_name: CategoryTheory.Arrow.mapAugmentedCechNerve
code: /-- The morphism between augmented Čech nerve associated to a morphism of arrows. -/
@[simps]
def mapAugmentedCechNerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePullback f.right (fun _ : Fin (n + 1) => f.left) fun _ => f.hom]
    [∀ n : ℕ, HasWidePullback g.right (fun _ : Fin (n + 1) => g.left) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechNerve ⟶ g.augmentedCechNerve 
goal: f.augmentedCechNerve ⟶ g.augmentedCechNerve

full_name: CategoryTheory.SimplicialObject.cechNerve_obj
code: /-- The Čech nerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechNerve : Arrow C ⥤ SimplicialObject C 
goal: CategoryTheory.SimplicialObject.cechNerve.obj f = f.cechNerve

full_name: CategoryTheory.SimplicialObject.cechNerve_map
code: /-- The Čech nerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechNerve : Arrow C ⥤ SimplicialObject C 
goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y),
  CategoryTheory.SimplicialObject.cechNerve.map F = CategoryTheory.Arrow.mapCechNerve F

full_name: CategoryTheory.SimplicialObject.cechNerve
code: /-- The Čech nerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechNerve : Arrow C ⥤ SimplicialObject C 
goal: CategoryTheory.Arrow C ⥤ CategoryTheory.SimplicialObject C

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve_obj_right
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).right = f.right

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve_obj_left_map
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: ∀ {X Y : SimplexCategoryᵒᵖ} (g : X ⟶ Y),
  (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).left.map g =
    CategoryTheory.Limits.WidePullback.lift (CategoryTheory.Limits.WidePullback.base fun x => f.hom)
      (fun i => CategoryTheory.Limits.WidePullback.π (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g.unop) i)) ⋯

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve_map_left_app
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y) (n : SimplexCategoryᵒᵖ),
  (CategoryTheory.SimplicialObject.augmentedCechNerve.map F).left.app n =
    CategoryTheory.Limits.WidePullback.lift ((CategoryTheory.Limits.WidePullback.base fun x => X.hom) ≫ F.right)
      (fun i => CategoryTheory.Limits.WidePullback.π (fun x => X.hom) i ≫ F.left) ⋯

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve_map_right
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y), (CategoryTheory.SimplicialObject.augmentedCechNerve.map F).right = F.right

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve_obj_left_obj
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).left.obj n =
  CategoryTheory.Limits.widePullback f.right (fun x => f.left) fun x => f.hom

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: CategoryTheory.Arrow C ⥤ CategoryTheory.SimplicialObject.Augmented C

full_name: CategoryTheory.SimplicialObject.augmentedCechNerve_obj_hom_app
code: /-- The augmented Čech nerve construction, as a functor from `Arrow C`. -/
@[simps!]
def augmentedCechNerve : Arrow C ⥤ SimplicialObject.Augmented C 
goal: (CategoryTheory.SimplicialObject.augmentedCechNerve.obj f).hom.app i =
  CategoryTheory.Limits.WidePullback.base fun x => f.hom

full_name: CategoryTheory.SimplicialObject.equivalenceRightToLeft
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F 
goal: CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F

full_name: CategoryTheory.SimplicialObject.equivalenceRightToLeft_left
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F 
goal: (CategoryTheory.SimplicialObject.equivalenceRightToLeft X F G).left =
  G.left.app (Opposite.op (SimplexCategory.mk 0)) ≫ CategoryTheory.Limits.WidePullback.π (fun x => F.hom) 0

full_name: CategoryTheory.SimplicialObject.equivalenceRightToLeft_right
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceRightToLeft (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : X ⟶ F.augmentedCechNerve) : Augmented.toArrow.obj X ⟶ F 
goal: (CategoryTheory.SimplicialObject.equivalenceRightToLeft X F G).right = G.right

full_name: CategoryTheory.SimplicialObject.equivalenceLeftToRight
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceLeftToRight (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : Augmented.toArrow.obj X ⟶ F) : X ⟶ F.augmentedCechNerve 
goal: X ⟶ F.augmentedCechNerve

full_name: CategoryTheory.SimplicialObject.equivalenceLeftToRight_left_app
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceLeftToRight (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : Augmented.toArrow.obj X ⟶ F) : X ⟶ F.augmentedCechNerve 
goal: (CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G).left.app x =
  CategoryTheory.Limits.WidePullback.lift (X.hom.app x ≫ G.right)
    (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯

full_name: CategoryTheory.SimplicialObject.equivalenceLeftToRight_right
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def equivalenceLeftToRight (X : SimplicialObject.Augmented C) (F : Arrow C)
    (G : Augmented.toArrow.obj X ⟶ F) : X ⟶ F.augmentedCechNerve 
goal: (CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G).right = G.right

full_name: CategoryTheory.SimplicialObject.cechNerveEquiv
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
    (Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve) 
goal: (CategoryTheory.SimplicialObject.Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve)

full_name: CategoryTheory.SimplicialObject.cechNerveEquiv_symm_apply
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
    (Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve) 
goal: (CategoryTheory.SimplicialObject.cechNerveEquiv X F).symm G =
  CategoryTheory.SimplicialObject.equivalenceRightToLeft X F G

full_name: CategoryTheory.SimplicialObject.cechNerveEquiv_apply
code: /-- A helper function used in defining the Čech adjunction. -/
@[simps]
def cechNerveEquiv (X : SimplicialObject.Augmented C) (F : Arrow C) :
    (Augmented.toArrow.obj X ⟶ F) ≃ (X ⟶ F.augmentedCechNerve) 
goal: (CategoryTheory.SimplicialObject.cechNerveEquiv X F) G = CategoryTheory.SimplicialObject.equivalenceLeftToRight X F G

full_name: CategoryTheory.SimplicialObject.cechNerveAdjunction
code: /-- The augmented Čech nerve construction is right adjoint to the `toArrow` functor. -/
abbrev cechNerveAdjunction : (Augmented.toArrow : _ ⥤ Arrow C) ⊣ augmentedCechNerve 
goal: CategoryTheory.SimplicialObject.Augmented.toArrow ⊣ CategoryTheory.SimplicialObject.augmentedCechNerve

full_name: CategoryTheory.Arrow.cechConerve
code: /-- The Čech conerve associated to an arrow. -/
@[simps]
def cechConerve : CosimplicialObject C 
goal: CategoryTheory.CosimplicialObject C

full_name: CategoryTheory.Arrow.cechConerve_obj
code: /-- The Čech conerve associated to an arrow. -/
@[simps]
def cechConerve : CosimplicialObject C 
goal: f.cechConerve.obj n = CategoryTheory.Limits.widePushout f.left (fun x => f.right) fun x => f.hom

full_name: CategoryTheory.Arrow.cechConerve_map
code: /-- The Čech conerve associated to an arrow. -/
@[simps]
def cechConerve : CosimplicialObject C 
goal: f.cechConerve.map g =
  CategoryTheory.Limits.WidePushout.desc (CategoryTheory.Limits.WidePushout.head fun x => f.hom)
    (fun i => CategoryTheory.Limits.WidePushout.ι (fun x => f.hom) ((SimplexCategory.Hom.toOrderHom g) i)) ⋯

full_name: CategoryTheory.Arrow.mapCechConerve_app
code: /-- The morphism between Čech conerves associated to a morphism of arrows. -/
@[simps]
def mapCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.cechConerve ⟶ g.cechConerve 
goal: (CategoryTheory.Arrow.mapCechConerve F).app n =
  CategoryTheory.Limits.WidePushout.desc (F.left ≫ CategoryTheory.Limits.WidePushout.head fun x => g.hom)
    (fun i => F.right ≫ CategoryTheory.Limits.WidePushout.ι (fun x => g.hom) i) ⋯

full_name: CategoryTheory.Arrow.mapCechConerve
code: /-- The morphism between Čech conerves associated to a morphism of arrows. -/
@[simps]
def mapCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.cechConerve ⟶ g.cechConerve 
goal: f.cechConerve ⟶ g.cechConerve

full_name: CategoryTheory.Arrow.augmentedCechConerve_right
code: /-- The augmented Čech conerve associated to an arrow. -/
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
goal: f.augmentedCechConerve.right = f.cechConerve

full_name: CategoryTheory.Arrow.augmentedCechConerve
code: /-- The augmented Čech conerve associated to an arrow. -/
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
goal: CategoryTheory.CosimplicialObject.Augmented C

full_name: CategoryTheory.Arrow.augmentedCechConerve_left
code: /-- The augmented Čech conerve associated to an arrow. -/
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
goal: f.augmentedCechConerve.left = f.left

full_name: CategoryTheory.Arrow.augmentedCechConerve_hom_app
code: /-- The augmented Čech conerve associated to an arrow. -/
@[simps]
def augmentedCechConerve : CosimplicialObject.Augmented C 
goal: f.augmentedCechConerve.hom.app i = CategoryTheory.Limits.WidePushout.head fun x => f.hom

full_name: CategoryTheory.Arrow.mapAugmentedCechConerve
code: /-- The morphism between augmented Čech conerves associated to a morphism of arrows. -/
@[simps]
def mapAugmentedCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechConerve ⟶ g.augmentedCechConerve 
goal: f.augmentedCechConerve ⟶ g.augmentedCechConerve

full_name: CategoryTheory.Arrow.mapAugmentedCechConerve_right
code: /-- The morphism between augmented Čech conerves associated to a morphism of arrows. -/
@[simps]
def mapAugmentedCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechConerve ⟶ g.augmentedCechConerve 
goal: (CategoryTheory.Arrow.mapAugmentedCechConerve F).right = CategoryTheory.Arrow.mapCechConerve F

full_name: CategoryTheory.Arrow.mapAugmentedCechConerve_left
code: /-- The morphism between augmented Čech conerves associated to a morphism of arrows. -/
@[simps]
def mapAugmentedCechConerve {f g : Arrow C}
    [∀ n : ℕ, HasWidePushout f.left (fun _ : Fin (n + 1) => f.right) fun _ => f.hom]
    [∀ n : ℕ, HasWidePushout g.left (fun _ : Fin (n + 1) => g.right) fun _ => g.hom] (F : f ⟶ g) :
    f.augmentedCechConerve ⟶ g.augmentedCechConerve 
goal: (CategoryTheory.Arrow.mapAugmentedCechConerve F).left = F.left

full_name: CategoryTheory.CosimplicialObject.cechConerve_map
code: /-- The Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechConerve : Arrow C ⥤ CosimplicialObject C 
goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y),
  CategoryTheory.CosimplicialObject.cechConerve.map F = CategoryTheory.Arrow.mapCechConerve F

full_name: CategoryTheory.CosimplicialObject.cechConerve_obj
code: /-- The Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechConerve : Arrow C ⥤ CosimplicialObject C 
goal: CategoryTheory.CosimplicialObject.cechConerve.obj f = f.cechConerve

full_name: CategoryTheory.CosimplicialObject.cechConerve
code: /-- The Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def cechConerve : Arrow C ⥤ CosimplicialObject C 
goal: CategoryTheory.Arrow C ⥤ CategoryTheory.CosimplicialObject C

full_name: CategoryTheory.CosimplicialObject.augmentedCechConerve
code: /-- The augmented Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def augmentedCechConerve : Arrow C ⥤ CosimplicialObject.Augmented C 
goal: CategoryTheory.Arrow C ⥤ CategoryTheory.CosimplicialObject.Augmented C

full_name: CategoryTheory.CosimplicialObject.augmentedCechConerve_map
code: /-- The augmented Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def augmentedCechConerve : Arrow C ⥤ CosimplicialObject.Augmented C 
goal: ∀ {X Y : CategoryTheory.Arrow C} (F : X ⟶ Y),
  CategoryTheory.CosimplicialObject.augmentedCechConerve.map F = CategoryTheory.Arrow.mapAugmentedCechConerve F

full_name: CategoryTheory.CosimplicialObject.augmentedCechConerve_obj
code: /-- The augmented Čech conerve construction, as a functor from `Arrow C`. -/
@[simps]
def augmentedCechConerve : Arrow C ⥤ CosimplicialObject.Augmented C 
goal: CategoryTheory.CosimplicialObject.augmentedCechConerve.obj f = f.augmentedCechConerve

full_name: CategoryTheory.CosimplicialObject.equivalenceLeftToRight
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps]
def equivalenceLeftToRight (F : Arrow C) (X : CosimplicialObject.Augmented C)
    (G : F.augmentedCechConerve ⟶ X) : F ⟶ Augmented.toArrow.obj X 
goal: F ⟶ CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X

full_name: CategoryTheory.CosimplicialObject.equivalenceLeftToRight_right
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps]
def equivalenceLeftToRight (F : Arrow C) (X : CosimplicialObject.Augmented C)
    (G : F.augmentedCechConerve ⟶ X) : F ⟶ Augmented.toArrow.obj X 
goal: (CategoryTheory.CosimplicialObject.equivalenceLeftToRight F X G).right =
  CategoryTheory.Limits.WidePushout.ι (fun x => F.hom) 0 ≫ G.right.app (SimplexCategory.mk 0)

full_name: CategoryTheory.CosimplicialObject.equivalenceLeftToRight_left
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps]
def equivalenceLeftToRight (F : Arrow C) (X : CosimplicialObject.Augmented C)
    (G : F.augmentedCechConerve ⟶ X) : F ⟶ Augmented.toArrow.obj X 
goal: (CategoryTheory.CosimplicialObject.equivalenceLeftToRight F X G).left = G.left

full_name: CategoryTheory.CosimplicialObject.equivalenceRightToLeft_left
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps!]
def equivalenceRightToLeft (F : Arrow C) (X : CosimplicialObject.Augmented C)
    (G : F ⟶ Augmented.toArrow.obj X) : F.augmentedCechConerve ⟶ X 
goal: (CategoryTheory.CosimplicialObject.equivalenceRightToLeft F X G).left = G.left

full_name: CategoryTheory.CosimplicialObject.equivalenceRightToLeft
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps!]
def equivalenceRightToLeft (F : Arrow C) (X : CosimplicialObject.Augmented C)
    (G : F ⟶ Augmented.toArrow.obj X) : F.augmentedCechConerve ⟶ X 
goal: F.augmentedCechConerve ⟶ X

full_name: CategoryTheory.CosimplicialObject.equivalenceRightToLeft_right_app
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps!]
def equivalenceRightToLeft (F : Arrow C) (X : CosimplicialObject.Augmented C)
    (G : F ⟶ Augmented.toArrow.obj X) : F.augmentedCechConerve ⟶ X 
goal: (CategoryTheory.CosimplicialObject.equivalenceRightToLeft F X G).right.app x =
  CategoryTheory.Limits.WidePushout.desc (G.left ≫ X.hom.app x)
    (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯

full_name: CategoryTheory.CosimplicialObject.cechConerveEquiv_symm_apply
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps]
def cechConerveEquiv (F : Arrow C) (X : CosimplicialObject.Augmented C) :
    (F.augmentedCechConerve ⟶ X) ≃ (F ⟶ Augmented.toArrow.obj X) 
goal: (CategoryTheory.CosimplicialObject.cechConerveEquiv F X).symm G =
  CategoryTheory.CosimplicialObject.equivalenceRightToLeft F X G

full_name: CategoryTheory.CosimplicialObject.cechConerveEquiv_apply
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps]
def cechConerveEquiv (F : Arrow C) (X : CosimplicialObject.Augmented C) :
    (F.augmentedCechConerve ⟶ X) ≃ (F ⟶ Augmented.toArrow.obj X) 
goal: (CategoryTheory.CosimplicialObject.cechConerveEquiv F X) G =
  CategoryTheory.CosimplicialObject.equivalenceLeftToRight F X G

full_name: CategoryTheory.CosimplicialObject.cechConerveEquiv
code: /-- A helper function used in defining the Čech conerve adjunction. -/
@[simps]
def cechConerveEquiv (F : Arrow C) (X : CosimplicialObject.Augmented C) :
    (F.augmentedCechConerve ⟶ X) ≃ (F ⟶ Augmented.toArrow.obj X) 
goal: (F.augmentedCechConerve ⟶ X) ≃ (F ⟶ CategoryTheory.CosimplicialObject.Augmented.toArrow.obj X)

full_name: CategoryTheory.CosimplicialObject.cechConerveAdjunction
code: /-- The augmented Čech conerve construction is left adjoint to the `toArrow` functor. -/
abbrev cechConerveAdjunction : augmentedCechConerve ⊣ (Augmented.toArrow : _ ⥤ Arrow C) 
goal: CategoryTheory.CosimplicialObject.augmentedCechConerve ⊣ CategoryTheory.CosimplicialObject.Augmented.toArrow

full_name: CategoryTheory.cechNerveTerminalFrom
code: /-- Given an object `X : C`, the natural simplicial object sending `[n]` to `Xⁿ⁺¹`. -/
def cechNerveTerminalFrom {C : Type u} [Category.{v} C] [HasFiniteProducts C] (X : C) :
    SimplicialObject C 
goal: CategoryTheory.SimplicialObject C

full_name: CategoryTheory.CechNerveTerminalFrom.wideCospan
code: /-- The diagram `Option ι ⥤ C` sending `none` to the terminal object and `some j` to `X`. -/
def wideCospan (X : C) : WidePullbackShape ι ⥤ C 
goal: CategoryTheory.Limits.WidePullbackShape ι ⥤ C

full_name: CategoryTheory.CechNerveTerminalFrom.uniqueToWideCospanNone
code: instance uniqueToWideCospanNone (X Y : C) : Unique (Y ⟶ (wideCospan ι X).obj none) 
goal: Unique (Y ⟶ (CategoryTheory.CechNerveTerminalFrom.wideCospan ι X).obj none)

full_name: CategoryTheory.CechNerveTerminalFrom.wideCospan.limitCone
code: /-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.CechNerveTerminalFrom.wideCospan ι X)

full_name: CategoryTheory.CechNerveTerminalFrom.hasWidePullback
code: instance hasWidePullback [Finite ι] (X : C) :
    HasWidePullback (Arrow.mk (terminal.from X)).right
      (fun _ : ι => (Arrow.mk (terminal.from X)).left)
      (fun _ => (Arrow.mk (terminal.from X)).hom) 
goal: CategoryTheory.Limits.HasWidePullback (CategoryTheory.Arrow.mk (CategoryTheory.Limits.terminal.from X)).right
  (fun x => (CategoryTheory.Arrow.mk (CategoryTheory.Limits.terminal.from X)).left) fun x =>
  (CategoryTheory.Arrow.mk (CategoryTheory.Limits.terminal.from X)).hom

full_name: CategoryTheory.CechNerveTerminalFrom.hasWidePullback'
code: instance hasWidePullback' [Finite ι] (X : C) :
    HasWidePullback (⊤_ C)
      (fun _ : ι => X)
      (fun _ => terminal.from X) 
goal: CategoryTheory.Limits.HasWidePullback (⊤_ C) (fun x => X) fun x => CategoryTheory.Limits.terminal.from X

full_name: CategoryTheory.CechNerveTerminalFrom.hasLimit_wideCospan
code: instance hasLimit_wideCospan [Finite ι] (X : C) : HasLimit (wideCospan ι X) 
goal: CategoryTheory.Limits.HasLimit (CategoryTheory.CechNerveTerminalFrom.wideCospan ι X)

full_name: CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi
code: /-- the isomorphism to the product induced by the limit cone `wideCospan ι X` -/
def wideCospan.limitIsoPi [Finite ι] (X : C) :
    limit (wideCospan ι X) ≅ ∏ᶜ fun _ : ι => X 
goal: CategoryTheory.Limits.limit (CategoryTheory.CechNerveTerminalFrom.wideCospan ι X) ≅ ∏ᶜ fun x => X

full_name: CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi_inv_comp_pi
code: @[reassoc (attr := simp)]
lemma wideCospan.limitIsoPi_inv_comp_pi [Finite ι] (X : C) (j : ι) :
    (wideCospan.limitIsoPi ι X).inv ≫ WidePullback.π _ j = Pi.π _ j 
goal: (CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi ι X).inv ≫
    CategoryTheory.Limits.WidePullback.π (fun x => CategoryTheory.Limits.terminal.from X) j =
  CategoryTheory.Limits.Pi.π (fun x => X) j

full_name: CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi_hom_comp_pi
code: @[reassoc (attr := simp)]
lemma wideCospan.limitIsoPi_hom_comp_pi [Finite ι] (X : C) (j : ι) :
    (wideCospan.limitIsoPi ι X).hom ≫ Pi.π _ j = WidePullback.π _ j 
goal: (CategoryTheory.CechNerveTerminalFrom.wideCospan.limitIsoPi ι X).hom ≫ CategoryTheory.Limits.Pi.π (fun x => X) j =
  CategoryTheory.Limits.WidePullback.π (fun x => CategoryTheory.Limits.terminal.from X) j

full_name: CategoryTheory.CechNerveTerminalFrom.iso
code: /-- Given an object `X : C`, the Čech nerve of the hom to the terminal object `X ⟶ ⊤_ C` is
naturally isomorphic to a simplicial object sending `[n]` to `Xⁿ⁺¹` (when `C` is `G-Set`, this is
`EG`, the universal cover of the classifying space of `G`. -/
def iso (X : C) : (Arrow.mk (terminal.from X)).cechNerve ≅ cechNerveTerminalFrom X 
goal: (CategoryTheory.Arrow.mk (CategoryTheory.Limits.terminal.from X)).cechNerve ≅ CategoryTheory.cechNerveTerminalFrom X