Theorem: CategoryTheory.SimplicialObject.equivalenceLeftToRight_right
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: 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 : SimplexCategoryᵒᵖ
i : Fin ((Opposite.unop x).len + 1)
⊢ (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) i ≫ F.hom = X.hom.app x ≫ G.right
state_after: 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 : SimplexCategoryᵒᵖ
i : Fin ((Opposite.unop x).len + 1)
⊢ (X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ≫ F.hom = X.hom.app x ≫ G.right
tactic: dsimp
state_before: 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 : SimplexCategoryᵒᵖ
i : Fin ((Opposite.unop x).len + 1)
⊢ (X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ≫ F.hom = X.hom.app x ≫ G.right
state_after: no goals
tactic: erw [Category.assoc, Arrow.w, Augmented.toArrow_obj_hom, NatTrans.naturality_assoc,
            Functor.const_obj_map, Category.id_comp]
state_before: 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_1 Y : SimplexCategoryᵒᵖ⦄ (f : X_1 ⟶ Y),
    X.left.map f ≫
        (fun x =>
            WidePullback.lift (X.hom.app x ≫ G.right)
              (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯)
          Y =
      (fun x =>
            WidePullback.lift (X.hom.app x ≫ G.right)
              (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯)
          X_1 ≫
        F.augmentedCechNerve.left.map f
state_after: 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 ≫
      (fun x =>
          WidePullback.lift (X.hom.app x ≫ G.right)
            (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯)
        y =
    (fun x =>
          WidePullback.lift (X.hom.app x ≫ G.right)
            (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯)
        x ≫
      F.augmentedCechNerve.left.map f
tactic: intro x y f
state_before: 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 ≫
      (fun x =>
          WidePullback.lift (X.hom.app x ≫ G.right)
            (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯)
        y =
    (fun x =>
          WidePullback.lift (X.hom.app x ≫ G.right)
            (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯)
        x ≫
      F.augmentedCechNerve.left.map f
state_after: 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.mk 0).const (Opposite.unop y) i).op ≫ G.left) ⋯ =
    WidePullback.lift (X.hom.app x ≫ G.right)
        (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯ ≫
      WidePullback.lift (WidePullback.base fun x => F.hom)
        (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i)) ⋯
tactic: dsimp
state_before: 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.mk 0).const (Opposite.unop y) i).op ≫ G.left) ⋯ =
    WidePullback.lift (X.hom.app x ≫ G.right)
        (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯ ≫
      WidePullback.lift (WidePullback.base fun x => F.hom)
        (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i)) ⋯
state_after: 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 ((Opposite.unop y).len + 1)
⊢ (X.left.map f ≫
        WidePullback.lift (X.hom.app y ≫ G.right)
          (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop y) i).op ≫ G.left) ⋯) ≫
      WidePullback.π (fun x => F.hom) j✝ =
    (WidePullback.lift (X.hom.app x ≫ G.right)
          (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯ ≫
        WidePullback.lift (WidePullback.base fun x => F.hom)
          (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i)) ⋯) ≫
      WidePullback.π (fun x => F.hom) j✝

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.mk 0).const (Opposite.unop y) i).op ≫ G.left) ⋯) ≫
      WidePullback.base fun x => F.hom) =
    (WidePullback.lift (X.hom.app x ≫ G.right)
          (fun i => X.left.map ((SimplexCategory.mk 0).const (Opposite.unop x) i).op ≫ G.left) ⋯ ≫
        WidePullback.lift (WidePullback.base fun x => F.hom)
          (fun i => WidePullback.π (fun x => F.hom) ((SimplexCategory.Hom.toOrderHom f.unop) i)) ⋯) ≫
      WidePullback.base fun x => F.hom
tactic: ext