Theorem: CategoryTheory.CosimplicialObject.equivalenceRightToLeft_right_app
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: 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 : SimplexCategory
⊢ ∀ (j : Fin (x.len + 1)),
    F.hom ≫ (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) j = G.left ≫ X.hom.app x
state_after: 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 : SimplexCategory
j : Fin (x.len + 1)
⊢ F.hom ≫ (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) j = G.left ≫ X.hom.app x
tactic: rintro j
state_before: 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 : SimplexCategory
j : Fin (x.len + 1)
⊢ F.hom ≫ (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) j = G.left ≫ X.hom.app x
state_after: 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 : SimplexCategory
j : Fin (x.len + 1)
⊢ G.left ≫ (Augmented.toArrow.obj X).hom ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
tactic: rw [← Arrow.w_assoc G]
state_before: 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 : SimplexCategory
j : Fin (x.len + 1)
⊢ G.left ≫ (Augmented.toArrow.obj X).hom ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
state_after: 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 : SimplexCategory
j : Fin (x.len + 1)
t :
  ((const C).obj X.left).map ((SimplexCategory.mk 0).const x j) ≫ X.hom.app x =
    X.hom.app (SimplexCategory.mk 0) ≫ ((𝟭 (CosimplicialObject C)).obj X.right).map ((SimplexCategory.mk 0).const x j)
⊢ G.left ≫ (Augmented.toArrow.obj X).hom ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
tactic: have t := X.hom.naturality (SimplexCategory.const (SimplexCategory.mk 0) x j)
state_before: 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 : SimplexCategory
j : Fin (x.len + 1)
t :
  ((const C).obj X.left).map ((SimplexCategory.mk 0).const x j) ≫ X.hom.app x =
    X.hom.app (SimplexCategory.mk 0) ≫ ((𝟭 (CosimplicialObject C)).obj X.right).map ((SimplexCategory.mk 0).const x j)
⊢ G.left ≫ (Augmented.toArrow.obj X).hom ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
state_after: 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 : SimplexCategory
j : Fin (x.len + 1)
t : 𝟙 X.left ≫ X.hom.app x = X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j)
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
tactic: dsimp at t ⊢
state_before: 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 : SimplexCategory
j : Fin (x.len + 1)
t : 𝟙 X.left ≫ X.hom.app x = X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j)
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
state_after: 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 : SimplexCategory
j : Fin (x.len + 1)
t : X.hom.app x = X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j)
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
tactic: simp only [Category.id_comp] at t
state_before: 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 : SimplexCategory
j : Fin (x.len + 1)
t : X.hom.app x = X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j)
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) ≫ X.right.map ((SimplexCategory.mk 0).const x j) = G.left ≫ X.hom.app x
state_after: no goals
tactic: rw [← t]
state_before: 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),
    F.augmentedCechConerve.right.map f ≫
        (fun x =>
            WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i))
              ⋯)
          Y =
      (fun x =>
            WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i))
              ⋯)
          X_1 ≫
        X.right.map f
state_after: 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
⊢ F.augmentedCechConerve.right.map f ≫
      (fun x =>
          WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯)
        y =
    (fun x =>
          WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯)
        x ≫
      X.right.map f
tactic: intro x y f
state_before: 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
⊢ F.augmentedCechConerve.right.map f ≫
      (fun x =>
          WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯)
        y =
    (fun x =>
          WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯)
        x ≫
      X.right.map f
state_after: 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)) ⋯ ≫
      WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const y i)) ⋯ =
    WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯ ≫
      X.right.map f
tactic: dsimp
state_before: 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)) ⋯ ≫
      WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const y i)) ⋯ =
    WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯ ≫
      X.right.map f
state_after: 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 (x.len + 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)) ⋯ ≫
        WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const y i)) ⋯ =
    WidePushout.ι (fun x => F.hom) j✝ ≫
      WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯ ≫
        X.right.map f

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)) ⋯ ≫
        WidePushout.desc (G.left ≫ X.hom.app y) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const y i)) ⋯ =
    (WidePushout.head fun x => F.hom) ≫
      WidePushout.desc (G.left ≫ X.hom.app x) (fun i => G.right ≫ X.right.map ((SimplexCategory.mk 0).const x i)) ⋯ ≫
        X.right.map f
tactic: ext