l3lab/ntp-mathlib huggingface dataset:
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals 

Proof state:
case id.none
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
⊢ ((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).map (WidePullbackShape.Hom.id none) ≫
      (fun X_1 =>
          Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
            fun i => limit.π (Discrete.functor fun x => X) { as := i })
        none =
    (fun X_1 =>
          Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
            fun i => limit.π (Discrete.functor fun x => X) { as := i })
        none ≫
      (wideCospan ι X).map (WidePullbackShape.Hom.id none)

Next tactic:
dsimp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; 

Proof state:
case id.none
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
⊢ 𝟙 (∏ fun x => X) ≫ terminal.from (∏ fun x => X) = terminal.from (∏ fun x => X) ≫ (wideCospan ι X).map (𝟙 none)

Next tactic:
simp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals 

Proof state:
case id.some
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
val✝ : ι
⊢ ((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).map (WidePullbackShape.Hom.id (some val✝)) ≫
      (fun X_1 =>
          Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
            fun i => limit.π (Discrete.functor fun x => X) { as := i })
        (some val✝) =
    (fun X_1 =>
          Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
            fun i => limit.π (Discrete.functor fun x => X) { as := i })
        (some val✝) ≫
      (wideCospan ι X).map (WidePullbackShape.Hom.id (some val✝))

Next tactic:
dsimp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; 

Proof state:
case id.some
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
val✝ : ι
⊢ 𝟙 (∏ fun x => X) ≫ limit.π (Discrete.functor fun x => X) { as := val✝ } =
    limit.π (Discrete.functor fun x => X) { as := val✝ } ≫ (wideCospan ι X).map (𝟙 (some val✝))

Next tactic:
simp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · 

Proof state:
case term
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
j✝ : ι
⊢ ((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).map (WidePullbackShape.Hom.term j✝) ≫
      (fun X_1 =>
          Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
            fun i => limit.π (Discrete.functor fun x => X) { as := i })
        none =
    (fun X_1 =>
          Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
            fun i => limit.π (Discrete.functor fun x => X) { as := i })
        (some j✝) ≫
      (wideCospan ι X).map (WidePullbackShape.Hom.term j✝)

Next tactic:
dsimp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              

Proof state:
case term
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
j✝ : ι
⊢ 𝟙 (∏ fun x => X) ≫ terminal.from (∏ fun x => X) =
    limit.π (Discrete.functor fun x => X) { as := j✝ } ≫ (wideCospan ι X).map (WidePullbackShape.Hom.term j✝)

Next tactic:
simp only [terminal.comp_from]
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              

Proof state:
case term
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
j✝ : ι
⊢ terminal.from (∏ fun x => X) =
    limit.π (Discrete.functor fun x => X) { as := j✝ } ≫ (wideCospan ι X).map (WidePullbackShape.Hom.term j✝)

Next tactic:
exact Subsingleton.elim _ _
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              exact Subsingleton.elim _ _ } }
  isLimit :=
    { lift := fun s => Limits.Pi.lift fun j => s.π.app (some j)
      fac := fun s j => Option.casesOn j (Subsingleton.elim _ _) fun j => limit.lift_π _ _
      uniq := fun s f h => by
        

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
s : Cone (wideCospan ι X)
f :
  s.pt ⟶
    { pt := ∏ fun x => X,
        π :=
          NatTrans.mk fun X_1 =>
            Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
              fun i => limit.π (Discrete.functor fun x => X) { as := i } }.pt
h :
  ∀ (j : WidePullbackShape ι),
    f ≫
        { pt := ∏ fun x => X,
                π :=
                  NatTrans.mk fun X_1 =>
                    Option.casesOn X_1
                      (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none)) fun i =>
                      limit.π (Discrete.functor fun x => X) { as := i } }.π.app
          j =
      s.π.app j
⊢ f = (fun s => Pi.lift fun j => s.π.app (some j)) s

Next tactic:
dsimp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              exact Subsingleton.elim _ _ } }
  isLimit :=
    { lift := fun s => Limits.Pi.lift fun j => s.π.app (some j)
      fac := fun s j => Option.casesOn j (Subsingleton.elim _ _) fun j => limit.lift_π _ _
      uniq := fun s f h => by
        dsimp
        

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
s : Cone (wideCospan ι X)
f :
  s.pt ⟶
    { pt := ∏ fun x => X,
        π :=
          NatTrans.mk fun X_1 =>
            Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
              fun i => limit.π (Discrete.functor fun x => X) { as := i } }.pt
h :
  ∀ (j : WidePullbackShape ι),
    f ≫
        { pt := ∏ fun x => X,
                π :=
                  NatTrans.mk fun X_1 =>
                    Option.casesOn X_1
                      (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none)) fun i =>
                      limit.π (Discrete.functor fun x => X) { as := i } }.π.app
          j =
      s.π.app j
⊢ f = Pi.lift fun j => s.π.app (some j)

Next tactic:
ext j
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              exact Subsingleton.elim _ _ } }
  isLimit :=
    { lift := fun s => Limits.Pi.lift fun j => s.π.app (some j)
      fac := fun s j => Option.casesOn j (Subsingleton.elim _ _) fun j => limit.lift_π _ _
      uniq := fun s f h => by
        dsimp
        ext j
        

Proof state:
case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
s : Cone (wideCospan ι X)
f :
  s.pt ⟶
    { pt := ∏ fun x => X,
        π :=
          NatTrans.mk fun X_1 =>
            Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
              fun i => limit.π (Discrete.functor fun x => X) { as := i } }.pt
h :
  ∀ (j : WidePullbackShape ι),
    f ≫
        { pt := ∏ fun x => X,
                π :=
                  NatTrans.mk fun X_1 =>
                    Option.casesOn X_1
                      (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none)) fun i =>
                      limit.π (Discrete.functor fun x => X) { as := i } }.π.app
          j =
      s.π.app j
j : ι
⊢ f ≫ Pi.π (fun x => X) j = (Pi.lift fun j => s.π.app (some j)) ≫ Pi.π (fun x => X) j

Next tactic:
dsimp only [Limits.Pi.lift]
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              exact Subsingleton.elim _ _ } }
  isLimit :=
    { lift := fun s => Limits.Pi.lift fun j => s.π.app (some j)
      fac := fun s j => Option.casesOn j (Subsingleton.elim _ _) fun j => limit.lift_π _ _
      uniq := fun s f h => by
        dsimp
        ext j
        dsimp only [Limits.Pi.lift]
        

Proof state:
case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
s : Cone (wideCospan ι X)
f :
  s.pt ⟶
    { pt := ∏ fun x => X,
        π :=
          NatTrans.mk fun X_1 =>
            Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
              fun i => limit.π (Discrete.functor fun x => X) { as := i } }.pt
h :
  ∀ (j : WidePullbackShape ι),
    f ≫
        { pt := ∏ fun x => X,
                π :=
                  NatTrans.mk fun X_1 =>
                    Option.casesOn X_1
                      (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none)) fun i =>
                      limit.π (Discrete.functor fun x => X) { as := i } }.π.app
          j =
      s.π.app j
j : ι
⊢ f ≫ Pi.π (fun x => X) j =
    limit.lift (Discrete.functor fun b => X) (Fan.mk s.pt fun j => s.π.app (some j)) ≫ Pi.π (fun x => X) j

Next tactic:
rw [limit.lift_π]
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              exact Subsingleton.elim _ _ } }
  isLimit :=
    { lift := fun s => Limits.Pi.lift fun j => s.π.app (some j)
      fac := fun s j => Option.casesOn j (Subsingleton.elim _ _) fun j => limit.lift_π _ _
      uniq := fun s f h => by
        dsimp
        ext j
        dsimp only [Limits.Pi.lift]
        rw [limit.lift_π]
        

Proof state:
case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
s : Cone (wideCospan ι X)
f :
  s.pt ⟶
    { pt := ∏ fun x => X,
        π :=
          NatTrans.mk fun X_1 =>
            Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
              fun i => limit.π (Discrete.functor fun x => X) { as := i } }.pt
h :
  ∀ (j : WidePullbackShape ι),
    f ≫
        { pt := ∏ fun x => X,
                π :=
                  NatTrans.mk fun X_1 =>
                    Option.casesOn X_1
                      (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none)) fun i =>
                      limit.π (Discrete.functor fun x => X) { as := i } }.π.app
          j =
      s.π.app j
j : ι
⊢ f ≫ Pi.π (fun x => X) j = (Fan.mk s.pt fun j => s.π.app (some j)).π.app { as := j }

Next tactic:
dsimp
/-- The product `Xᶥ` is the vertex of a limit cone on `wideCospan ι X`. -/
def wideCospan.limitCone [Finite ι] (X : C) : LimitCone (wideCospan ι X) where
  cone :=
    { pt := ∏ fun _ : ι => X
      π :=
        { app := fun X => Option.casesOn X (terminal.from _) fun i => limit.π _ ⟨i⟩
          naturality := fun i j f => by
            cases f
            · cases i
              all_goals dsimp; simp
            · dsimp
              simp only [terminal.comp_from]
              exact Subsingleton.elim _ _ } }
  isLimit :=
    { lift := fun s => Limits.Pi.lift fun j => s.π.app (some j)
      fac := fun s j => Option.casesOn j (Subsingleton.elim _ _) fun j => limit.lift_π _ _
      uniq := fun s f h => by
        dsimp
        ext j
        dsimp only [Limits.Pi.lift]
        rw [limit.lift_π]
        dsimp
        

Proof state:
case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
s : Cone (wideCospan ι X)
f :
  s.pt ⟶
    { pt := ∏ fun x => X,
        π :=
          NatTrans.mk fun X_1 =>
            Option.casesOn X_1 (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none))
              fun i => limit.π (Discrete.functor fun x => X) { as := i } }.pt
h :
  ∀ (j : WidePullbackShape ι),
    f ≫
        { pt := ∏ fun x => X,
                π :=
                  NatTrans.mk fun X_1 =>
                    Option.casesOn X_1
                      (terminal.from (((Functor.const (WidePullbackShape ι)).obj (∏ fun x => X)).obj none)) fun i =>
                      limit.π (Discrete.functor fun x => X) { as := i } }.π.app
          j =
      s.π.app j
j : ι
⊢ f ≫ Pi.π (fun x => X) j = s.π.app (some j)

Next tactic:
rw [← h (some j)]
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) := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
⊢ HasWidePullback (Arrow.mk (terminal.from X)).right (fun x => (Arrow.mk (terminal.from X)).left) fun x =>
    (Arrow.mk (terminal.from X)).hom

Next tactic:
cases nonempty_fintype ι
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) := by
  cases nonempty_fintype ι
  

Proof state:
case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
val✝ : Fintype ι
⊢ HasWidePullback (Arrow.mk (terminal.from X)).right (fun x => (Arrow.mk (terminal.from X)).left) fun x =>
    (Arrow.mk (terminal.from X)).hom

Next tactic:
exact ⟨⟨wideCospan.limitCone ι X⟩⟩
@[reassoc (attr := simp)]
lemma wideCospan.limitIsoPi_hom_comp_pi [Finite ι] (X : C) (j : ι) :
    (wideCospan.limitIsoPi ι X).hom ≫ Pi.π _ j = WidePullback.π _ j := by
  

Proof state:
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasTerminal C
ι : Type w
inst✝¹ : HasFiniteProducts C
inst✝ : Finite ι
X : C
j : ι
⊢ (limitIsoPi ι X).hom ≫ Pi.π (fun x => X) j = WidePullback.π (fun x => terminal.from X) j

Next tactic:
rw [← wideCospan.limitIsoPi_inv_comp_pi, Iso.hom_inv_id_assoc]
/-- 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 :=
  NatIso.ofComponents (fun m => wideCospan.limitIsoPi _ _) (fun {m n} f => by
    

Proof state:
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
ι : Type w
inst✝ : HasFiniteProducts C
X : C
m n : SimplexCategoryᵒᵖ
f : m ⟶ n
⊢ (Arrow.cechNerve (Arrow.mk (terminal.from X))).map f ≫
      ((fun m => wideCospan.limitIsoPi (Fin (SimplexCategory.len m.unop + 1)) (Arrow.mk (terminal.from X)).left)
          n).hom =
    ((fun m => wideCospan.limitIsoPi (Fin (SimplexCategory.len m.unop + 1)) (Arrow.mk (terminal.from X)).left) m).hom ≫
      (cechNerveTerminalFrom X).map f

Next tactic:
dsimp only [cechNerveTerminalFrom, Arrow.cechNerve]
/-- 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 :=
  NatIso.ofComponents (fun m => wideCospan.limitIsoPi _ _) (fun {m n} f => by
    dsimp only [cechNerveTerminalFrom, Arrow.cechNerve]
    

Proof state:
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
ι : Type w
inst✝ : HasFiniteProducts C
X : C
m n : SimplexCategoryᵒᵖ
f : m ⟶ n
⊢ WidePullback.lift (WidePullback.base fun x => (Arrow.mk (terminal.from X)).hom)
        (fun i =>
          WidePullback.π (fun x => (Arrow.mk (terminal.from X)).hom) ((SimplexCategory.Hom.toOrderHom f.unop) i))
        (_ :
          ∀ (j : Fin (SimplexCategory.len n.unop + 1)),
            WidePullback.π (fun x => (Arrow.mk (terminal.from X)).hom) ((SimplexCategory.Hom.toOrderHom f.unop) j) ≫
                (Arrow.mk (terminal.from X)).hom =
              WidePullback.base fun x => (Arrow.mk (terminal.from X)).hom) ≫
      (wideCospan.limitIsoPi (Fin (SimplexCategory.len n.unop + 1)) (Arrow.mk (terminal.from X)).left).hom =
    (wideCospan.limitIsoPi (Fin (SimplexCategory.len m.unop + 1)) (Arrow.mk (terminal.from X)).left).hom ≫
      Pi.lift fun i => Pi.π (fun x => X) ((SimplexCategory.Hom.toOrderHom f.unop) i)

Next tactic:
ext ⟨j⟩
/-- 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 :=
  NatIso.ofComponents (fun m => wideCospan.limitIsoPi _ _) (fun {m n} f => by
    dsimp only [cechNerveTerminalFrom, Arrow.cechNerve]
    ext ⟨j⟩
    

Proof state:
case h.mk
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasTerminal C
ι : Type w
inst✝ : HasFiniteProducts C
X : C
m n : SimplexCategoryᵒᵖ
f : m ⟶ n
j : ℕ
isLt✝ : j < SimplexCategory.len n.unop + 1
⊢ (WidePullback.lift (WidePullback.base fun x => (Arrow.mk (terminal.from X)).hom)
          (fun i =>
            WidePullback.π (fun x => (Arrow.mk (terminal.from X)).hom) ((SimplexCategory.Hom.toOrderHom f.unop) i))
          (_ :
            ∀ (j : Fin (SimplexCategory.len n.unop + 1)),
              WidePullback.π (fun x => (Arrow.mk (terminal.from X)).hom) ((SimplexCategory.Hom.toOrderHom f.unop) j) ≫
                  (Arrow.mk (terminal.from X)).hom =
                WidePullback.base fun x => (Arrow.mk (terminal.from X)).hom) ≫
        (wideCospan.limitIsoPi (Fin (SimplexCategory.len n.unop + 1)) (Arrow.mk (terminal.from X)).left).hom) ≫
      Pi.π (fun x => X) { val := j, isLt := isLt✝ } =
    ((wideCospan.limitIsoPi (Fin (SimplexCategory.len m.unop + 1)) (Arrow.mk (terminal.from X)).left).hom ≫
        Pi.lift fun i => Pi.π (fun x => X) ((SimplexCategory.Hom.toOrderHom f.unop) i)) ≫
      Pi.π (fun x => X) { val := j, isLt := isLt✝ }

Next tactic:
simp only [Category.assoc, limit.lift_π, Fan.mk_π_app]