[GOAL]
C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.61, max u v} (SimplicialObject C)
[PROOFSTEP]
dsimp only [SimplicialObject]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.61, max u v} (SimplexCategoryᵒᵖ ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (SimplicialObject C)
[PROOFSTEP]
dsimp [SimplicialObject]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (SimplexCategoryᵒᵖ ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (SimplicialObject C)
[PROOFSTEP]
dsimp [SimplicialObject]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (SimplexCategoryᵒᵖ ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y : SimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategoryᵒᵖ), NatTrans.app f n = NatTrans.app g n
⊢ f.app = g.app
[PROOFSTEP]
ext
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X Y : SimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategoryᵒᵖ), NatTrans.app f n = NatTrans.app g n
x✝ : SimplexCategoryᵒᵖ
⊢ NatTrans.app f x✝ = NatTrans.app g x✝
[PROOFSTEP]
apply h
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n m : ℕ
h : n = m
⊢ op [n] = op [m]
[PROOFSTEP]
congr
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ eqToIso X h = Iso.refl (X.obj (op [n]))
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
h : n = n
⊢ (eqToIso X h).hom = (Iso.refl (X.obj (op [n]))).hom
[PROOFSTEP]
simp [eqToIso]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ δ X (Fin.succ j) ≫ δ X i = δ X (Fin.castSucc i) ≫ δ X j
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ X.map (SimplexCategory.δ (Fin.succ j)).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (Fin.castSucc i)).op ≫ X.map (SimplexCategory.δ j).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
hj : j = 0
⊢ False
[PROOFSTEP]
simp [hj, Fin.not_lt_zero] at H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
⊢ δ X j ≫ δ X i = δ X (Fin.castSucc i) ≫ δ X (Fin.pred j (_ : j = 0 → False))
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
⊢ X.map (SimplexCategory.δ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (Fin.castSucc i)).op ≫ X.map (SimplexCategory.δ (Fin.pred j (_ : j = 0 → False))).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ δ X (Fin.succ j) ≫ δ X (Fin.castLT i (_ : ↑i < n + 2)) = δ X i ≫ δ X j
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ X.map (SimplexCategory.δ (Fin.succ j)).op ≫ X.map (SimplexCategory.δ (Fin.castLT i (_ : ↑i < n + 2))).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.δ j).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ'' H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X (Fin.castSucc i) ≫ δ X i = δ X (Fin.succ i) ≫ δ X i
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ (Fin.castSucc i)).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (Fin.succ i)).op ≫ X.map (SimplexCategory.δ i).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ_self]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
j : Fin (n + 3)
i : Fin (n + 2)
H : j = Fin.castSucc i
⊢ δ X j ≫ δ X i = δ X (Fin.succ i) ≫ δ X i
[PROOFSTEP]
subst H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X (Fin.castSucc i) ≫ δ X i = δ X (Fin.succ i) ≫ δ X i
[PROOFSTEP]
rw [δ_comp_δ_self]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ Fin.castSucc j
⊢ σ X (Fin.succ j) ≫ δ X (Fin.castSucc i) = δ X i ≫ σ X j
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ Fin.castSucc j
⊢ X.map (SimplexCategory.σ (Fin.succ j)).op ≫ X.map (SimplexCategory.δ (Fin.castSucc i)).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_le H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (Fin.castSucc i) = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.σ i).op ≫ X.map (SimplexCategory.δ (Fin.castSucc i)).op = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_self, op_id, X.map_id]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.castSucc i
⊢ σ X i ≫ δ X j = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
subst H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (Fin.castSucc i) = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
rw [δ_comp_σ_self]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (Fin.succ i) = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.σ i).op ≫ X.map (SimplexCategory.δ (Fin.succ i)).op = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_succ, op_id, X.map_id]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.succ i
⊢ σ X i ≫ δ X j = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
subst H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ σ X i ≫ δ X (Fin.succ i) = 𝟙 (X.obj (op [n]))
[PROOFSTEP]
rw [δ_comp_σ_succ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : Fin.castSucc j < i
⊢ σ X (Fin.castSucc j) ≫ δ X (Fin.succ i) = δ X i ≫ σ X j
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : Fin.castSucc j < i
⊢ X.map (SimplexCategory.σ (Fin.castSucc j)).op ≫ X.map (SimplexCategory.δ (Fin.succ i)).op =
    X.map (SimplexCategory.δ i).op ≫ X.map (SimplexCategory.σ j).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
hi : i = 0
⊢ False
[PROOFSTEP]
simp only [Fin.not_lt_zero, hi] at H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
⊢ σ X j ≫ δ X i = δ X (Fin.pred i (_ : i = 0 → False)) ≫ σ X (Fin.castLT j (_ : ↑j < n + 1))
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
⊢ X.map (SimplexCategory.σ j).op ≫ X.map (SimplexCategory.δ i).op =
    X.map (SimplexCategory.δ (Fin.pred i (_ : i = 0 → False))).op ≫
      X.map (SimplexCategory.σ (Fin.castLT j (_ : ↑j < n + 1))).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt' H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ σ X j ≫ σ X (Fin.castSucc i) = σ X i ≫ σ X (Fin.succ j)
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.map (SimplexCategory.σ j).op ≫ X.map (SimplexCategory.σ (Fin.castSucc i)).op =
    X.map (SimplexCategory.σ i).op ≫ X.map (SimplexCategory.σ (Fin.succ j)).op
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.σ_comp_σ H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
⊢ Category.{?u.68325, max u v} (Truncated C n)
[PROOFSTEP]
dsimp [Truncated]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
n : ℕ
⊢ Category.{?u.68325, max u v} ((SimplexCategory.Truncated n)ᵒᵖ ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : SimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (Truncated C n)
[PROOFSTEP]
dsimp [Truncated]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : SimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J ((SimplexCategory.Truncated n)ᵒᵖ ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : SimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (Truncated C n)
[PROOFSTEP]
dsimp [Truncated]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : SimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J ((SimplexCategory.Truncated n)ᵒᵖ ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
⊢ Category.{?u.76503, max u v} (Augmented C)
[PROOFSTEP]
dsimp only [Augmented]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
⊢ Category.{?u.76503, max u v} (Comma (𝟭 (SimplicialObject C)) (const C))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map (NatTrans.app (drop.map η) (op [0])) ≫
      ((fun X => { left := (drop.obj X).obj (op [0]), right := point.obj X, hom := NatTrans.app X.hom (op [0]) })
          Y✝).hom =
    ((fun X => { left := (drop.obj X).obj (op [0]), right := point.obj X, hom := NatTrans.app X.hom (op [0]) })
          X✝).hom ≫
      (𝟭 C).map (point.map η)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ NatTrans.app η.left (op [0]) ≫ NatTrans.app Y✝.hom (op [0]) = NatTrans.app X✝.hom (op [0]) ≫ η.right
[PROOFSTEP]
rw [← NatTrans.comp_app]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ NatTrans.app (η.left ≫ Y✝.hom) (op [0]) = NatTrans.app X✝.hom (op [0]) ≫ η.right
[PROOFSTEP]
erw [η.w]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : SimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ NatTrans.app (X✝.hom ≫ (const C).map η.right) (op [0]) = NatTrans.app X✝.hom (op [0]) ≫ η.right
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ : SimplicialObject C
X Y : Augmented C
f : X ⟶ Y
⊢ NatTrans.app (drop.map f) (op [0]) ≫ NatTrans.app Y.hom (op [0]) = NatTrans.app X.hom (op [0]) ≫ point.map f
[PROOFSTEP]
convert congr_app f.w (op (SimplexCategory.mk 0))
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u_1
inst✝ : Category.{?u.105136, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 (SimplicialObject D)).map (whiskerRight η.left F) ≫
      ((fun X =>
            { left := ((whiskering C D).obj F).obj (drop.obj X), right := F.obj (point.obj X),
              hom := whiskerRight X.hom F ≫ (Functor.constComp SimplexCategoryᵒᵖ X.right F).hom })
          Y✝).hom =
    ((fun X =>
            { left := ((whiskering C D).obj F).obj (drop.obj X), right := F.obj (point.obj X),
              hom := whiskerRight X.hom F ≫ (Functor.constComp SimplexCategoryᵒᵖ X.right F).hom })
          X✝).hom ≫
      (const D).map (F.map η.right)
[PROOFSTEP]
ext
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u_1
inst✝ : Category.{?u.105136, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategoryᵒᵖ
⊢ NatTrans.app
      ((𝟭 (SimplicialObject D)).map (whiskerRight η.left F) ≫
        ((fun X =>
              { left := ((whiskering C D).obj F).obj (drop.obj X), right := F.obj (point.obj X),
                hom := whiskerRight X.hom F ≫ (Functor.constComp SimplexCategoryᵒᵖ X.right F).hom })
            Y✝).hom)
      n✝ =
    NatTrans.app
      (((fun X =>
              { left := ((whiskering C D).obj F).obj (drop.obj X), right := F.obj (point.obj X),
                hom := whiskerRight X.hom F ≫ (Functor.constComp SimplexCategoryᵒᵖ X.right F).hom })
            X✝).hom ≫
        (const D).map (F.map η.right))
      n✝
[PROOFSTEP]
dsimp [whiskerRight]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u_1
inst✝ : Category.{?u.105136, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategoryᵒᵖ
⊢ F.map (NatTrans.app η.left n✝) ≫ F.map (NatTrans.app Y✝.hom n✝) ≫ 𝟙 (F.obj Y✝.right) =
    (F.map (NatTrans.app X✝.hom n✝) ≫ 𝟙 (F.obj X✝.right)) ≫ F.map η.right
[PROOFSTEP]
simp only [Category.comp_id, ← F.map_comp, ← NatTrans.comp_app]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u_1
inst✝ : Category.{?u.105136, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategoryᵒᵖ
⊢ F.map (NatTrans.app (η.left ≫ Y✝.hom) n✝) = F.map (NatTrans.app X✝.hom n✝ ≫ η.right)
[PROOFSTEP]
erw [η.w]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u_1
inst✝ : Category.{?u.105136, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategoryᵒᵖ
⊢ F.map (NatTrans.app (X✝.hom ≫ (const C).map η.right) n✝) = F.map (NatTrans.app X✝.hom n✝ ≫ η.right)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
⊢ (𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom =
    ((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (NatTrans.app η (point.obj A))
[PROOFSTEP]
ext n
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ NatTrans.app ((𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom) n =
    NatTrans.app (((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (NatTrans.app η (point.obj A))) n
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ NatTrans.app η (A.left.obj n) ≫ Y✝.map (NatTrans.app A.hom n) ≫ 𝟙 (Y✝.obj A.right) =
    (X✝.map (NatTrans.app A.hom n) ≫ 𝟙 (X✝.obj A.right)) ≫ NatTrans.app η A.right
[PROOFSTEP]
rw [Category.comp_id, Category.comp_id, η.naturality]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ Z✝ : C ⥤ D
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := whiskeringObj C D,
          map := fun {X Y} η =>
            NatTrans.mk fun A => CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
      (x✝¹ ≫ x✝) =
    { obj := whiskeringObj C D,
            map := fun {X Y} η =>
              NatTrans.mk fun A => CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
        x✝¹ ≫
      { obj := whiskeringObj C D,
            map := fun {X Y} η =>
              NatTrans.mk fun A => CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
        x✝
[PROOFSTEP]
ext
[GOAL]
case w.h.h₁.h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ Z✝ : C ⥤ D
x✝² : X✝ ⟶ Y✝
x✝¹ : Y✝ ⟶ Z✝
x✝ : Augmented C
n✝ : SimplexCategoryᵒᵖ
⊢ NatTrans.app
      (NatTrans.app
          ({ obj := whiskeringObj C D,
                map := fun {X Y} η =>
                  NatTrans.mk fun A =>
                    CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
            (x✝² ≫ x✝¹))
          x✝).left
      n✝ =
    NatTrans.app
      (NatTrans.app
          ({ obj := whiskeringObj C D,
                  map := fun {X Y} η =>
                    NatTrans.mk fun A =>
                      CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
              x✝² ≫
            { obj := whiskeringObj C D,
                  map := fun {X Y} η =>
                    NatTrans.mk fun A =>
                      CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
              x✝¹)
          x✝).left
      n✝
[PROOFSTEP]
rfl
[GOAL]
case w.h.h₂
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ Z✝ : C ⥤ D
x✝² : X✝ ⟶ Y✝
x✝¹ : Y✝ ⟶ Z✝
x✝ : Augmented C
⊢ (NatTrans.app
        ({ obj := whiskeringObj C D,
              map := fun {X Y} η =>
                NatTrans.mk fun A => CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
          (x✝² ≫ x✝¹))
        x✝).right =
    (NatTrans.app
        ({ obj := whiskeringObj C D,
                map := fun {X Y} η =>
                  NatTrans.mk fun A =>
                    CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
            x✝² ≫
          { obj := whiskeringObj C D,
                map := fun {X Y} η =>
                  NatTrans.mk fun A =>
                    CommaMorphism.mk (whiskerLeft (drop.obj A) η) (NatTrans.app η (point.obj A)) }.map
            x✝¹)
        x✝).right
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj (op [0]) ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ ∀ ⦃X_1 Y : SimplexCategoryᵒᵖ⦄ (f_1 : X_1 ⟶ Y),
    ((𝟭 (SimplicialObject C)).obj X).map f_1 ≫ (fun i => X.map (SimplexCategory.const i.unop 0).op ≫ f) Y =
      (fun i => X.map (SimplexCategory.const i.unop 0).op ≫ f) X_1 ≫ ((const C).obj X₀).map f_1
[PROOFSTEP]
intro i j g
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj (op [0]) ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ ((𝟭 (SimplicialObject C)).obj X).map g ≫ (fun i => X.map (SimplexCategory.const i.unop 0).op ≫ f) j =
    (fun i => X.map (SimplexCategory.const i.unop 0).op ≫ f) i ≫ ((const C).obj X₀).map g
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj (op [0]) ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g ≫ X.map (SimplexCategory.const j.unop 0).op ≫ f = (X.map (SimplexCategory.const i.unop 0).op ≫ f) ≫ 𝟙 X₀
[PROOFSTEP]
rw [← g.op_unop]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj (op [0]) ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
i j : SimplexCategoryᵒᵖ
g : i ⟶ j
⊢ X.map g.unop.op ≫ X.map (SimplexCategory.const j.unop 0).op ≫ f =
    (X.map (SimplexCategory.const i.unop 0).op ≫ f) ≫ 𝟙 X₀
[PROOFSTEP]
simpa only [← X.map_comp, ← Category.assoc, Category.comp_id, ← op_comp] using w _ _ _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj (op [0]) ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ NatTrans.app (augment X X₀ f w).hom (op [0]) = f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : SimplicialObject C
X₀ : C
f : X.obj (op [0]) ⟶ X₀
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), X.map g₁.op ≫ f = X.map g₂.op ≫ f
⊢ X.map (SimplexCategory.const [0] 0).op ≫ f = f
[PROOFSTEP]
rw [SimplexCategory.hom_zero_zero ([0].const 0), op_id, X.map_id, Category.id_comp]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.208707, max u v} (CosimplicialObject C)
[PROOFSTEP]
dsimp only [CosimplicialObject]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
⊢ Category.{?u.208707, max u v} (SimplexCategory ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (CosimplicialObject C)
[PROOFSTEP]
dsimp [CosimplicialObject]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (SimplexCategory ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (CosimplicialObject C)
[PROOFSTEP]
dsimp [CosimplicialObject]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (SimplexCategory ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X Y : CosimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategory), NatTrans.app f n = NatTrans.app g n
⊢ f.app = g.app
[PROOFSTEP]
ext
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X Y : CosimplicialObject C
f g : X ⟶ Y
h : ∀ (n : SimplexCategory), NatTrans.app f n = NatTrans.app g n
x✝ : SimplexCategory
⊢ NatTrans.app f x✝ = NatTrans.app g x✝
[PROOFSTEP]
apply h
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n m : ℕ
h : n = m
⊢ [n] = [m]
[PROOFSTEP]
rw [h]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
h : n = n
⊢ eqToIso X h = Iso.refl (X.obj [n])
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
h : n = n
⊢ (eqToIso X h).hom = (Iso.refl (X.obj [n])).hom
[PROOFSTEP]
simp [eqToIso]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ δ X i ≫ δ X (Fin.succ j) = δ X j ≫ δ X (Fin.castSucc i)
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 2)
H : i ≤ j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ (Fin.succ j)) =
    X.map (SimplexCategory.δ j) ≫ X.map (SimplexCategory.δ (Fin.castSucc i))
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.δ_comp_δ H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
hj : j = 0
⊢ False
[PROOFSTEP]
simp only [hj, Fin.not_lt_zero] at H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
⊢ δ X i ≫ δ X j = δ X (Fin.pred j (_ : j = 0 → False)) ≫ δ X (Fin.castSucc i)
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : Fin.castSucc i < j
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ j) =
    X.map (SimplexCategory.δ (Fin.pred j (_ : j = 0 → False))) ≫ X.map (SimplexCategory.δ (Fin.castSucc i))
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ' H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ δ X (Fin.castLT i (_ : ↑i < n + 2)) ≫ δ X (Fin.succ j) = δ X j ≫ δ X i
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : i ≤ Fin.castSucc j
⊢ X.map (SimplexCategory.δ (Fin.castLT i (_ : ↑i < n + 2))) ≫ X.map (SimplexCategory.δ (Fin.succ j)) =
    X.map (SimplexCategory.δ j) ≫ X.map (SimplexCategory.δ i)
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_δ'' H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X i ≫ δ X (Fin.castSucc i) = δ X i ≫ δ X (Fin.succ i)
[PROOFSTEP]
dsimp [δ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ (Fin.castSucc i)) =
    X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.δ (Fin.succ i))
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.δ_comp_δ_self]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 3)
H : j = Fin.castSucc i
⊢ δ X i ≫ δ X j = δ X i ≫ δ X (Fin.succ i)
[PROOFSTEP]
subst H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
⊢ δ X i ≫ δ X (Fin.castSucc i) = δ X i ≫ δ X (Fin.succ i)
[PROOFSTEP]
rw [δ_comp_δ_self]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ Fin.castSucc j
⊢ δ X (Fin.castSucc i) ≫ σ X (Fin.succ j) = σ X j ≫ δ X i
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : i ≤ Fin.castSucc j
⊢ X.map (SimplexCategory.δ (Fin.castSucc i)) ≫ X.map (SimplexCategory.σ (Fin.succ j)) =
    X.map (SimplexCategory.σ j) ≫ X.map (SimplexCategory.δ i)
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.δ_comp_σ_of_le H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (Fin.castSucc i) ≫ σ X i = 𝟙 (X.obj [n])
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.δ (Fin.castSucc i)) ≫ X.map (SimplexCategory.σ i) = 𝟙 (X.obj [n])
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.δ_comp_σ_self, X.map_id]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.castSucc i
⊢ δ X j ≫ σ X i = 𝟙 (X.obj [n])
[PROOFSTEP]
subst H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (Fin.castSucc i) ≫ σ X i = 𝟙 (X.obj [n])
[PROOFSTEP]
rw [δ_comp_σ_self]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (Fin.succ i) ≫ σ X i = 𝟙 (X.obj [n])
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ X.map (SimplexCategory.δ (Fin.succ i)) ≫ X.map (SimplexCategory.σ i) = 𝟙 (X.obj [n])
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.δ_comp_σ_succ, X.map_id]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
j : Fin (n + 2)
i : Fin (n + 1)
H : j = Fin.succ i
⊢ δ X j ≫ σ X i = 𝟙 (X.obj [n])
[PROOFSTEP]
subst H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 1)
⊢ δ X (Fin.succ i) ≫ σ X i = 𝟙 (X.obj [n])
[PROOFSTEP]
rw [δ_comp_σ_succ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : Fin.castSucc j < i
⊢ δ X (Fin.succ i) ≫ σ X (Fin.castSucc j) = σ X j ≫ δ X i
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 2)
j : Fin (n + 1)
H : Fin.castSucc j < i
⊢ X.map (SimplexCategory.δ (Fin.succ i)) ≫ X.map (SimplexCategory.σ (Fin.castSucc j)) =
    X.map (SimplexCategory.σ j) ≫ X.map (SimplexCategory.δ i)
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.δ_comp_σ_of_gt H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
hi : i = 0
⊢ False
[PROOFSTEP]
simp only [Fin.not_lt_zero, hi] at H
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
⊢ δ X i ≫ σ X j = σ X (Fin.castLT j (_ : ↑j < n + 1)) ≫ δ X (Fin.pred i (_ : i = 0 → False))
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i : Fin (n + 3)
j : Fin (n + 2)
H : Fin.succ j < i
⊢ X.map (SimplexCategory.δ i) ≫ X.map (SimplexCategory.σ j) =
    X.map (SimplexCategory.σ (Fin.castLT j (_ : ↑j < n + 1))) ≫
      X.map (SimplexCategory.δ (Fin.pred i (_ : i = 0 → False)))
[PROOFSTEP]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_gt' H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ σ X (Fin.castSucc i) ≫ σ X j = σ X (Fin.succ j) ≫ σ X i
[PROOFSTEP]
dsimp [δ, σ]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
i j : Fin (n + 1)
H : i ≤ j
⊢ X.map (SimplexCategory.σ (Fin.castSucc i)) ≫ X.map (SimplexCategory.σ j) =
    X.map (SimplexCategory.σ (Fin.succ j)) ≫ X.map (SimplexCategory.σ i)
[PROOFSTEP]
simp only [← X.map_comp, SimplexCategory.σ_comp_σ H]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
⊢ Category.{?u.295628, max u v} (Truncated C n)
[PROOFSTEP]
dsimp [Truncated]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
⊢ Category.{?u.295628, max u v} (SimplexCategory.Truncated n ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (Truncated C n)
[PROOFSTEP]
dsimp [Truncated]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasLimitsOfShape J C
⊢ HasLimitsOfShape J (SimplexCategory.Truncated n ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (Truncated C n)
[PROOFSTEP]
dsimp [Truncated]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
X : CosimplicialObject C
n : ℕ
J : Type v
inst✝¹ : SmallCategory J
inst✝ : HasColimitsOfShape J C
⊢ HasColimitsOfShape J (SimplexCategory.Truncated n ⥤ C)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.303800, max u v} (Augmented C)
[PROOFSTEP]
dsimp only [Augmented]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
⊢ Category.{?u.303800, max u v} (Comma (const C) (𝟭 (CosimplicialObject C)))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map (point.map η) ≫
      ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := NatTrans.app X.hom [0] }) Y✝).hom =
    ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := NatTrans.app X.hom [0] }) X✝).hom ≫
      (𝟭 C).map (NatTrans.app (drop.map η) [0])
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ NatTrans.app Y✝.hom [0] = NatTrans.app X✝.hom [0] ≫ NatTrans.app η.right [0]
[PROOFSTEP]
rw [← NatTrans.comp_app]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ NatTrans.app Y✝.hom [0] = NatTrans.app (X✝.hom ≫ η.right) [0]
[PROOFSTEP]
erw [← η.w]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ NatTrans.app Y✝.hom [0] = NatTrans.app ((const C).map η.left ≫ Y✝.hom) [0]
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u_1
inst✝ : Category.{?u.334362, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (const D).map (F.map η.left) ≫
      ((fun X =>
            { left := F.obj (point.obj X), right := ((whiskering C D).obj F).obj (drop.obj X),
              hom := (Functor.constComp SimplexCategory (point.obj X) F).inv ≫ whiskerRight X.hom F })
          Y✝).hom =
    ((fun X =>
            { left := F.obj (point.obj X), right := ((whiskering C D).obj F).obj (drop.obj X),
              hom := (Functor.constComp SimplexCategory (point.obj X) F).inv ≫ whiskerRight X.hom F })
          X✝).hom ≫
      (𝟭 (CosimplicialObject D)).map (whiskerRight η.right F)
[PROOFSTEP]
ext
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u_1
inst✝ : Category.{?u.334362, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategory
⊢ NatTrans.app
      ((const D).map (F.map η.left) ≫
        ((fun X =>
              { left := F.obj (point.obj X), right := ((whiskering C D).obj F).obj (drop.obj X),
                hom := (Functor.constComp SimplexCategory (point.obj X) F).inv ≫ whiskerRight X.hom F })
            Y✝).hom)
      n✝ =
    NatTrans.app
      (((fun X =>
              { left := F.obj (point.obj X), right := ((whiskering C D).obj F).obj (drop.obj X),
                hom := (Functor.constComp SimplexCategory (point.obj X) F).inv ≫ whiskerRight X.hom F })
            X✝).hom ≫
        (𝟭 (CosimplicialObject D)).map (whiskerRight η.right F))
      n✝
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u_1
inst✝ : Category.{?u.334362, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategory
⊢ F.map η.left ≫ 𝟙 (F.obj Y✝.left) ≫ F.map (NatTrans.app Y✝.hom n✝) =
    (𝟙 (F.obj X✝.left) ≫ F.map (NatTrans.app X✝.hom n✝)) ≫ F.map (NatTrans.app η.right n✝)
[PROOFSTEP]
rw [Category.id_comp, Category.id_comp, ← F.map_comp, ← F.map_comp, ← NatTrans.comp_app]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u_1
inst✝ : Category.{?u.334362, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategory
⊢ F.map (η.left ≫ NatTrans.app Y✝.hom n✝) = F.map (NatTrans.app (X✝.hom ≫ η.right) n✝)
[PROOFSTEP]
erw [← η.w]
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u_1
inst✝ : Category.{?u.334362, u_1} D
F : C ⥤ D
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
n✝ : SimplexCategory
⊢ F.map (η.left ≫ NatTrans.app Y✝.hom n✝) = F.map (NatTrans.app ((const C).map η.left ≫ Y✝.hom) n✝)
[PROOFSTEP]
rfl
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
⊢ (const D).map (NatTrans.app η (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom =
    ((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)
[PROOFSTEP]
ext n
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ NatTrans.app ((const D).map (NatTrans.app η (point.obj A)) ≫ ((whiskeringObj C D Y✝).obj A).hom) n =
    NatTrans.app (((whiskeringObj C D X✝).obj A).hom ≫ (𝟭 (CosimplicialObject D)).map (whiskerLeft (drop.obj A) η)) n
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategory
⊢ NatTrans.app η A.left ≫ 𝟙 (Y✝.obj A.left) ≫ Y✝.map (NatTrans.app A.hom n) =
    (𝟙 (X✝.obj A.left) ≫ X✝.map (NatTrans.app A.hom n)) ≫ NatTrans.app η (A.right.obj n)
[PROOFSTEP]
rw [Category.id_comp, Category.id_comp, η.naturality]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
⊢ (whiskeringObj C D X✝).map f ≫
      (fun A => CommaMorphism.mk (NatTrans.app η (point.obj A)) (whiskerLeft (drop.obj A) η)) x✝ =
    (fun A => CommaMorphism.mk (NatTrans.app η (point.obj A)) (whiskerLeft (drop.obj A) η)) x✝¹ ≫
      (whiskeringObj C D Y✝).map f
[PROOFSTEP]
ext
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
⊢ ((whiskeringObj C D X✝).map f ≫
        (fun A => CommaMorphism.mk (NatTrans.app η (point.obj A)) (whiskerLeft (drop.obj A) η)) x✝).left =
    ((fun A => CommaMorphism.mk (NatTrans.app η (point.obj A)) (whiskerLeft (drop.obj A) η)) x✝¹ ≫
        (whiskeringObj C D Y✝).map f).left
[PROOFSTEP]
dsimp
[GOAL]
case h₂.h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
n✝ : SimplexCategory
⊢ NatTrans.app
      ((whiskeringObj C D X✝).map f ≫
          (fun A => CommaMorphism.mk (NatTrans.app η (point.obj A)) (whiskerLeft (drop.obj A) η)) x✝).right
      n✝ =
    NatTrans.app
      ((fun A => CommaMorphism.mk (NatTrans.app η (point.obj A)) (whiskerLeft (drop.obj A) η)) x✝¹ ≫
          (whiskeringObj C D Y✝).map f).right
      n✝
[PROOFSTEP]
dsimp
[GOAL]
case h₁
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
⊢ X✝.map f.left ≫ NatTrans.app η x✝.left = NatTrans.app η x✝¹.left ≫ Y✝.map f.left
[PROOFSTEP]
simp
[GOAL]
case h₂.h
C : Type u
inst✝¹ : Category.{v, u} C
X : CosimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
x✝¹ x✝ : Augmented C
f : x✝¹ ⟶ x✝
n✝ : SimplexCategory
⊢ X✝.map (NatTrans.app f.right n✝) ≫ NatTrans.app η (x✝.right.obj n✝) =
    NatTrans.app η (x✝¹.right.obj n✝) ≫ Y✝.map (NatTrans.app f.right n✝)
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
⊢ ∀ ⦃X_1 Y : SimplexCategory⦄ (f_1 : X_1 ⟶ Y),
    ((const C).obj X₀).map f_1 ≫ (fun i => f ≫ X.map (SimplexCategory.const i 0)) Y =
      (fun i => f ≫ X.map (SimplexCategory.const i 0)) X_1 ≫ ((𝟭 (CosimplicialObject C)).obj X).map f_1
[PROOFSTEP]
intro i j g
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
i j : SimplexCategory
g : i ⟶ j
⊢ ((const C).obj X₀).map g ≫ (fun i => f ≫ X.map (SimplexCategory.const i 0)) j =
    (fun i => f ≫ X.map (SimplexCategory.const i 0)) i ≫ ((𝟭 (CosimplicialObject C)).obj X).map g
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
i j : SimplexCategory
g : i ⟶ j
⊢ 𝟙 X₀ ≫ f ≫ X.map (SimplexCategory.const j 0) = (f ≫ X.map (SimplexCategory.const i 0)) ≫ X.map g
[PROOFSTEP]
simpa [← X.map_comp] using w _ _ _
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
⊢ NatTrans.app (augment X X₀ f w).hom [0] = f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ X : CosimplicialObject C
X₀ : C
f : X₀ ⟶ X.obj [0]
w : ∀ (i : SimplexCategory) (g₁ g₂ : [0] ⟶ i), f ≫ X.map g₁ = f ≫ X.map g₂
⊢ f ≫ X.map (SimplexCategory.const [0] 0) = f
[PROOFSTEP]
rw [SimplexCategory.hom_zero_zero ([0].const 0), X.map_id, Category.comp_id]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : Augmented C
⊢ (CosimplicialObject.Augmented.leftOp (rightOp X)).right = X.right
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X : Augmented Cᵒᵖ
⊢ (SimplicialObject.Augmented.rightOp (leftOp X)).left = X.left
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫ ((fun X => SimplicialObject.Augmented.rightOp X.unop) Y✝).hom =
    ((fun X => SimplicialObject.Augmented.rightOp X.unop) X✝).hom ≫
      (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left)
[PROOFSTEP]
ext x
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ NatTrans.app
      ((CosimplicialObject.const Cᵒᵖ).map f.unop.right.op ≫
        ((fun X => SimplicialObject.Augmented.rightOp X.unop) Y✝).hom)
      x =
    NatTrans.app
      (((fun X => SimplicialObject.Augmented.rightOp X.unop) X✝).hom ≫
        (𝟭 (CosimplicialObject Cᵒᵖ)).map (NatTrans.rightOp f.unop.left))
      x
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ f.unop.right.op ≫ (NatTrans.app Y✝.unop.hom (op x)).op =
    (NatTrans.app X✝.unop.hom (op x)).op ≫ (NatTrans.app f.unop.left (op x)).op
[PROOFSTEP]
simp_rw [← op_comp]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ (NatTrans.app Y✝.unop.hom (op x) ≫ f.unop.right).op =
    (NatTrans.app f.unop.left (op x) ≫ NatTrans.app X✝.unop.hom (op x)).op
[PROOFSTEP]
congr 1
[GOAL]
case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategory
⊢ NatTrans.app Y✝.unop.hom (op x) ≫ f.unop.right = NatTrans.app f.unop.left (op x) ≫ NatTrans.app X✝.unop.hom (op x)
[PROOFSTEP]
exact (congr_app f.unop.w (op x)).symm
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟭 (SimplicialObject C)).map (NatTrans.leftOp f.right) ≫ (CosimplicialObject.Augmented.leftOp X✝).hom =
    (CosimplicialObject.Augmented.leftOp Y✝).hom ≫ (SimplicialObject.const C).map f.left.unop
[PROOFSTEP]
ext x
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ NatTrans.app ((𝟭 (SimplicialObject C)).map (NatTrans.leftOp f.right) ≫ (CosimplicialObject.Augmented.leftOp X✝).hom)
      x =
    NatTrans.app ((CosimplicialObject.Augmented.leftOp Y✝).hom ≫ (SimplicialObject.const C).map f.left.unop) x
[PROOFSTEP]
dsimp
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ (NatTrans.app f.right x.unop).unop ≫ (NatTrans.app X✝.hom x.unop).unop =
    (NatTrans.app Y✝.hom x.unop).unop ≫ f.left.unop
[PROOFSTEP]
simp_rw [← unop_comp]
[GOAL]
case h
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ (NatTrans.app X✝.hom x.unop ≫ NatTrans.app f.right x.unop).unop = (f.left ≫ NatTrans.app Y✝.hom x.unop).unop
[PROOFSTEP]
congr 1
[GOAL]
case h.e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : CosimplicialObject.Augmented Cᵒᵖ
f : X✝ ⟶ Y✝
x : SimplexCategoryᵒᵖ
⊢ NatTrans.app X✝.hom x.unop ≫ NatTrans.app f.right x.unop = f.left ≫ NatTrans.app Y✝.hom x.unop
[PROOFSTEP]
exact (congr_app f.w (unop x)).symm
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟭 (SimplicialObject.Augmented C)ᵒᵖ).map f ≫
      ((fun X => Iso.op (SimplicialObject.Augmented.rightOpLeftOpIso X.unop)) Y✝).hom =
    ((fun X => Iso.op (SimplicialObject.Augmented.rightOpLeftOpIso X.unop)) X✝).hom ≫
      (simplicialToCosimplicialAugmented C ⋙ cosimplicialToSimplicialAugmented C).map f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ f ≫ (SimplicialObject.Augmented.rightOpLeftOpIso Y✝.unop).hom.op =
    (SimplicialObject.Augmented.rightOpLeftOpIso X✝.unop).hom.op ≫
      (CommaMorphism.mk (NatTrans.leftOp (NatTrans.rightOp f.unop.left)) f.unop.right).op
[PROOFSTEP]
rw [← f.op_unop]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ f.unop.op ≫ (SimplicialObject.Augmented.rightOpLeftOpIso Y✝.unop).hom.op =
    (SimplicialObject.Augmented.rightOpLeftOpIso X✝.unop).hom.op ≫
      (CommaMorphism.mk (NatTrans.leftOp (NatTrans.rightOp f.unop.op.unop.left)) f.unop.op.unop.right).op
[PROOFSTEP]
simp_rw [← op_comp]
[GOAL]
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ ((SimplicialObject.Augmented.rightOpLeftOpIso Y✝.unop).hom ≫ f.unop).op =
    (CommaMorphism.mk (NatTrans.leftOp (NatTrans.rightOp f.unop.op.unop.left)) f.unop.op.unop.right ≫
        (SimplicialObject.Augmented.rightOpLeftOpIso X✝.unop).hom).op
[PROOFSTEP]
congr 1
[GOAL]
case e_f
C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : (SimplicialObject.Augmented C)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (SimplicialObject.Augmented.rightOpLeftOpIso Y✝.unop).hom ≫ f.unop =
    CommaMorphism.mk (NatTrans.leftOp (NatTrans.rightOp f.unop.op.unop.left)) f.unop.op.unop.right ≫
      (SimplicialObject.Augmented.rightOpLeftOpIso X✝.unop).hom
[PROOFSTEP]
aesop_cat


[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
x : Option α
⊢ Option.traverse pure x = x
[PROOFSTEP]
cases x
[GOAL]
case none
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
⊢ Option.traverse pure none = none
[PROOFSTEP]
rfl
[GOAL]
case some
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
val✝ : α
⊢ Option.traverse pure (some val✝) = some val✝
[PROOFSTEP]
rfl
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
x : Option α
⊢ Option.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) x = Comp.mk (Option.traverse f <$> Option.traverse g x)
[PROOFSTEP]
cases x
[GOAL]
case none
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
⊢ Option.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) none =
    Comp.mk (Option.traverse f <$> Option.traverse g none)
[PROOFSTEP]
simp! [functor_norm]
[GOAL]
case some
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
val✝ : α
⊢ Option.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) (some val✝) =
    Comp.mk (Option.traverse f <$> Option.traverse g (some val✝))
[PROOFSTEP]
simp! [functor_norm]
[GOAL]
case none
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
⊢ pure none = Comp.mk (pure (pure none))
[PROOFSTEP]
rfl
[GOAL]
case some
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
val✝ : α
⊢ Comp.mk (((fun x => some <$> x) ∘ f) <$> g val✝) = Comp.mk ((Option.traverse f ∘ some) <$> g val✝)
[PROOFSTEP]
rfl
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
x : Option α
⊢ Option.traverse (pure ∘ f) x = pure (f <$> x)
[PROOFSTEP]
cases x
[GOAL]
case none
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
⊢ Option.traverse (pure ∘ f) none = pure (f <$> none)
[PROOFSTEP]
rfl
[GOAL]
case some
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
val✝ : α
⊢ Option.traverse (pure ∘ f) (some val✝) = pure (f <$> some val✝)
[PROOFSTEP]
rfl
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
x : Option α
⊢ (fun {α} => ApplicativeTransformation.app η α) (Option.traverse f x) =
    Option.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) x
[PROOFSTEP]
cases' x with x
[GOAL]
case none
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
⊢ (fun {α} => ApplicativeTransformation.app η α) (Option.traverse f none) =
    Option.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) none
[PROOFSTEP]
simp! [*, functor_norm, ApplicativeTransformation.preserves_map, ApplicativeTransformation.preserves_seq,
  ApplicativeTransformation.preserves_pure]
[GOAL]
case some
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
x : α
⊢ (fun {α} => ApplicativeTransformation.app η α) (Option.traverse f (some x)) =
    Option.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) (some x)
[PROOFSTEP]
simp! [*, functor_norm, ApplicativeTransformation.preserves_map, ApplicativeTransformation.preserves_seq,
  ApplicativeTransformation.preserves_pure]
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
xs : List α
⊢ List.traverse pure xs = xs
[PROOFSTEP]
induction xs
[GOAL]
case nil
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
⊢ List.traverse pure [] = []
[PROOFSTEP]
simp! [*, List.traverse, functor_norm]
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse pure tail✝ = tail✝
⊢ List.traverse pure (head✝ :: tail✝) = head✝ :: tail✝
[PROOFSTEP]
simp! [*, List.traverse, functor_norm]
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse pure tail✝ = tail✝
⊢ (Seq.seq (cons head✝) fun x => tail✝) = head✝ :: tail✝
[PROOFSTEP]
rfl
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
x : List α
⊢ List.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) x = Comp.mk (List.traverse f <$> List.traverse g x)
[PROOFSTEP]
induction x
[GOAL]
case nil
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
⊢ List.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) [] = Comp.mk (List.traverse f <$> List.traverse g [])
[PROOFSTEP]
simp! [*, functor_norm]
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
head✝ : α
tail✝ : List α
tail_ih✝ :
  List.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) tail✝ = Comp.mk (List.traverse f <$> List.traverse g tail✝)
⊢ List.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) (head✝ :: tail✝) =
    Comp.mk (List.traverse f <$> List.traverse g (head✝ :: tail✝))
[PROOFSTEP]
simp! [*, functor_norm]
[GOAL]
case nil
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
⊢ pure [] = Comp.mk (pure (pure []))
[PROOFSTEP]
rfl
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
f : β → F γ
g : α → G β
head✝ : α
tail✝ : List α
tail_ih✝ :
  List.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) tail✝ = Comp.mk (List.traverse f <$> List.traverse g tail✝)
⊢ Comp.mk
      (Seq.seq
        (((fun x => x ∘ List.traverse f) ∘ (fun x x_1 => Seq.seq x fun x => x_1) ∘ (fun x => cons <$> x) ∘ f) <$>
          g head✝)
        fun x => List.traverse g tail✝) =
    Comp.mk (Seq.seq (((fun x => List.traverse f ∘ x) ∘ cons) <$> g head✝) fun x => List.traverse g tail✝)
[PROOFSTEP]
rfl
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
x : List α
⊢ List.traverse (pure ∘ f) x = pure (f <$> x)
[PROOFSTEP]
induction x
[GOAL]
case nil
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
⊢ List.traverse (pure ∘ f) [] = pure (f <$> [])
[PROOFSTEP]
simp! [*, functor_norm]
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse (pure ∘ f) tail✝ = pure (f <$> tail✝)
⊢ List.traverse (pure ∘ f) (head✝ :: tail✝) = pure (f <$> (head✝ :: tail✝))
[PROOFSTEP]
simp! [*, functor_norm]
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u_1
f : α → β
head✝ : α
tail✝ : List α
tail_ih✝ : List.traverse (pure ∘ f) tail✝ = pure (f <$> tail✝)
⊢ (Seq.seq (cons (f head✝)) fun x => map f tail✝) = f head✝ :: map f tail✝
[PROOFSTEP]
rfl
[GOAL]
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
x : List α
⊢ (fun {α} => ApplicativeTransformation.app η α) (List.traverse f x) =
    List.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) x
[PROOFSTEP]
induction x
[GOAL]
case nil
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
⊢ (fun {α} => ApplicativeTransformation.app η α) (List.traverse f []) =
    List.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) []
[PROOFSTEP]
simp! [*, functor_norm, ApplicativeTransformation.preserves_map, ApplicativeTransformation.preserves_seq,
  ApplicativeTransformation.preserves_pure]
[GOAL]
case cons
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
head✝ : α
tail✝ : List α
tail_ih✝ :
  (fun {α} => ApplicativeTransformation.app η α) (List.traverse f tail✝) =
    List.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) tail✝
⊢ (fun {α} => ApplicativeTransformation.app η α) (List.traverse f (head✝ :: tail✝)) =
    List.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) (head✝ :: tail✝)
[PROOFSTEP]
simp! [*, functor_norm, ApplicativeTransformation.preserves_map, ApplicativeTransformation.preserves_seq,
  ApplicativeTransformation.preserves_pure]
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f : α' → F β'
inst✝ : LawfulApplicative F
bs : List α'
⊢ traverse f ([] ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f []) fun x => traverse f bs
[PROOFSTEP]
simp [functor_norm]
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f : α' → F β'
inst✝ : LawfulApplicative F
a : α'
as bs : List α'
⊢ traverse f (a :: as ++ bs) = Seq.seq ((fun x x_1 => x ++ x_1) <$> traverse f (a :: as)) fun x => traverse f bs
[PROOFSTEP]
simp [traverse_append as bs, functor_norm]
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f : α' → F β'
inst✝ : LawfulApplicative F
a : α'
as bs : List α'
⊢ (Seq.seq
      (Seq.seq (((fun x => x ∘ fun x x_1 => x ++ x_1) ∘ Function.comp ∘ fun x x_1 => x :: x_1) <$> f a) fun x =>
        traverse f as)
      fun x => traverse f bs) =
    Seq.seq (Seq.seq (((fun x => (fun x x_1 => x ++ x_1) ∘ x) ∘ fun x x_1 => x :: x_1) <$> f a) fun x => traverse f as)
      fun x => traverse f bs
[PROOFSTEP]
congr
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
⊢ [] ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) [] []
[PROOFSTEP]
simp
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
⊢ [] ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) [] (a :: as)
[PROOFSTEP]
simp
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f [] ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) []
[PROOFSTEP]
simp
[GOAL]
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
α' β' : Type u
f✝ : α' → F β'
inst✝ : LawfulApplicative F
f : α' → Set β'
a : α'
as : List α'
b : β'
bs : List β'
⊢ b :: bs ∈ traverse f (a :: as) ↔ Forall₂ (fun b a => b ∈ f a) (b :: bs) (a :: as)
[PROOFSTEP]
simp [mem_traverse as bs]
[GOAL]
σ : Type u
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β γ : Type u
g : α → β
f : β → G γ
x : σ ⊕ α
⊢ Sum.traverse f (g <$> x) = Sum.traverse (f ∘ g) x
[PROOFSTEP]
cases x
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β γ : Type u
g : α → β
f : β → G γ
val✝ : σ
⊢ Sum.traverse f (g <$> inl val✝) = Sum.traverse (f ∘ g) (inl val✝)
[PROOFSTEP]
simp [Sum.traverse, id_map, functor_norm]
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β γ : Type u
g : α → β
f : β → G γ
val✝ : α
⊢ Sum.traverse f (g <$> inr val✝) = Sum.traverse (f ∘ g) (inr val✝)
[PROOFSTEP]
simp [Sum.traverse, id_map, functor_norm]
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β γ : Type u
g : α → β
f : β → G γ
val✝ : σ
⊢ (match g <$> inl val✝ with
    | inl x => pure (inl x)
    | inr x => inr <$> f x) =
    pure (inl val✝)
[PROOFSTEP]
rfl
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝¹ : Applicative F
inst✝ : Applicative G
α β γ : Type u
g : α → β
f : β → G γ
val✝ : α
⊢ (match g <$> inr val✝ with
    | inl x => pure (inl x)
    | inr x => inr <$> f x) =
    inr <$> f (g val✝)
[PROOFSTEP]
rfl
[GOAL]
σ✝ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
σ α : Type u_1
x : σ ⊕ α
⊢ Sum.traverse pure x = x
[PROOFSTEP]
cases x
[GOAL]
case inl
σ✝ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
σ α : Type u_1
val✝ : σ
⊢ Sum.traverse pure (inl val✝) = inl val✝
[PROOFSTEP]
rfl
[GOAL]
case inr
σ✝ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
σ α : Type u_1
val✝ : α
⊢ Sum.traverse pure (inr val✝) = inr val✝
[PROOFSTEP]
rfl
[GOAL]
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
x : σ ⊕ α
⊢ Sum.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) x = Comp.mk (Sum.traverse f <$> Sum.traverse g x)
[PROOFSTEP]
cases x
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
val✝ : σ
⊢ Sum.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) (inl val✝) =
    Comp.mk (Sum.traverse f <$> Sum.traverse g (inl val✝))
[PROOFSTEP]
simp! [Sum.traverse, map_id, functor_norm]
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
val✝ : α
⊢ Sum.traverse (Comp.mk ∘ (fun x x_1 => x <$> x_1) f ∘ g) (inr val✝) =
    Comp.mk (Sum.traverse f <$> Sum.traverse g (inr val✝))
[PROOFSTEP]
simp! [Sum.traverse, map_id, functor_norm]
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
val✝ : σ
⊢ pure (inl val✝) = Comp.mk (pure (pure (inl val✝)))
[PROOFSTEP]
rfl
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β γ : Type u
f : β → F γ
g : α → G β
val✝ : α
⊢ Comp.mk (((fun x => inr <$> x) ∘ f) <$> g val✝) = Comp.mk ((Sum.traverse f ∘ inr) <$> g val✝)
[PROOFSTEP]
rfl
[GOAL]
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u
f : α → β
x : σ ⊕ α
⊢ Sum.traverse (pure ∘ f) x = pure (f <$> x)
[PROOFSTEP]
induction x
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u
f : α → β
val✝ : σ
⊢ Sum.traverse (pure ∘ f) (inl val✝) = pure (f <$> inl val✝)
[PROOFSTEP]
simp! [*, functor_norm]
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u
f : α → β
val✝ : α
⊢ Sum.traverse (pure ∘ f) (inr val✝) = pure (f <$> inr val✝)
[PROOFSTEP]
simp! [*, functor_norm]
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u
f : α → β
val✝ : σ
⊢ inl val✝ = f <$> inl val✝
[PROOFSTEP]
rfl
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α β : Type u
f : α → β
val✝ : α
⊢ inr (f val✝) = f <$> inr val✝
[PROOFSTEP]
rfl
[GOAL]
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
g : α → G β
f : β → γ
x : σ ⊕ α
⊢ (fun x x_1 => x <$> x_1) f <$> Sum.traverse g x = Sum.traverse ((fun x x_1 => x <$> x_1) f ∘ g) x
[PROOFSTEP]
cases x
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
g : α → G β
f : β → γ
val✝ : σ
⊢ (fun x x_1 => x <$> x_1) f <$> Sum.traverse g (inl val✝) = Sum.traverse ((fun x x_1 => x <$> x_1) f ∘ g) (inl val✝)
[PROOFSTEP]
simp [Sum.traverse, id_map, functor_norm]
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
g : α → G β
f : β → γ
val✝ : α
⊢ (fun x x_1 => x <$> x_1) f <$> Sum.traverse g (inr val✝) = Sum.traverse ((fun x x_1 => x <$> x_1) f ∘ g) (inr val✝)
[PROOFSTEP]
simp [Sum.traverse, id_map, functor_norm]
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
g : α → G β
f : β → γ
val✝ : σ
⊢ pure (f <$> inl val✝) = pure (inl val✝)
[PROOFSTEP]
congr
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α : Type u_1
β γ : Type u
g : α → G β
f : β → γ
val✝ : α
⊢ ((fun x => f <$> x) ∘ inr) <$> g val✝ = (inr ∘ f) <$> g val✝
[PROOFSTEP]
congr
[GOAL]
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
x : σ ⊕ α
⊢ (fun {α} => ApplicativeTransformation.app η α) (Sum.traverse f x) =
    Sum.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) x
[PROOFSTEP]
cases x
[GOAL]
case inl
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
val✝ : σ
⊢ (fun {α} => ApplicativeTransformation.app η α) (Sum.traverse f (inl val✝)) =
    Sum.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) (inl val✝)
[PROOFSTEP]
simp! [Sum.traverse, functor_norm, ApplicativeTransformation.preserves_map, ApplicativeTransformation.preserves_seq,
  ApplicativeTransformation.preserves_pure]
[GOAL]
case inr
σ : Type u
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α : Type u_1
β : Type u
f : α → F β
val✝ : α
⊢ (fun {α} => ApplicativeTransformation.app η α) (Sum.traverse f (inr val✝)) =
    Sum.traverse ((fun {α} => ApplicativeTransformation.app η α) ∘ f) (inr val✝)
[PROOFSTEP]
simp! [Sum.traverse, functor_norm, ApplicativeTransformation.preserves_map, ApplicativeTransformation.preserves_seq,
  ApplicativeTransformation.preserves_pure]


[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
⊢ (X Y : Discrete PEmpty) → Zero (X ⟶ Y)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X Y : Discrete PUnit
⊢ Zero (X ⟶ Y)
[PROOFSTEP]
repeat (constructor)
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X Y : Discrete PUnit
⊢ Zero (X ⟶ Y)
[PROOFSTEP]
constructor
[GOAL]
case zero
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X Y : Discrete PUnit
⊢ X ⟶ Y
[PROOFSTEP]
constructor
[GOAL]
case zero.down
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X Y : Discrete PUnit
⊢ PLift (X.as = Y.as)
[PROOFSTEP]
constructor
[GOAL]
case zero.down.down
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X Y : Discrete PUnit
⊢ X.as = Y.as
[PROOFSTEP]
constructor
[GOAL]

[PROOFSTEP]
constructor
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
⊢ I = J
[PROOFSTEP]
have : I.Zero = J.Zero := by
  funext X Y
  specialize w X Y
  apply congrArg Zero.mk w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
⊢ Zero = Zero
[PROOFSTEP]
funext X Y
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
X Y : C
⊢ Zero X Y = Zero X Y
[PROOFSTEP]
specialize w X Y
[GOAL]
case h.h
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
w : Zero.zero = Zero.zero
⊢ Zero X Y = Zero X Y
[PROOFSTEP]
apply congrArg Zero.mk w
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ I = J
[PROOFSTEP]
cases I
[GOAL]
case mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
J : HasZeroMorphisms C
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ mk = J
[PROOFSTEP]
cases J
[GOAL]
case mk.mk
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
Zero✝¹ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝¹ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝¹ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ mk = mk
[PROOFSTEP]
congr
[GOAL]
case mk.mk.h.e_4
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
Zero✝¹ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝¹ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝¹ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ HEq comp_zero✝¹ comp_zero✝
[PROOFSTEP]
apply proof_irrel_heq
[GOAL]
case mk.mk.h.e_5
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
Zero✝¹ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝¹ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝¹ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
Zero✝ : (X Y : C) → _root_.Zero (X ⟶ Y)
comp_zero✝ : ∀ {X Y : C} (f : X ⟶ Y) (Z : C), f ≫ 0 = 0
zero_comp✝ : ∀ (X : C) {Y Z : C} (f : Y ⟶ Z), 0 ≫ f = 0
w : ∀ (X Y : C), Zero.zero = Zero.zero
this : Zero = Zero
⊢ HEq zero_comp✝¹ zero_comp✝
[PROOFSTEP]
apply proof_irrel_heq
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
⊢ I = J
[PROOFSTEP]
apply ext_aux
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
⊢ ∀ (X Y : C), Zero.zero = Zero.zero
[PROOFSTEP]
intro X Y
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
⊢ Zero.zero = Zero.zero
[PROOFSTEP]
have : (I.Zero X Y).zero ≫ (J.Zero Y Y).zero = (I.Zero X Y).zero := by apply I.zero_comp X (J.Zero Y Y).zero
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
⊢ Zero.zero ≫ Zero.zero = Zero.zero
[PROOFSTEP]
apply I.zero_comp X (J.Zero Y Y).zero
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero = Zero.zero
[PROOFSTEP]
have that : (I.Zero X Y).zero ≫ (J.Zero Y Y).zero = (J.Zero X Y).zero := by apply J.comp_zero (I.Zero X Y).zero Y
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero ≫ Zero.zero = Zero.zero
[PROOFSTEP]
apply J.comp_zero (I.Zero X Y).zero Y
[GOAL]
case w
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
I J : HasZeroMorphisms C
X Y : C
this : Zero.zero ≫ Zero.zero = Zero.zero
that : Zero.zero ≫ Zero.zero = Zero.zero
⊢ Zero.zero = Zero.zero
[PROOFSTEP]
rw [← this, ← that]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono g
h : f ≫ g = 0
⊢ f = 0
[PROOFSTEP]
rw [← zero_comp, cancel_mono] at h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Mono g
h✝ : f ≫ g = 0
h : f = 0
⊢ f = 0
[PROOFSTEP]
exact h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi f
h : f ≫ g = 0
⊢ g = 0
[PROOFSTEP]
rw [← comp_zero, cancel_epi] at h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : Epi f
h✝ : f ≫ g = 0
h : g = 0
⊢ g = 0
[PROOFSTEP]
exact h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : HasImage f
w : image.ι f = 0
⊢ f = 0
[PROOFSTEP]
rw [← image.fac f, w, HasZeroMorphisms.comp_zero]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
H : C ⥤ D
⊢ η ≫ 0 = 0
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
H : C ⥤ D
X : C
⊢ NatTrans.app (η ≫ 0) X = NatTrans.app 0 X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
H : C ⥤ D
X : C
⊢ NatTrans.app η X ≫ NatTrans.app 0 X = NatTrans.app 0 X
[PROOFSTEP]
apply comp_zero
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms D
F G H : C ⥤ D
η : G ⟶ H
⊢ 0 ≫ η = 0
[PROOFSTEP]
ext X
[GOAL]
case w.h
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms D
F G H : C ⥤ D
η : G ⟶ H
X : C
⊢ NatTrans.app (0 ≫ η) X = NatTrans.app 0 X
[PROOFSTEP]
dsimp
[GOAL]
case w.h
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms D
F G H : C ⥤ D
η : G ⟶ H
X : C
⊢ NatTrans.app 0 X ≫ NatTrans.app η X = NatTrans.app 0 X
[PROOFSTEP]
apply zero_comp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : X ⟶ Y
⊢ f = default
[PROOFSTEP]
rw [← id_comp f, ← id_comp (0 : X ⟶ Y), h, zero_comp, zero_comp]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : X ⟶ Y
⊢ 0 = default
[PROOFSTEP]
simp only
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : Y ⟶ X
⊢ f = default
[PROOFSTEP]
rw [← comp_id f, ← comp_id (0 : Y ⟶ X), h, comp_zero, comp_zero]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X : C
h : 𝟙 X = 0
Y : C
f : Y ⟶ X
⊢ 0 = default
[PROOFSTEP]
simp only
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Mono 0
⊢ 𝟙 X ≫ 0 = 0 ≫ 0
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Epi 0
⊢ 0 ≫ 𝟙 Y = 0 ≫ 0
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : f = 0
⊢ IsZero X
[PROOFSTEP]
subst h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Mono 0
⊢ IsZero X
[PROOFSTEP]
apply of_mono_zero X Y
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
h : f = 0
⊢ IsZero Y
[PROOFSTEP]
subst h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Epi 0
⊢ IsZero Y
[PROOFSTEP]
apply of_epi_zero X Y
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ IsZero X ↔ f = 0
[PROOFSTEP]
rw [iff_id_eq_zero]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ 𝟙 X = 0 ↔ f = 0
[PROOFSTEP]
constructor
[GOAL]
case mp
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ 𝟙 X = 0 → f = 0
[PROOFSTEP]
intro h
[GOAL]
case mp
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
h : 𝟙 X = 0
⊢ f = 0
[PROOFSTEP]
rw [← Category.id_comp f, h, zero_comp]
[GOAL]
case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
⊢ f = 0 → 𝟙 X = 0
[PROOFSTEP]
intro h
[GOAL]
case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
h : f = 0
⊢ 𝟙 X = 0
[PROOFSTEP]
rw [← IsSplitMono.id f]
[GOAL]
case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitMono f
h : f = 0
⊢ f ≫ retraction f = 0
[PROOFSTEP]
simp [h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ IsZero Y ↔ f = 0
[PROOFSTEP]
rw [iff_id_eq_zero]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 ↔ f = 0
[PROOFSTEP]
constructor
[GOAL]
case mp
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ 𝟙 Y = 0 → f = 0
[PROOFSTEP]
intro h
[GOAL]
case mp
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
h : 𝟙 Y = 0
⊢ f = 0
[PROOFSTEP]
rw [← Category.comp_id f, h, comp_zero]
[GOAL]
case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
⊢ f = 0 → 𝟙 Y = 0
[PROOFSTEP]
intro h
[GOAL]
case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
h : f = 0
⊢ 𝟙 Y = 0
[PROOFSTEP]
rw [← IsSplitEpi.id f]
[GOAL]
case mpr
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : IsSplitEpi f
h : f = 0
⊢ section_ f ≫ f = 0
[PROOFSTEP]
simp [h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
i : IsZero Y
⊢ IsZero X
[PROOFSTEP]
have hf := i.eq_zero_of_tgt f
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
i : IsZero Y
hf : f = 0
⊢ IsZero X
[PROOFSTEP]
subst hf
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
i : IsZero Y
inst✝ : Mono 0
⊢ IsZero X
[PROOFSTEP]
exact IsZero.of_mono_zero X Y
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
i : IsZero X
⊢ IsZero Y
[PROOFSTEP]
have hf := i.eq_zero_of_src f
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
i : IsZero X
hf : f = 0
⊢ IsZero Y
[PROOFSTEP]
subst hf
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y : C
i : IsZero X
inst✝ : Epi 0
⊢ IsZero Y
[PROOFSTEP]
exact IsZero.of_epi_zero X Y
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y : C
f : X ⟶ Y
Z : C
⊢ f ≫ 0 = 0
[PROOFSTEP]
change f ≫ (hO.from_ Y ≫ hO.to_ Z) = hO.from_ X ≫ hO.to_ Z
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y : C
f : X ⟶ Y
Z : C
⊢ f ≫ IsZero.from_ hO Y ≫ IsZero.to_ hO Z = IsZero.from_ hO X ≫ IsZero.to_ hO Z
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y : C
f : X ⟶ Y
Z : C
⊢ (f ≫ IsZero.from_ hO Y) ≫ IsZero.to_ hO Z = IsZero.from_ hO X ≫ IsZero.to_ hO Z
[PROOFSTEP]
congr
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y : C
f : X ⟶ Y
Z : C
⊢ f ≫ IsZero.from_ hO Y = IsZero.from_ hO X
[PROOFSTEP]
apply hO.eq_of_tgt
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y Z : C
f : Y ⟶ Z
⊢ 0 ≫ f = 0
[PROOFSTEP]
change (hO.from_ X ≫ hO.to_ Y) ≫ f = hO.from_ X ≫ hO.to_ Z
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y Z : C
f : Y ⟶ Z
⊢ (IsZero.from_ hO X ≫ IsZero.to_ hO Y) ≫ f = IsZero.from_ hO X ≫ IsZero.to_ hO Z
[PROOFSTEP]
rw [Category.assoc]
[GOAL]
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y Z : C
f : Y ⟶ Z
⊢ IsZero.from_ hO X ≫ IsZero.to_ hO Y ≫ f = IsZero.from_ hO X ≫ IsZero.to_ hO Z
[PROOFSTEP]
congr
[GOAL]
case e_a
C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
O : C
hO : IsZero O
X Y Z : C
f : Y ⟶ Z
⊢ IsZero.to_ hO Y ≫ f = IsZero.to_ hO Z
[PROOFSTEP]
apply hO.eq_of_src
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
Z : C
⊢ f ≫ 0 = 0
[PROOFSTEP]
change f ≫ (default : Y ⟶ 0) ≫ default = (default : X ⟶ 0) ≫ default
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
Z : C
⊢ f ≫ default ≫ default = default ≫ default
[PROOFSTEP]
rw [← Category.assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
Z : C
⊢ (f ≫ default) ≫ default = default ≫ default
[PROOFSTEP]
congr
[GOAL]
case e_a
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
Z : C
⊢ f ≫ default = default
[PROOFSTEP]
simp only [eq_iff_true_of_subsingleton]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y Z : C
f : Y ⟶ Z
⊢ 0 ≫ f = 0
[PROOFSTEP]
change ((default : X ⟶ 0) ≫ default) ≫ f = (default : X ⟶ 0) ≫ default
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y Z : C
f : Y ⟶ Z
⊢ (default ≫ default) ≫ f = default ≫ default
[PROOFSTEP]
rw [Category.assoc]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y Z : C
f : Y ⟶ Z
⊢ default ≫ default ≫ f = default ≫ default
[PROOFSTEP]
congr
[GOAL]
case e_a
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroObject C
X Y Z : C
f : Y ⟶ Z
⊢ default ≫ f = default
[PROOFSTEP]
simp only [eq_iff_true_of_subsingleton]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsInitial X
⊢ (zeroIsoIsInitial t).hom = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsInitial X
⊢ (zeroIsoIsInitial t).inv = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsTerminal X
⊢ (zeroIsoIsTerminal t).hom = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
t : IsTerminal X
⊢ (zeroIsoIsTerminal t).inv = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
⊢ zeroIsoInitial.hom = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
⊢ zeroIsoInitial.inv = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
⊢ zeroIsoTerminal.hom = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
⊢ zeroIsoTerminal.inv = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
⊢ 𝟙 0 = 0
[PROOFSTEP]
apply HasZeroObject.from_zero_ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
f : X ⟶ 0
⊢ f = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
⊢ f = 0
[PROOFSTEP]
have h : f = f ≫ i.hom ≫ 𝟙 0 ≫ i.inv := by simp only [Iso.hom_inv_id, id_comp, comp_id]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
⊢ f = f ≫ i.hom ≫ 𝟙 0 ≫ i.inv
[PROOFSTEP]
simp only [Iso.hom_inv_id, id_comp, comp_id]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
h : f = f ≫ i.hom ≫ 𝟙 0 ≫ i.inv
⊢ f = 0
[PROOFSTEP]
simpa using h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
f : 0 ⟶ X
⊢ f = 0
[PROOFSTEP]
ext
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
⊢ f = 0
[PROOFSTEP]
have h : f = i.hom ≫ 𝟙 0 ≫ i.inv ≫ f := by simp only [Iso.hom_inv_id_assoc, id_comp, comp_id]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
⊢ f = i.hom ≫ 𝟙 0 ≫ i.inv ≫ f
[PROOFSTEP]
simp only [Iso.hom_inv_id_assoc, id_comp, comp_id]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
h : f = i.hom ≫ 𝟙 0 ≫ i.inv ≫ f
⊢ f = 0
[PROOFSTEP]
simpa using h
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : X ≅ 0
Z : C
g h : Z ⟶ X
x✝ : g ≫ f = h ≫ f
⊢ g = h
[PROOFSTEP]
rw [zero_of_target_iso_zero g i, zero_of_target_iso_zero h i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
i : Y ≅ 0
Z : C
g h : Y ⟶ Z
x✝ : f ≫ g = f ≫ h
⊢ g = h
[PROOFSTEP]
rw [zero_of_source_iso_zero g i, zero_of_source_iso_zero h i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ Function.LeftInverse (_ : (X ≅ 0) → 𝟙 X = 0) fun h => Iso.mk 0 0
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
⊢ Function.RightInverse (_ : (X ≅ 0) → 𝟙 X = 0) fun h => Iso.mk 0 0
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
h : Mono 0
⊢ (0 ≫ 0) ≫ 0 = 𝟙 X ≫ 0
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X Y : C
h : Epi 0
⊢ 0 ≫ 0 ≫ 0 = 0 ≫ 𝟙 Y
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
h : f = 0
⊢ X ≅ 0
[PROOFSTEP]
subst h
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Mono 0
⊢ X ≅ 0
[PROOFSTEP]
apply isoZeroOfMonoZero ‹_›
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
inst✝ : Epi f
h : f = 0
⊢ Y ≅ 0
[PROOFSTEP]
subst h
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroObject C
inst✝¹ : HasZeroMorphisms C
X Y : C
inst✝ : Epi 0
⊢ Y ≅ 0
[PROOFSTEP]
apply isoZeroOfEpiZero ‹_›
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
P : IsIsomorphic X 0
⊢ 0 ≫ 0 = 𝟙 X
[PROOFSTEP]
cases' P with P
[GOAL]
case intro
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
P : X ≅ 0
⊢ 0 ≫ 0 = 𝟙 X
[PROOFSTEP]
rw [← P.hom_inv_id, ← Category.id_comp P.inv]
[GOAL]
case intro
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
P : X ≅ 0
⊢ 0 ≫ 0 = P.hom ≫ 𝟙 0 ≫ P.inv
[PROOFSTEP]
apply Eq.symm
[GOAL]
case intro.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
P : X ≅ 0
⊢ P.hom ≫ 𝟙 0 ≫ P.inv = 0 ≫ 0
[PROOFSTEP]
simp only [id_comp, Iso.hom_inv_id, comp_zero]
[GOAL]
case intro.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
P : X ≅ 0
⊢ 𝟙 X = 0
[PROOFSTEP]
apply (idZeroEquivIsoZero X).invFun P
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroObject C
inst✝ : HasZeroMorphisms C
X : C
P : IsIsomorphic X 0
⊢ 0 ≫ 0 = 𝟙 0
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
⊢ IsIso 0 → 𝟙 X = 0 ∧ 𝟙 Y = 0
[PROOFSTEP]
intro i
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 𝟙 X = 0 ∧ 𝟙 Y = 0
[PROOFSTEP]
rw [← IsIso.hom_inv_id (0 : X ⟶ Y)]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 0 ≫ inv 0 = 0 ∧ 𝟙 Y = 0
[PROOFSTEP]
rw [← IsIso.inv_hom_id (0 : X ⟶ Y)]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
i : IsIso 0
⊢ 0 ≫ inv 0 = 0 ∧ inv 0 ≫ 0 = 0
[PROOFSTEP]
simp only [eq_self_iff_true, comp_zero, and_self, zero_comp]
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
h : 𝟙 X = 0 ∧ 𝟙 Y = 0
⊢ 0 ≫ 0 = 𝟙 X ∧ 0 ≫ 0 = 𝟙 Y
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
⊢ Function.LeftInverse (_ : 𝟙 X = 0 ∧ 𝟙 Y = 0 → IsIso 0) (_ : IsIso 0 → 𝟙 X = 0 ∧ 𝟙 Y = 0)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X Y : C
⊢ Function.RightInverse (_ : 𝟙 X = 0 ∧ 𝟙 Y = 0 → IsIso 0) (_ : IsIso 0 → 𝟙 X = 0 ∧ 𝟙 Y = 0)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : HasZeroMorphisms C
X : C
⊢ IsIso 0 ≃ 𝟙 X = 0
[PROOFSTEP]
simpa using isIsoZeroEquiv X X
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ IsIso 0 ≃ (X ≅ 0) × (Y ≅ 0)
[PROOFSTEP]
refine' (isIsoZeroEquiv X Y).trans _
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ 𝟙 X = 0 ∧ 𝟙 Y = 0 ≃ (X ≅ 0) × (Y ≅ 0)
[PROOFSTEP]
symm
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ (X ≅ 0) × (Y ≅ 0) ≃ 𝟙 X = 0 ∧ 𝟙 Y = 0
[PROOFSTEP]
fconstructor
[GOAL]
case toFun
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ (X ≅ 0) × (Y ≅ 0) → 𝟙 X = 0 ∧ 𝟙 Y = 0
[PROOFSTEP]
rintro ⟨eX, eY⟩
[GOAL]
case toFun.mk
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
eX : X ≅ 0
eY : Y ≅ 0
⊢ 𝟙 X = 0 ∧ 𝟙 Y = 0
[PROOFSTEP]
fconstructor
[GOAL]
case toFun.mk.left
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
eX : X ≅ 0
eY : Y ≅ 0
⊢ 𝟙 X = 0
case toFun.mk.right
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
eX : X ≅ 0
eY : Y ≅ 0
⊢ 𝟙 Y = 0
[PROOFSTEP]
exact (idZeroEquivIsoZero X).symm eX
[GOAL]
case toFun.mk.right
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
eX : X ≅ 0
eY : Y ≅ 0
⊢ 𝟙 Y = 0
[PROOFSTEP]
exact (idZeroEquivIsoZero Y).symm eY
[GOAL]
case invFun
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ 𝟙 X = 0 ∧ 𝟙 Y = 0 → (X ≅ 0) × (Y ≅ 0)
[PROOFSTEP]
rintro ⟨hX, hY⟩
[GOAL]
case invFun.intro
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
hX : 𝟙 X = 0
hY : 𝟙 Y = 0
⊢ (X ≅ 0) × (Y ≅ 0)
[PROOFSTEP]
fconstructor
[GOAL]
case invFun.intro.fst
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
hX : 𝟙 X = 0
hY : 𝟙 Y = 0
⊢ X ≅ 0
case invFun.intro.snd
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
hX : 𝟙 X = 0
hY : 𝟙 Y = 0
⊢ Y ≅ 0
[PROOFSTEP]
exact (idZeroEquivIsoZero X) hX
[GOAL]
case invFun.intro.snd
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
hX : 𝟙 X = 0
hY : 𝟙 Y = 0
⊢ Y ≅ 0
[PROOFSTEP]
exact (idZeroEquivIsoZero Y) hY
[GOAL]
case left_inv
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ Function.LeftInverse (fun a => And.casesOn a fun hX hY => (↑(idZeroEquivIsoZero X) hX, ↑(idZeroEquivIsoZero Y) hY))
    (_ : (X ≅ 0) × (Y ≅ 0) → 𝟙 X = 0 ∧ 𝟙 Y = 0)
[PROOFSTEP]
aesop_cat
[GOAL]
case right_inv
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
⊢ Function.RightInverse (fun a => And.casesOn a fun hX hY => (↑(idZeroEquivIsoZero X) hX, ↑(idZeroEquivIsoZero Y) hY))
    (_ : (X ≅ 0) × (Y ≅ 0) → 𝟙 X = 0 ∧ 𝟙 Y = 0)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
i : X ≅ 0
j : Y ≅ 0
⊢ IsIso f
[PROOFSTEP]
rw [zero_of_source_iso_zero f i]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X Y : C
f : X ⟶ Y
i : X ≅ 0
j : Y ≅ 0
⊢ IsIso 0
[PROOFSTEP]
exact (isIsoZeroEquivIsoZero _ _).invFun ⟨i, j⟩
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
⊢ HasZeroObject C
[PROOFSTEP]
refine' ⟨⟨⊥_ C, fun X => ⟨⟨⟨0⟩, by aesop_cat⟩⟩, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩⟩⟩
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
X : C
⊢ ∀ (a : ⊥_ C ⟶ X), a = default
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
X : C
f : X ⟶ ⊥_ C
⊢ f = default
[PROOFSTEP]
calc
  f = f ≫ 𝟙 _ := (Category.comp_id _).symm
  _ = f ≫ 0 := by congr!
  _ = 0 := HasZeroMorphisms.comp_zero _ _
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasInitial C
X : C
f : X ⟶ ⊥_ C
⊢ f ≫ 𝟙 (⊥_ C) = f ≫ 0
[PROOFSTEP]
congr!
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
⊢ HasZeroObject C
[PROOFSTEP]
refine' ⟨⟨⊤_ C, fun X => ⟨⟨⟨0⟩, fun f => _⟩⟩, fun X => ⟨⟨⟨0⟩, by aesop_cat⟩⟩⟩⟩
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
X : C
⊢ ∀ (a : X ⟶ ⊤_ C), a = default
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
X : C
f : ⊤_ C ⟶ X
⊢ f = default
[PROOFSTEP]
calc
  f = 𝟙 _ ≫ f := (Category.id_comp _).symm
  _ = 0 ≫ f := by congr!
  _ = 0 := zero_comp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
inst✝ : HasTerminal C
X : C
f : ⊤_ C ⟶ X
⊢ 𝟙 (⊤_ C) ≫ f = 0 ≫ f
[PROOFSTEP]
congr!
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : HasImage f
inst✝ : Epi (factorThruImage f)
h : f ≫ g = 0
⊢ factorThruImage f ≫ image.ι f ≫ g = 0
[PROOFSTEP]
simp [h]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
inst✝¹ : HasZeroMorphisms C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝ : HasImage g
h : f ≫ g = 0
⊢ (f ≫ factorThruImage g) ≫ image.ι g = 0
[PROOFSTEP]
simp [h]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ ι 0 = 0
[PROOFSTEP]
rw [← image.lift_fac (monoFactorisationZero X Y)]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
X Y : C
inst✝ : HasImage 0
⊢ lift (monoFactorisationZero X Y) ≫ (monoFactorisationZero X Y).m = 0
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroObject C
inst✝¹ : HasEqualizers C
X Y : C
f : X ⟶ Y
h : f = 0
inst✝ : HasImage f
⊢ ι f = 0
[PROOFSTEP]
rw [image.eq_fac h]
[GOAL]
C : Type u
inst✝⁵ : Category.{v, u} C
D : Type u'
inst✝⁴ : Category.{v', u'} D
inst✝³ : HasZeroMorphisms C
inst✝² : HasZeroObject C
inst✝¹ : HasEqualizers C
X Y : C
f : X ⟶ Y
h : f = 0
inst✝ : HasImage f
⊢ (eqToIso h).hom ≫ ι 0 = 0
[PROOFSTEP]
simp