l3lab/ntp-mathlib huggingface dataset:
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
⊢ ∀ ⦃X_1 Y : SimplexCategory⦄ (f : X_1 ⟶ Y),
    (Arrow.augmentedCechConerve F).right.map f ≫
        (fun x =>
            WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
              (_ :
                ∀ (j : Fin (SimplexCategory.len x + 1)),
                  F.hom ≫ (fun i => G.right ≫ X.right.map (SimplexCategory.const x i)) j = G.left ≫ X.hom.app x))
          Y =
      (fun x =>
            WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
              (_ :
                ∀ (j : Fin (SimplexCategory.len x + 1)),
                  F.hom ≫ (fun i => G.right ≫ X.right.map (SimplexCategory.const x i)) j = G.left ≫ X.hom.app x))
          X_1 ≫
        X.right.map f

Next tactic:
intro x y f
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
⊢ (Arrow.augmentedCechConerve F).right.map f ≫
      (fun x =>
          WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
            (_ :
              ∀ (j : Fin (SimplexCategory.len x + 1)),
                F.hom ≫ (fun i => G.right ≫ X.right.map (SimplexCategory.const x i)) j = G.left ≫ X.hom.app x))
        y =
    (fun x =>
          WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
            (_ :
              ∀ (j : Fin (SimplexCategory.len x + 1)),
                F.hom ≫ (fun i => G.right ≫ X.right.map (SimplexCategory.const x i)) j = G.left ≫ X.hom.app x))
        x ≫
      X.right.map f

Next tactic:
dsimp
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
⊢ WidePushout.desc (WidePushout.head fun x => F.hom)
        (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i))
        (_ :
          ∀ (j : Fin (SimplexCategory.len x + 1)),
            F.hom ≫ (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i)) j =
              WidePushout.head fun x => F.hom) ≫
      WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map (SimplexCategory.const y i))
        (_ :
          ∀ (j : Fin (SimplexCategory.len y + 1)),
            F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const y j) = G.left ≫ X.hom.app y) =
    WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
        (_ :
          ∀ (j : Fin (SimplexCategory.len x + 1)),
            F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const x j) = G.left ≫ X.hom.app x) ≫
      X.right.map f

Next tactic:
ext
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · 

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
j✝ : Fin (SimplexCategory.len x + 1)
⊢ WidePushout.ι (fun x => F.hom) j✝ ≫
      WidePushout.desc (WidePushout.head fun x => F.hom)
          (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i)) j =
                WidePushout.head fun x => F.hom) ≫
        WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map (SimplexCategory.const y i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const y j) = G.left ≫ X.hom.app y) =
    WidePushout.ι (fun x => F.hom) j✝ ≫
      WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const x j) = G.left ≫ X.hom.app x) ≫
        X.right.map f

Next tactic:
dsimp
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
j✝ : Fin (SimplexCategory.len x + 1)
⊢ WidePushout.ι (fun x => F.hom) j✝ ≫
      WidePushout.desc (WidePushout.head fun x => F.hom)
          (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i)) j =
                WidePushout.head fun x => F.hom) ≫
        WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map (SimplexCategory.const y i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const y j) = G.left ≫ X.hom.app y) =
    WidePushout.ι (fun x => F.hom) j✝ ≫
      WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const x j) = G.left ≫ X.hom.app x) ≫
        X.right.map f

Next tactic:
simp only [WidePushout.ι_desc_assoc, WidePushout.ι_desc]
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePushout.ι_desc_assoc, WidePushout.ι_desc]
          

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
j✝ : Fin (SimplexCategory.len x + 1)
⊢ G.right ≫ X.right.map (SimplexCategory.const y ((SimplexCategory.Hom.toOrderHom f) j✝)) =
    (G.right ≫ X.right.map (SimplexCategory.const x j✝)) ≫ X.right.map f

Next tactic:
rw [Category.assoc, ← X.right.map_comp]
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePushout.ι_desc_assoc, WidePushout.ι_desc]
          rw [Category.assoc, ← X.right.map_comp]
          

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
j✝ : Fin (SimplexCategory.len x + 1)
⊢ G.right ≫ X.right.map (SimplexCategory.const y ((SimplexCategory.Hom.toOrderHom f) j✝)) =
    G.right ≫ X.right.map (SimplexCategory.const x j✝ ≫ f)

Next tactic:
rfl
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePushout.ι_desc_assoc, WidePushout.ι_desc]
          rw [Category.assoc, ← X.right.map_comp]
          rfl
        · 

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
⊢ (WidePushout.head fun x => F.hom) ≫
      WidePushout.desc (WidePushout.head fun x => F.hom)
          (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i)) j =
                WidePushout.head fun x => F.hom) ≫
        WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map (SimplexCategory.const y i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const y j) = G.left ≫ X.hom.app y) =
    (WidePushout.head fun x => F.hom) ≫
      WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const x j) = G.left ≫ X.hom.app x) ≫
        X.right.map f

Next tactic:
dsimp
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePushout.ι_desc_assoc, WidePushout.ι_desc]
          rw [Category.assoc, ← X.right.map_comp]
          rfl
        · dsimp
          

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
⊢ (WidePushout.head fun x => F.hom) ≫
      WidePushout.desc (WidePushout.head fun x => F.hom)
          (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ (fun i => WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f) i)) j =
                WidePushout.head fun x => F.hom) ≫
        WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map (SimplexCategory.const y i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const y j) = G.left ≫ X.hom.app y) =
    (WidePushout.head fun x => F.hom) ≫
      WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len x + 1)),
              F.hom ≫ G.right ≫ X.right.map (SimplexCategory.const x j) = G.left ≫ X.hom.app x) ≫
        X.right.map f

Next tactic:
simp only [Functor.const_obj_map, ← NatTrans.naturality, WidePushout.head_desc_assoc,
            WidePushout.head_desc, Category.assoc]
/-- 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 where
  left := G.left
  right :=
    { app := fun x =>
        Limits.WidePushout.desc (G.left ≫ X.hom.app _)
          (fun i => G.right ≫ X.right.map (SimplexCategory.const x i))
          (by
            rintro j
            rw [← Arrow.w_assoc G]
            have t := X.hom.naturality (x.const j)
            dsimp at t ⊢
            simp only [Category.id_comp] at t
            rw [← t])
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePushout.ι_desc_assoc, WidePushout.ι_desc]
          rw [Category.assoc, ← X.right.map_comp]
          rfl
        · dsimp
          simp only [Functor.const_obj_map, ← NatTrans.naturality, WidePushout.head_desc_assoc,
            WidePushout.head_desc, Category.assoc]
          

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F ⟶ Augmented.toArrow.obj X
x y : SimplexCategory
f : x ⟶ y
⊢ G.left ≫ X.hom.app y = G.left ≫ 𝟙 X.left ≫ X.hom.app y

Next tactic:
erw [Category.id_comp]
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
⊢ Function.LeftInverse (equivalenceRightToLeft F X) (equivalenceLeftToRight F X)

Next tactic:
intro A
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : Arrow.augmentedCechConerve F ⟶ X
⊢ equivalenceRightToLeft F X (equivalenceLeftToRight F X A) = A

Next tactic:
ext x : 2
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext x : 2
    · 

Proof state:
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : Arrow.augmentedCechConerve F ⟶ X
⊢ (equivalenceRightToLeft F X (equivalenceLeftToRight F X A)).left = A.left

Next tactic:
rfl
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext x : 2
    · rfl
    · 

Proof state:
case h₂.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : Arrow.augmentedCechConerve F ⟶ X
x : SimplexCategory
⊢ (equivalenceRightToLeft F X (equivalenceLeftToRight F X A)).right.app x = A.right.app x

Next tactic:
refine' WidePushout.hom_ext _ _ _ (fun j => _) _
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext x : 2
    · rfl
    · refine' WidePushout.hom_ext _ _ _ (fun j => _) _
      · 

Proof state:
case h₂.h.refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : Arrow.augmentedCechConerve F ⟶ X
x : SimplexCategory
j : Fin (SimplexCategory.len x + 1)
⊢ WidePushout.ι (fun x => F.hom) j ≫ (equivalenceRightToLeft F X (equivalenceLeftToRight F X A)).right.app x =
    WidePushout.ι (fun x => F.hom) j ≫ A.right.app x

Next tactic:
dsimp
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext x : 2
    · rfl
    · refine' WidePushout.hom_ext _ _ _ (fun j => _) _
      · dsimp
        

Proof state:
case h₂.h.refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : Arrow.augmentedCechConerve F ⟶ X
x : SimplexCategory
j : Fin (SimplexCategory.len x + 1)
⊢ WidePushout.ι (fun x => F.hom) j ≫
      WidePushout.desc (A.left ≫ X.hom.app x)
        (fun i =>
          (WidePushout.ι (fun x => F.hom) 0 ≫ A.right.app (SimplexCategory.mk 0)) ≫
            X.right.map (SimplexCategory.const x i))
        (_ :
          ∀ (j : Fin (SimplexCategory.len x + 1)),
            F.hom ≫ (fun i => (equivalenceLeftToRight F X A).right ≫ X.right.map (SimplexCategory.const x i)) j =
              (equivalenceLeftToRight F X A).left ≫ X.hom.app x) =
    WidePushout.ι (fun x => F.hom) j ≫ A.right.app x

Next tactic:
simp only [Category.assoc, ← NatTrans.naturality A.right, Arrow.augmentedCechConerve_right,
          SimplexCategory.len_mk, Arrow.cechConerve_map, colimit.ι_desc,
          WidePushoutShape.mkCocone_ι_app, colimit.ι_desc_assoc]
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext x : 2
    · rfl
    · refine' WidePushout.hom_ext _ _ _ (fun j => _) _
      · dsimp
        simp only [Category.assoc, ← NatTrans.naturality A.right, Arrow.augmentedCechConerve_right,
          SimplexCategory.len_mk, Arrow.cechConerve_map, colimit.ι_desc,
          WidePushoutShape.mkCocone_ι_app, colimit.ι_desc_assoc]
        

Proof state:
case h₂.h.refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
A : Arrow.augmentedCechConerve F ⟶ X
x : SimplexCategory
j : Fin (SimplexCategory.len x + 1)
⊢ WidePushout.ι (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom (SimplexCategory.const x j)) 0) ≫ A.right.app x =
    WidePushout.ι (fun x => F.hom) j ≫ A.right.app x

Next tactic:
rfl