l3lab/ntp-mathlib huggingface dataset:
/-- 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 where
  left :=
    { app := fun x =>
        Limits.WidePullback.lift (X.hom.app _ ≫ G.right)
          (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) fun i => by
          dsimp
          erw [Category.assoc, Arrow.w, Augmented.toArrow_obj_hom, NatTrans.naturality_assoc,
            Functor.const_obj_map, Category.id_comp]
      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), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
G : Augmented.toArrow.obj X ⟶ F
x y : SimplexCategoryᵒᵖ
f : x ⟶ y
j✝ : Fin (SimplexCategory.len y.unop + 1)
⊢ (X.left.map f ≫
        WidePullback.lift (X.hom.app y ≫ G.right) (fun i => X.left.map (SimplexCategory.const y.unop i).op ≫ G.left)
          (_ :
            ∀ (i : Fin (SimplexCategory.len y.unop + 1)),
              (X.left.map (SimplexCategory.const y.unop i).op ≫ G.left) ≫ F.hom = X.hom.app y ≫ G.right)) ≫
      WidePullback.π (fun x => F.hom) j✝ =
    (WidePullback.lift (X.hom.app x ≫ G.right) (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left)
          (_ :
            ∀ (i : Fin (SimplexCategory.len x.unop + 1)),
              (X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) ≫ F.hom = X.hom.app x ≫ G.right) ≫
        WidePullback.lift (WidePullback.base fun x => F.hom)
          (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y.unop + 1)),
              WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) j) ≫ F.hom =
                WidePullback.base fun x => F.hom)) ≫
      WidePullback.π (fun x => F.hom) j✝

Next tactic:
simp only [WidePullback.lift_π, Category.assoc, ← X.left.map_comp_assoc]
/-- 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 where
  left :=
    { app := fun x =>
        Limits.WidePullback.lift (X.hom.app _ ≫ G.right)
          (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) fun i => by
          dsimp
          erw [Category.assoc, Arrow.w, Augmented.toArrow_obj_hom, NatTrans.naturality_assoc,
            Functor.const_obj_map, Category.id_comp]
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePullback.lift_π, Category.assoc, ← X.left.map_comp_assoc]
          

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

Next tactic:
rfl
/-- 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 where
  left :=
    { app := fun x =>
        Limits.WidePullback.lift (X.hom.app _ ≫ G.right)
          (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) fun i => by
          dsimp
          erw [Category.assoc, Arrow.w, Augmented.toArrow_obj_hom, NatTrans.naturality_assoc,
            Functor.const_obj_map, Category.id_comp]
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePullback.lift_π, Category.assoc, ← X.left.map_comp_assoc]
          rfl
        · 

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
G : Augmented.toArrow.obj X ⟶ F
x y : SimplexCategoryᵒᵖ
f : x ⟶ y
⊢ ((X.left.map f ≫
        WidePullback.lift (X.hom.app y ≫ G.right) (fun i => X.left.map (SimplexCategory.const y.unop i).op ≫ G.left)
          (_ :
            ∀ (i : Fin (SimplexCategory.len y.unop + 1)),
              (X.left.map (SimplexCategory.const y.unop i).op ≫ G.left) ≫ F.hom = X.hom.app y ≫ G.right)) ≫
      WidePullback.base fun x => F.hom) =
    (WidePullback.lift (X.hom.app x ≫ G.right) (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left)
          (_ :
            ∀ (i : Fin (SimplexCategory.len x.unop + 1)),
              (X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) ≫ F.hom = X.hom.app x ≫ G.right) ≫
        WidePullback.lift (WidePullback.base fun x => F.hom)
          (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y.unop + 1)),
              WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) j) ≫ F.hom =
                WidePullback.base fun x => F.hom)) ≫
      WidePullback.base fun x => F.hom

Next tactic:
dsimp
/-- 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 where
  left :=
    { app := fun x =>
        Limits.WidePullback.lift (X.hom.app _ ≫ G.right)
          (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) fun i => by
          dsimp
          erw [Category.assoc, Arrow.w, Augmented.toArrow_obj_hom, NatTrans.naturality_assoc,
            Functor.const_obj_map, Category.id_comp]
      naturality := by
        intro x y f
        dsimp
        ext
        · dsimp
          simp only [WidePullback.lift_π, Category.assoc, ← X.left.map_comp_assoc]
          rfl
        · dsimp
          

Proof state:
case a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
G : Augmented.toArrow.obj X ⟶ F
x y : SimplexCategoryᵒᵖ
f : x ⟶ y
⊢ ((X.left.map f ≫
        WidePullback.lift (X.hom.app y ≫ G.right) (fun i => X.left.map (SimplexCategory.const y.unop i).op ≫ G.left)
          (_ :
            ∀ (i : Fin (SimplexCategory.len y.unop + 1)),
              (X.left.map (SimplexCategory.const y.unop i).op ≫ G.left) ≫ F.hom = X.hom.app y ≫ G.right)) ≫
      WidePullback.base fun x => F.hom) =
    (WidePullback.lift (X.hom.app x ≫ G.right) (fun i => X.left.map (SimplexCategory.const x.unop i).op ≫ G.left)
          (_ :
            ∀ (i : Fin (SimplexCategory.len x.unop + 1)),
              (X.left.map (SimplexCategory.const x.unop i).op ≫ G.left) ≫ F.hom = X.hom.app x ≫ G.right) ≫
        WidePullback.lift (WidePullback.base fun x => F.hom)
          (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len y.unop + 1)),
              WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) j) ≫ F.hom =
                WidePullback.base fun x => F.hom)) ≫
      WidePullback.base fun x => F.hom

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

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

Next tactic:
intro A
/-- 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) 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), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ equivalenceRightToLeft X F (equivalenceLeftToRight X F A) = A

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

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

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

Proof state:
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ WidePullback.lift (X.hom.app (Opposite.op (SimplexCategory.mk 0)) ≫ A.right)
        (fun i => X.left.map (SimplexCategory.const (SimplexCategory.mk 0) i).op ≫ A.left)
        (_ :
          ∀ (i : Fin (SimplexCategory.len (Opposite.op (SimplexCategory.mk 0)).unop + 1)),
            (fun i => X.left.map (SimplexCategory.const (Opposite.op (SimplexCategory.mk 0)).unop i).op ≫ A.left) i ≫
                F.hom =
              X.hom.app (Opposite.op (SimplexCategory.mk 0)) ≫ A.right) ≫
      WidePullback.π (fun x => F.hom) 0 =
    A.left

Next tactic:
erw [WidePullback.lift_π]
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      

Proof state:
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ X.left.map (SimplexCategory.const (SimplexCategory.mk 0) 0).op ≫ A.left = A.left

Next tactic:
nth_rw 2 [← Category.id_comp A.left]
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      

Proof state:
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ X.left.map (SimplexCategory.const (SimplexCategory.mk 0) 0).op ≫ A.left = 𝟙 (Augmented.toArrow.obj X).left ≫ A.left

Next tactic:
congr 1
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      

Proof state:
case h₁.e_a
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ X.left.map (SimplexCategory.const (SimplexCategory.mk 0) 0).op = 𝟙 (Augmented.toArrow.obj X).left

Next tactic:
convert X.left.map_id _
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      

Proof state:
case h.e'_2.h.h.e'_8
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ (SimplexCategory.const (SimplexCategory.mk 0) 0).op = 𝟙 (Opposite.op (SimplexCategory.mk 0))

Next tactic:
rw [← op_id]
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      

Proof state:
case h.e'_2.h.h.e'_8
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ (SimplexCategory.const (SimplexCategory.mk 0) 0).op = (𝟙 (SimplexCategory.mk 0)).op

Next tactic:
congr 1
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      

Proof state:
case h.e'_2.h.h.e'_8.e_f
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
⊢ SimplexCategory.const (SimplexCategory.mk 0) 0 = 𝟙 (SimplexCategory.mk 0)

Next tactic:
ext ⟨a, ha⟩
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      

Proof state:
case h.e'_2.h.h.e'_8.e_f.a.h.h.mk.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
a : ℕ
ha : a < SimplexCategory.len (SimplexCategory.mk 0) + 1
⊢ ↑((SimplexCategory.Hom.toOrderHom (SimplexCategory.const (SimplexCategory.mk 0) 0)) { val := a, isLt := ha }) =
    ↑((SimplexCategory.Hom.toOrderHom (𝟙 (SimplexCategory.mk 0))) { val := a, isLt := ha })

Next tactic:
change a < 1 at ha
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      

Proof state:
case h.e'_2.h.h.e'_8.e_f.a.h.h.mk.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
a : ℕ
ha : a < 1
⊢ ↑((SimplexCategory.Hom.toOrderHom (SimplexCategory.const (SimplexCategory.mk 0) 0)) { val := a, isLt := ha }) =
    ↑((SimplexCategory.Hom.toOrderHom (𝟙 (SimplexCategory.mk 0))) { val := a, isLt := ha })

Next tactic:
change 0 = a
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      change 0 = a
      

Proof state:
case h.e'_2.h.h.e'_8.e_f.a.h.h.mk.h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : Augmented.toArrow.obj X ⟶ F
a : ℕ
ha : a < 1
⊢ 0 = a

Next tactic:
linarith
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      change 0 = a
      linarith
    · 

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

Next tactic:
rfl
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      change 0 = a
      linarith
    · rfl
  right_inv := by
    

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

Next tactic:
intro A
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      change 0 = a
      linarith
    · rfl
  right_inv := by
    intro A
    

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

Next tactic:
ext x : 2
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      change 0 = a
      linarith
    · rfl
  right_inv := by
    intro A
    ext x : 2
    · 

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

Next tactic:
refine' WidePullback.hom_ext _ _ _ (fun j => _) _
/-- 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) where
  toFun := equivalenceLeftToRight _ _
  invFun := equivalenceRightToLeft _ _
  left_inv := by
    intro A
    ext
    · dsimp
      erw [WidePullback.lift_π]
      nth_rw 2 [← Category.id_comp A.left]
      congr 1
      convert X.left.map_id _
      rw [← op_id]
      congr 1
      ext ⟨a, ha⟩
      change a < 1 at ha
      change 0 = a
      linarith
    · rfl
  right_inv := by
    intro A
    ext x : 2
    · refine' WidePullback.hom_ext _ _ _ (fun j => _) _
      · 

Proof state:
case h₁.h.refine'_1
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePullback f.right (fun x => f.left) fun x => f.hom
X : Augmented C
F : Arrow C
A : X ⟶ Arrow.augmentedCechNerve F
x : SimplexCategoryᵒᵖ
j : Fin (SimplexCategory.len x.unop + 1)
⊢ (equivalenceLeftToRight X F (equivalenceRightToLeft X F A)).left.app x ≫ WidePullback.π (fun x => F.hom) j =
    A.left.app x ≫ WidePullback.π (fun x => F.hom) j

Next tactic:
dsimp