File: Mathlib/CategoryTheory/Subobject/FactorThru.lean

full_name: CategoryTheory.MonoOver.Factors
code: /-- When `f : X ⟶ Y` and `P : MonoOver Y`,
`P.Factors f` expresses that there exists a factorisation of `f` through `P`.
Given `h : P.Factors f`, you can recover the morphism as `P.factorThru f h`.
-/
def Factors {X Y : C} (P : MonoOver Y) (f : X ⟶ Y) : Prop 
goal: Prop

full_name: CategoryTheory.MonoOver.factors_congr
code: theorem factors_congr {X : C} {f g : MonoOver X} {Y : C} (h : Y ⟶ X) (e : f ≅ g) :
    f.Factors h ↔ g.Factors h 
goal: f.Factors h ↔ g.Factors h

full_name: CategoryTheory.MonoOver.factorThru
code: /-- `P.factorThru f h` provides a factorisation of `f : X ⟶ Y` through some `P : MonoOver Y`,
given the evidence `h : P.Factors f` that such a factorisation exists. -/
def factorThru {X Y : C} (P : MonoOver Y) (f : X ⟶ Y) (h : Factors P f) : X ⟶ (P : C) 
goal: X ⟶ P.obj.left

full_name: CategoryTheory.Subobject.Factors
code: /-- When `f : X ⟶ Y` and `P : Subobject Y`,
`P.Factors f` expresses that there exists a factorisation of `f` through `P`.
Given `h : P.Factors f`, you can recover the morphism as `P.factorThru f h`.
-/
def Factors {X Y : C} (P : Subobject Y) (f : X ⟶ Y) : Prop 
goal: Prop

full_name: CategoryTheory.Subobject.mk_factors_iff
code: @[simp]
theorem mk_factors_iff {X Y Z : C} (f : Y ⟶ X) [Mono f] (g : Z ⟶ X) :
    (Subobject.mk f).Factors g ↔ (MonoOver.mk' f).Factors g 
goal: (CategoryTheory.Subobject.mk f).Factors g ↔ (CategoryTheory.MonoOver.mk' f).Factors g

full_name: CategoryTheory.Subobject.mk_factors_self
code: theorem mk_factors_self (f : X ⟶ Y) [Mono f] : (mk f).Factors f 
goal: (CategoryTheory.Subobject.mk f).Factors f

full_name: CategoryTheory.Subobject.factors_iff
code: theorem factors_iff {X Y : C} (P : Subobject Y) (f : X ⟶ Y) :
    P.Factors f ↔ (representative.obj P).Factors f 
goal: P.Factors f ↔ (CategoryTheory.Subobject.representative.obj P).Factors f

full_name: CategoryTheory.Subobject.factors_self
code: theorem factors_self {X : C} (P : Subobject X) : P.Factors P.arrow 
goal: P.Factors P.arrow

full_name: CategoryTheory.Subobject.factors_comp_arrow
code: theorem factors_comp_arrow {X Y : C} {P : Subobject Y} (f : X ⟶ P) : P.Factors (f ≫ P.arrow) 
goal: P.Factors (f ≫ P.arrow)

full_name: CategoryTheory.Subobject.factors_of_factors_right
code: theorem factors_of_factors_right {X Y Z : C} {P : Subobject Z} (f : X ⟶ Y) {g : Y ⟶ Z}
    (h : P.Factors g) : P.Factors (f ≫ g) 
goal: P.Factors (f ≫ g)

full_name: CategoryTheory.Subobject.factors_zero
code: theorem factors_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y} : P.Factors (0 : X ⟶ Y) 
goal: P.Factors 0

full_name: CategoryTheory.Subobject.factors_of_le
code: theorem factors_of_le {Y Z : C} {P Q : Subobject Y} (f : Z ⟶ Y) (h : P ≤ Q) :
    P.Factors f → Q.Factors f 
goal: P.Factors f → Q.Factors f

full_name: CategoryTheory.Subobject.factorThru
code: /-- `P.factorThru f h` provides a factorisation of `f : X ⟶ Y` through some `P : Subobject Y`,
given the evidence `h : P.Factors f` that such a factorisation exists. -/
def factorThru {X Y : C} (P : Subobject Y) (f : X ⟶ Y) (h : Factors P f) : X ⟶ P 
goal: X ⟶ CategoryTheory.Subobject.underlying.obj P

full_name: CategoryTheory.Subobject.factorThru_arrow
code: @[reassoc (attr := simp)]
theorem factorThru_arrow {X Y : C} (P : Subobject Y) (f : X ⟶ Y) (h : Factors P f) :
    P.factorThru f h ≫ P.arrow = f 
goal: P.factorThru f h ≫ P.arrow = f

full_name: CategoryTheory.Subobject.factorThru_self
code: @[simp]
theorem factorThru_self {X : C} (P : Subobject X) (h) : P.factorThru P.arrow h = 𝟙 (P : C) 
goal: P.factorThru P.arrow h = 𝟙 (CategoryTheory.Subobject.underlying.obj P)

full_name: CategoryTheory.Subobject.factorThru_mk_self
code: @[simp]
theorem factorThru_mk_self (f : X ⟶ Y) [Mono f] :
    (mk f).factorThru f (mk_factors_self f) = (underlyingIso f).inv 
goal: (CategoryTheory.Subobject.mk f).factorThru f ⋯ = (CategoryTheory.Subobject.underlyingIso f).inv

full_name: CategoryTheory.Subobject.factorThru_comp_arrow
code: @[simp]
theorem factorThru_comp_arrow {X Y : C} {P : Subobject Y} (f : X ⟶ P) (h) :
    P.factorThru (f ≫ P.arrow) h = f 
goal: P.factorThru (f ≫ P.arrow) h = f

full_name: CategoryTheory.Subobject.factorThru_eq_zero
code: @[simp]
theorem factorThru_eq_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y} {f : X ⟶ Y}
    {h : Factors P f} : P.factorThru f h = 0 ↔ f = 0 
goal: P.factorThru f h = 0 ↔ f = 0

full_name: CategoryTheory.Subobject.factorThru_right
code: theorem factorThru_right {X Y Z : C} {P : Subobject Z} (f : X ⟶ Y) (g : Y ⟶ Z) (h : P.Factors g) :
    f ≫ P.factorThru g h = P.factorThru (f ≫ g) (factors_of_factors_right f h) 
goal: f ≫ P.factorThru g h = P.factorThru (f ≫ g) ⋯

full_name: CategoryTheory.Subobject.factorThru_zero
code: @[simp]
theorem factorThru_zero [HasZeroMorphisms C] {X Y : C} {P : Subobject Y}
    (h : P.Factors (0 : X ⟶ Y)) : P.factorThru 0 h = 0 
goal: P.factorThru 0 h = 0

full_name: CategoryTheory.Subobject.factorThru_ofLE
code: theorem factorThru_ofLE {Y Z : C} {P Q : Subobject Y} {f : Z ⟶ Y} (h : P ≤ Q) (w : P.Factors f) :
    Q.factorThru f (factors_of_le f h w) = P.factorThru f w ≫ ofLE P Q h 
goal: Q.factorThru f ⋯ = P.factorThru f w ≫ P.ofLE Q h

full_name: CategoryTheory.Subobject.factors_add
code: theorem factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y) (wf : P.Factors f)
    (wg : P.Factors g) : P.Factors (f + g) 
goal: P.Factors (f + g)

full_name: CategoryTheory.Subobject.factorThru_add
code: theorem factorThru_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y) (w : P.Factors (f + g))
    (wf : P.Factors f) (wg : P.Factors g) :
    P.factorThru (f + g) w = P.factorThru f wf + P.factorThru g wg 
goal: P.factorThru (f + g) w = P.factorThru f wf + P.factorThru g wg

full_name: CategoryTheory.Subobject.factors_left_of_factors_add
code: theorem factors_left_of_factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wg : P.Factors g) : P.Factors f 
goal: P.Factors f

full_name: CategoryTheory.Subobject.factorThru_add_sub_factorThru_right
code: @[simp]
theorem factorThru_add_sub_factorThru_right {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wg : P.Factors g) :
    P.factorThru (f + g) w - P.factorThru g wg =
      P.factorThru f (factors_left_of_factors_add f g w wg) 
goal: P.factorThru (f + g) w - P.factorThru g wg = P.factorThru f ⋯

full_name: CategoryTheory.Subobject.factors_right_of_factors_add
code: theorem factors_right_of_factors_add {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wf : P.Factors f) : P.Factors g 
goal: P.Factors g

full_name: CategoryTheory.Subobject.factorThru_add_sub_factorThru_left
code: @[simp]
theorem factorThru_add_sub_factorThru_left {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wf : P.Factors f) :
    P.factorThru (f + g) w - P.factorThru f wf =
      P.factorThru g (factors_right_of_factors_add f g w wf) 
goal: P.factorThru (f + g) w - P.factorThru f wf = P.factorThru g ⋯