Theorem: CategoryTheory.CostructuredArrow.lift_projectQuotient
File: Mathlib/CategoryTheory/Subobject/Comma.lean

tactic: intro P f hf q hq
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
⊢ ∀ ⦃A_1 : (CostructuredArrow S T)ᵒᵖ⦄ (f : A_1 ⟶ A.op) [inst : Mono f]
    {q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right}
    (hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom),
    liftQuotient (projectQuotient (Subobject.mk f)) hq = Subobject.mk f

tactic: fapply Subobject.mk_eq_mk_of_comm
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ liftQuotient (projectQuotient (Subobject.mk f)) hq = Subobject.mk f

tactic: refine' (Iso.op (isoMk _ _) : _ ≅ op (unop P))
state_before: case i
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ (mk q).op ≅ P

tactic: exact (Subobject.underlyingIso f.unop.left.op).unop
state_before: case i.refine'_1
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ P.unop.left ≅ (mk q).left

tactic: refine' (cancel_epi (S.map f.unop.left)).1 _
state_before: case i.refine'_2
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ S.map (Iso.unop (Subobject.underlyingIso f.unop.left.op)).hom ≫ (mk q).hom = P.unop.hom

tactic: simpa [← Category.assoc, ← S.map_comp] using hq
state_before: case i.refine'_2
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ S.map f.unop.left ≫ S.map (Iso.unop (Subobject.underlyingIso f.unop.left.op)).hom ≫ (mk q).hom =
    S.map f.unop.left ≫ P.unop.hom

tactic: exact Quiver.Hom.unop_inj (by aesop_cat)
state_before: case w
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ (Iso.op (isoMk (Iso.unop (Subobject.underlyingIso f.unop.left.op)))).hom ≫ f =
    (homMk (Subobject.arrow (projectQuotient (Subobject.mk f))).unop).op

tactic: aesop_cat
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : C ⥤ D
T : D
inst✝¹ : HasColimits C
inst✝ : PreservesColimits S
A : CostructuredArrow S T
P : (CostructuredArrow S T)ᵒᵖ
f : P ⟶ A.op
hf : Mono f
q : S.obj (Subobject.underlying.obj (projectQuotient (Subobject.mk f))).unop ⟶ (Functor.fromPUnit T).obj A.right
hq : S.map (Subobject.arrow (projectQuotient (Subobject.mk f))).unop ≫ q = A.hom
⊢ ((Iso.op (isoMk (Iso.unop (Subobject.underlyingIso f.unop.left.op)))).hom ≫ f).unop =
    (homMk (Subobject.arrow (projectQuotient (Subobject.mk f))).unop).op.unop