Theorem: CategoryTheory.StructuredArrow.lift_projectSubobject
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 : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A : StructuredArrow S T
⊢ ∀ ⦃A_1 : StructuredArrow S T⦄ (f : A_1 ⟶ A) [inst : Mono f]
    {q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))}
    (hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom),
    liftSubobject (projectSubobject (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 : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ liftSubobject (projectSubobject (Subobject.mk f)) hq = Subobject.mk f

tactic: fapply isoMk
state_before: case i
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ mk q ≅ P

tactic: exact Subobject.underlyingIso _
state_before: case i.g
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ (mk q).right ≅ P.right

tactic: exact (cancel_mono (T.map f.right)).1 (by dsimp; simpa [← T.map_comp] using hq)
state_before: case i.w
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ autoParam ((mk q).hom ≫ T.map (Subobject.underlyingIso (MonoOver.arrow (MonoOver.mk' f)).right).hom = P.hom) _auto✝

tactic: dsimp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ ((mk q).hom ≫ T.map (Subobject.underlyingIso (MonoOver.arrow (MonoOver.mk' f)).right).hom) ≫ T.map f.right =
    P.hom ≫ T.map f.right

tactic: simpa [← T.map_comp] using hq
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ (q ≫ T.map (Subobject.underlyingIso f.right).hom) ≫ T.map f.right = P.hom ≫ T.map f.right

tactic: exact ext _ _ (by dsimp; simp)
state_before: case w
C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ (isoMk (Subobject.underlyingIso (MonoOver.arrow (MonoOver.mk' f)).right)).hom ≫ f =
    homMk (Subobject.arrow (projectSubobject (Subobject.mk f)))

tactic: dsimp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ ((isoMk (Subobject.underlyingIso (MonoOver.arrow (MonoOver.mk' f)).right)).hom ≫ f).right =
    (homMk (Subobject.arrow (projectSubobject (Subobject.mk f)))).right

tactic: simp
state_before: C : Type u₁
inst✝³ : Category C
D : Type u₂
inst✝² : Category D
S : D
T : C ⥤ D
inst✝¹ : HasLimits C
inst✝ : PreservesLimits T
A P : StructuredArrow S T
f : P ⟶ A
hf : Mono f
q : (Functor.fromPUnit S).obj A.left ⟶ T.obj (Subobject.underlying.obj (projectSubobject (Subobject.mk f)))
hq : q ≫ T.map (Subobject.arrow (projectSubobject (Subobject.mk f))) = A.hom
⊢ (Subobject.underlyingIso f.right).hom ≫ f.right = Subobject.arrow (Subobject.mk f.right)