File: Mathlib/CategoryTheory/Subobject/Lattice.lean

full_name: CategoryTheory.MonoOver.instTop
code: instance {X : C} : Top (MonoOver X) 
goal: Top (CategoryTheory.MonoOver X)

full_name: CategoryTheory.MonoOver.instInhabited
code: instance {X : C} : Inhabited (MonoOver X) 
goal: Inhabited (CategoryTheory.MonoOver X)

full_name: CategoryTheory.MonoOver.leTop
code: /-- The morphism to the top object in `MonoOver X`. -/
def leTop (f : MonoOver X) : f ⟶ ⊤ 
goal: f ⟶ ⊤

full_name: CategoryTheory.MonoOver.top_left
code: @[simp]
theorem top_left (X : C) : ((⊤ : MonoOver X) : C) = X 
goal: ⊤.obj.left = X

full_name: CategoryTheory.MonoOver.top_arrow
code: @[simp]
theorem top_arrow (X : C) : (⊤ : MonoOver X).arrow = 𝟙 X 
goal: ⊤.arrow = 𝟙 X

full_name: CategoryTheory.MonoOver.mapTop
code: /-- `map f` sends `⊤ : MonoOver X` to `⟨X, f⟩ : MonoOver Y`. -/
def mapTop (f : X ⟶ Y) [Mono f] : (map f).obj ⊤ ≅ mk' f 
goal: (CategoryTheory.MonoOver.map f).obj ⊤ ≅ CategoryTheory.MonoOver.mk' f

full_name: CategoryTheory.MonoOver.pullbackTop
code: /-- The pullback of the top object in `MonoOver Y`
is (isomorphic to) the top object in `MonoOver X`. -/
def pullbackTop (f : X ⟶ Y) : (pullback f).obj ⊤ ≅ ⊤ 
goal: (CategoryTheory.MonoOver.pullback f).obj ⊤ ≅ ⊤

full_name: CategoryTheory.MonoOver.topLEPullbackSelf
code: /-- There is a morphism from `⊤ : MonoOver A` to the pullback of a monomorphism along itself;
as the category is thin this is an isomorphism. -/
def topLEPullbackSelf {A B : C} (f : A ⟶ B) [Mono f] :
    (⊤ : MonoOver A) ⟶ (pullback f).obj (mk' f) 
goal: ⊤ ⟶ (CategoryTheory.MonoOver.pullback f).obj (CategoryTheory.MonoOver.mk' f)

full_name: CategoryTheory.MonoOver.pullbackSelf
code: /-- The pullback of a monomorphism along itself is isomorphic to the top object. -/
def pullbackSelf {A B : C} (f : A ⟶ B) [Mono f] : (pullback f).obj (mk' f) ≅ ⊤ 
goal: (CategoryTheory.MonoOver.pullback f).obj (CategoryTheory.MonoOver.mk' f) ≅ ⊤

full_name: CategoryTheory.MonoOver.instBot
code: instance {X : C} : Bot (MonoOver X) 
goal: Bot (CategoryTheory.MonoOver X)

full_name: CategoryTheory.MonoOver.bot_left
code: @[simp]
theorem bot_left (X : C) : ((⊥ : MonoOver X) : C) = ⊥_ C 
goal: ⊥.obj.left = ⊥_ C

full_name: CategoryTheory.MonoOver.bot_arrow
code: @[simp]
theorem bot_arrow {X : C} : (⊥ : MonoOver X).arrow = initial.to X 
goal: ⊥.arrow = CategoryTheory.Limits.initial.to X

full_name: CategoryTheory.MonoOver.botLE
code: /-- The (unique) morphism from `⊥ : MonoOver X` to any other `f : MonoOver X`. -/
def botLE {X : C} (f : MonoOver X) : ⊥ ⟶ f 
goal: ⊥ ⟶ f

full_name: CategoryTheory.MonoOver.mapBot
code: /-- `map f` sends `⊥ : MonoOver X` to `⊥ : MonoOver Y`. -/
def mapBot (f : X ⟶ Y) [Mono f] : (map f).obj ⊥ ≅ ⊥ 
goal: (CategoryTheory.MonoOver.map f).obj ⊥ ≅ ⊥

full_name: CategoryTheory.MonoOver.botCoeIsoZero
code: /-- The object underlying `⊥ : Subobject B` is (up to isomorphism) the zero object. -/
def botCoeIsoZero {B : C} : ((⊥ : MonoOver B) : C) ≅ 0 
goal: ⊥.obj.left ≅ 0

full_name: CategoryTheory.MonoOver.bot_arrow_eq_zero
code: theorem bot_arrow_eq_zero [HasZeroMorphisms C] {B : C} : (⊥ : MonoOver B).arrow = 0 
goal: ⊥.arrow = 0

full_name: CategoryTheory.MonoOver.inf
code: /-- When `[HasPullbacks C]`, `MonoOver A` has "intersections", functorial in both arguments.

As `MonoOver A` is only a preorder, this doesn't satisfy the axioms of `SemilatticeInf`,
but we reuse all the names from `SemilatticeInf` because they will be used to construct
`SemilatticeInf (subobject A)` shortly.
-/
@[simps]
def inf {A : C} : MonoOver A ⥤ MonoOver A ⥤ MonoOver A 
goal: CategoryTheory.MonoOver A ⥤ CategoryTheory.MonoOver A ⥤ CategoryTheory.MonoOver A

full_name: CategoryTheory.MonoOver.inf_map_app
code: /-- When `[HasPullbacks C]`, `MonoOver A` has "intersections", functorial in both arguments.

As `MonoOver A` is only a preorder, this doesn't satisfy the axioms of `SemilatticeInf`,
but we reuse all the names from `SemilatticeInf` because they will be used to construct
`SemilatticeInf (subobject A)` shortly.
-/
@[simps]
def inf {A : C} : MonoOver A ⥤ MonoOver A ⥤ MonoOver A 
goal: ∀ {X Y : CategoryTheory.MonoOver A} (k : X ⟶ Y) (g : CategoryTheory.MonoOver A),
  (CategoryTheory.MonoOver.inf.map k).app g =
    CategoryTheory.MonoOver.homMk
      (CategoryTheory.Limits.pullback.lift
        (CategoryTheory.Limits.pullback.fst ((CategoryTheory.MonoOver.forget A).obj g).hom X.arrow)
        (CategoryTheory.Limits.pullback.snd ((CategoryTheory.MonoOver.forget A).obj g).hom X.arrow ≫ k.left) ⋯)
      ⋯

full_name: CategoryTheory.MonoOver.inf_obj
code: /-- When `[HasPullbacks C]`, `MonoOver A` has "intersections", functorial in both arguments.

As `MonoOver A` is only a preorder, this doesn't satisfy the axioms of `SemilatticeInf`,
but we reuse all the names from `SemilatticeInf` because they will be used to construct
`SemilatticeInf (subobject A)` shortly.
-/
@[simps]
def inf {A : C} : MonoOver A ⥤ MonoOver A ⥤ MonoOver A 
goal: CategoryTheory.MonoOver.inf.obj f = CategoryTheory.MonoOver.pullback f.arrow ⋙ CategoryTheory.MonoOver.map f.arrow

full_name: CategoryTheory.MonoOver.infLELeft
code: /-- A morphism from the "infimum" of two objects in `MonoOver A` to the first object. -/
def infLELeft {A : C} (f g : MonoOver A) : (inf.obj f).obj g ⟶ f 
goal: (CategoryTheory.MonoOver.inf.obj f).obj g ⟶ f

full_name: CategoryTheory.MonoOver.infLERight
code: /-- A morphism from the "infimum" of two objects in `MonoOver A` to the second object. -/
def infLERight {A : C} (f g : MonoOver A) : (inf.obj f).obj g ⟶ g 
goal: (CategoryTheory.MonoOver.inf.obj f).obj g ⟶ g

full_name: CategoryTheory.MonoOver.leInf
code: /-- A morphism version of the `le_inf` axiom. -/
def leInf {A : C} (f g h : MonoOver A) : (h ⟶ f) → (h ⟶ g) → (h ⟶ (inf.obj f).obj g) 
goal: (h ⟶ f) → (h ⟶ g) → (h ⟶ (CategoryTheory.MonoOver.inf.obj f).obj g)

full_name: CategoryTheory.MonoOver.sup
code: /-- When `[HasImages C] [HasBinaryCoproducts C]`, `MonoOver A` has a `sup` construction,
which is functorial in both arguments,
and which on `Subobject A` will induce a `SemilatticeSup`. -/
def sup {A : C} : MonoOver A ⥤ MonoOver A ⥤ MonoOver A 
goal: CategoryTheory.MonoOver A ⥤ CategoryTheory.MonoOver A ⥤ CategoryTheory.MonoOver A

full_name: CategoryTheory.MonoOver.leSupLeft
code: /-- A morphism version of `le_sup_left`. -/
def leSupLeft {A : C} (f g : MonoOver A) : f ⟶ (sup.obj f).obj g 
goal: f ⟶ (CategoryTheory.MonoOver.sup.obj f).obj g

full_name: CategoryTheory.MonoOver.leSupRight
code: /-- A morphism version of `le_sup_right`. -/
def leSupRight {A : C} (f g : MonoOver A) : g ⟶ (sup.obj f).obj g 
goal: g ⟶ (CategoryTheory.MonoOver.sup.obj f).obj g

full_name: CategoryTheory.MonoOver.supLe
code: /-- A morphism version of `sup_le`. -/
def supLe {A : C} (f g h : MonoOver A) : (f ⟶ h) → (g ⟶ h) → ((sup.obj f).obj g ⟶ h) 
goal: (f ⟶ h) → (g ⟶ h) → ((CategoryTheory.MonoOver.sup.obj f).obj g ⟶ h)

full_name: CategoryTheory.Subobject.orderTop
code: instance orderTop {X : C} : OrderTop (Subobject X) 
goal: OrderTop (CategoryTheory.Subobject X)

full_name: CategoryTheory.Subobject.instInhabited
code: instance {X : C} : Inhabited (Subobject X) 
goal: Inhabited (CategoryTheory.Subobject X)

full_name: CategoryTheory.Subobject.top_eq_id
code: theorem top_eq_id (B : C) : (⊤ : Subobject B) = Subobject.mk (𝟙 B) 
goal: ⊤ = CategoryTheory.Subobject.mk (𝟙 B)

full_name: CategoryTheory.Subobject.underlyingIso_top_hom
code: theorem underlyingIso_top_hom {B : C} : (underlyingIso (𝟙 B)).hom = (⊤ : Subobject B).arrow 
goal: (CategoryTheory.Subobject.underlyingIso (𝟙 B)).hom = ⊤.arrow

full_name: CategoryTheory.Subobject.top_arrow_isIso
code: instance top_arrow_isIso {B : C} : IsIso (⊤ : Subobject B).arrow 
goal: CategoryTheory.IsIso ⊤.arrow

full_name: CategoryTheory.Subobject.underlyingIso_inv_top_arrow
code: @[reassoc (attr := simp)]
theorem underlyingIso_inv_top_arrow {B : C} :
    (underlyingIso _).inv ≫ (⊤ : Subobject B).arrow = 𝟙 B 
goal: (CategoryTheory.Subobject.underlyingIso (𝟙 B)).inv ≫ ⊤.arrow = 𝟙 B

full_name: CategoryTheory.Subobject.map_top
code: @[simp]
theorem map_top (f : X ⟶ Y) [Mono f] : (map f).obj ⊤ = Subobject.mk f 
goal: (CategoryTheory.Subobject.map f).obj ⊤ = CategoryTheory.Subobject.mk f

full_name: CategoryTheory.Subobject.top_factors
code: theorem top_factors {A B : C} (f : A ⟶ B) : (⊤ : Subobject B).Factors f 
goal: ⊤.Factors f

full_name: CategoryTheory.Subobject.isIso_iff_mk_eq_top
code: theorem isIso_iff_mk_eq_top {X Y : C} (f : X ⟶ Y) [Mono f] : IsIso f ↔ mk f = ⊤ 
goal: CategoryTheory.IsIso f ↔ CategoryTheory.Subobject.mk f = ⊤

full_name: CategoryTheory.Subobject.isIso_arrow_iff_eq_top
code: theorem isIso_arrow_iff_eq_top {Y : C} (P : Subobject Y) : IsIso P.arrow ↔ P = ⊤ 
goal: CategoryTheory.IsIso P.arrow ↔ P = ⊤

full_name: CategoryTheory.Subobject.isIso_top_arrow
code: instance isIso_top_arrow {Y : C} : IsIso (⊤ : Subobject Y).arrow 
goal: CategoryTheory.IsIso ⊤.arrow

full_name: CategoryTheory.Subobject.mk_eq_top_of_isIso
code: theorem mk_eq_top_of_isIso {X Y : C} (f : X ⟶ Y) [IsIso f] : mk f = ⊤ 
goal: CategoryTheory.Subobject.mk f = ⊤

full_name: CategoryTheory.Subobject.eq_top_of_isIso_arrow
code: theorem eq_top_of_isIso_arrow {Y : C} (P : Subobject Y) [IsIso P.arrow] : P = ⊤ 
goal: P = ⊤

full_name: CategoryTheory.Subobject.pullback_top
code: theorem pullback_top (f : X ⟶ Y) : (pullback f).obj ⊤ = ⊤ 
goal: (CategoryTheory.Subobject.pullback f).obj ⊤ = ⊤

full_name: CategoryTheory.Subobject.pullback_self
code: theorem pullback_self {A B : C} (f : A ⟶ B) [Mono f] : (pullback f).obj (mk f) = ⊤ 
goal: (CategoryTheory.Subobject.pullback f).obj (CategoryTheory.Subobject.mk f) = ⊤

full_name: CategoryTheory.Subobject.orderBot
code: instance orderBot {X : C} : OrderBot (Subobject X) 
goal: OrderBot (CategoryTheory.Subobject X)

full_name: CategoryTheory.Subobject.bot_eq_initial_to
code: theorem bot_eq_initial_to {B : C} : (⊥ : Subobject B) = Subobject.mk (initial.to B) 
goal: ⊥ = CategoryTheory.Subobject.mk (CategoryTheory.Limits.initial.to B)

full_name: CategoryTheory.Subobject.botCoeIsoInitial
code: /-- The object underlying `⊥ : Subobject B` is (up to isomorphism) the initial object. -/
def botCoeIsoInitial {B : C} : ((⊥ : Subobject B) : C) ≅ ⊥_ C 
goal: CategoryTheory.Subobject.underlying.obj ⊥ ≅ ⊥_ C

full_name: CategoryTheory.Subobject.map_bot
code: theorem map_bot (f : X ⟶ Y) [Mono f] : (map f).obj ⊥ = ⊥ 
goal: (CategoryTheory.Subobject.map f).obj ⊥ = ⊥

full_name: CategoryTheory.Subobject.botCoeIsoZero
code: /-- The object underlying `⊥ : Subobject B` is (up to isomorphism) the zero object. -/
def botCoeIsoZero {B : C} : ((⊥ : Subobject B) : C) ≅ 0 
goal: CategoryTheory.Subobject.underlying.obj ⊥ ≅ 0

full_name: CategoryTheory.Subobject.bot_eq_zero
code: theorem bot_eq_zero {B : C} : (⊥ : Subobject B) = Subobject.mk (0 : 0 ⟶ B) 
goal: ⊥ = CategoryTheory.Subobject.mk 0

full_name: CategoryTheory.Subobject.bot_arrow
code: @[simp]
theorem bot_arrow {B : C} : (⊥ : Subobject B).arrow = 0 
goal: ⊥.arrow = 0

full_name: CategoryTheory.Subobject.bot_factors_iff_zero
code: theorem bot_factors_iff_zero {A B : C} (f : A ⟶ B) : (⊥ : Subobject B).Factors f ↔ f = 0 
goal: ⊥.Factors f ↔ f = 0

full_name: CategoryTheory.Subobject.mk_eq_bot_iff_zero
code: theorem mk_eq_bot_iff_zero {f : X ⟶ Y} [Mono f] : Subobject.mk f = ⊥ ↔ f = 0 
goal: CategoryTheory.Subobject.mk f = ⊥ ↔ f = 0

full_name: CategoryTheory.Subobject.functor_obj
code: /-- Sending `X : C` to `Subobject X` is a contravariant functor `Cᵒᵖ ⥤ Type`. -/
@[simps]
def functor [HasPullbacks C] : Cᵒᵖ ⥤ Type max u₁ v₁ 
goal: (CategoryTheory.Subobject.functor C).obj X = CategoryTheory.Subobject (Opposite.unop X)

full_name: CategoryTheory.Subobject.functor
code: /-- Sending `X : C` to `Subobject X` is a contravariant functor `Cᵒᵖ ⥤ Type`. -/
@[simps]
def functor [HasPullbacks C] : Cᵒᵖ ⥤ Type max u₁ v₁ 
goal: Cᵒᵖ ⥤ Type (max u₁ v₁)

full_name: CategoryTheory.Subobject.functor_map
code: /-- Sending `X : C` to `Subobject X` is a contravariant functor `Cᵒᵖ ⥤ Type`. -/
@[simps]
def functor [HasPullbacks C] : Cᵒᵖ ⥤ Type max u₁ v₁ 
goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (a : CategoryTheory.Subobject (Opposite.unop X)),
  (CategoryTheory.Subobject.functor C).map f a = (CategoryTheory.Subobject.pullback f.unop).obj a

full_name: CategoryTheory.Subobject.inf
code: /-- The functorial infimum on `MonoOver A` descends to an infimum on `Subobject A`. -/
def inf {A : C} : Subobject A ⥤ Subobject A ⥤ Subobject A 
goal: CategoryTheory.Subobject A ⥤ CategoryTheory.Subobject A ⥤ CategoryTheory.Subobject A

full_name: CategoryTheory.Subobject.inf_le_left
code: theorem inf_le_left {A : C} (f g : Subobject A) : (inf.obj f).obj g ≤ f 
goal: (CategoryTheory.Subobject.inf.obj f).obj g ≤ f

full_name: CategoryTheory.Subobject.inf_le_right
code: theorem inf_le_right {A : C} (f g : Subobject A) : (inf.obj f).obj g ≤ g 
goal: (CategoryTheory.Subobject.inf.obj f).obj g ≤ g

full_name: CategoryTheory.Subobject.le_inf
code: theorem le_inf {A : C} (h f g : Subobject A) : h ≤ f → h ≤ g → h ≤ (inf.obj f).obj g 
goal: h ≤ f → h ≤ g → h ≤ (CategoryTheory.Subobject.inf.obj f).obj g

full_name: CategoryTheory.Subobject.semilatticeInf
code: instance semilatticeInf {B : C} : SemilatticeInf (Subobject B) 
goal: SemilatticeInf (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.factors_left_of_inf_factors
code: theorem factors_left_of_inf_factors {A B : C} {X Y : Subobject B} {f : A ⟶ B}
    (h : (X ⊓ Y).Factors f) : X.Factors f 
goal: X.Factors f

full_name: CategoryTheory.Subobject.factors_right_of_inf_factors
code: theorem factors_right_of_inf_factors {A B : C} {X Y : Subobject B} {f : A ⟶ B}
    (h : (X ⊓ Y).Factors f) : Y.Factors f 
goal: Y.Factors f

full_name: CategoryTheory.Subobject.inf_factors
code: @[simp]
theorem inf_factors {A B : C} {X Y : Subobject B} (f : A ⟶ B) :
    (X ⊓ Y).Factors f ↔ X.Factors f ∧ Y.Factors f 
goal: (X ⊓ Y).Factors f ↔ X.Factors f ∧ Y.Factors f

full_name: CategoryTheory.Subobject.inf_arrow_factors_left
code: theorem inf_arrow_factors_left {B : C} (X Y : Subobject B) : X.Factors (X ⊓ Y).arrow 
goal: X.Factors (X ⊓ Y).arrow

full_name: CategoryTheory.Subobject.inf_arrow_factors_right
code: theorem inf_arrow_factors_right {B : C} (X Y : Subobject B) : Y.Factors (X ⊓ Y).arrow 
goal: Y.Factors (X ⊓ Y).arrow

full_name: CategoryTheory.Subobject.finset_inf_factors
code: @[simp]
theorem finset_inf_factors {I : Type*} {A B : C} {s : Finset I} {P : I → Subobject B} (f : A ⟶ B) :
    (s.inf P).Factors f ↔ ∀ i ∈ s, (P i).Factors f 
goal: (s.inf P).Factors f ↔ ∀ i ∈ s, (P i).Factors f

full_name: CategoryTheory.Subobject.finset_inf_arrow_factors
code: theorem finset_inf_arrow_factors {I : Type*} {B : C} (s : Finset I) (P : I → Subobject B) (i : I)
    (m : i ∈ s) : (P i).Factors (s.inf P).arrow 
goal: (P i).Factors (s.inf P).arrow

full_name: CategoryTheory.Subobject.inf_eq_map_pullback'
code: theorem inf_eq_map_pullback' {A : C} (f₁ : MonoOver A) (f₂ : Subobject A) :
    (Subobject.inf.obj (Quotient.mk'' f₁)).obj f₂ =
      (Subobject.map f₁.arrow).obj ((Subobject.pullback f₁.arrow).obj f₂) 
goal: (CategoryTheory.Subobject.inf.obj (Quotient.mk'' f₁)).obj f₂ =
  (CategoryTheory.Subobject.map f₁.arrow).obj ((CategoryTheory.Subobject.pullback f₁.arrow).obj f₂)

full_name: CategoryTheory.Subobject.inf_eq_map_pullback
code: theorem inf_eq_map_pullback {A : C} (f₁ : MonoOver A) (f₂ : Subobject A) :
    (Quotient.mk'' f₁ ⊓ f₂ : Subobject A) = (map f₁.arrow).obj ((pullback f₁.arrow).obj f₂) 
goal: Quotient.mk'' f₁ ⊓ f₂ =
  (CategoryTheory.Subobject.map f₁.arrow).obj ((CategoryTheory.Subobject.pullback f₁.arrow).obj f₂)

full_name: CategoryTheory.Subobject.prod_eq_inf
code: theorem prod_eq_inf {A : C} {f₁ f₂ : Subobject A} [HasBinaryProduct f₁ f₂] :
    (f₁ ⨯ f₂) = f₁ ⊓ f₂ 
goal: (f₁ ⨯ f₂) = f₁ ⊓ f₂

full_name: CategoryTheory.Subobject.inf_def
code: theorem inf_def {B : C} (m m' : Subobject B) : m ⊓ m' = (inf.obj m).obj m' 
goal: m ⊓ m' = (CategoryTheory.Subobject.inf.obj m).obj m'

full_name: CategoryTheory.Subobject.inf_pullback
code: /-- `⊓` commutes with pullback. -/
theorem inf_pullback {X Y : C} (g : X ⟶ Y) (f₁ f₂) :
    (pullback g).obj (f₁ ⊓ f₂) = (pullback g).obj f₁ ⊓ (pullback g).obj f₂ 
goal: (CategoryTheory.Subobject.pullback g).obj (f₁ ⊓ f₂) =
  (CategoryTheory.Subobject.pullback g).obj f₁ ⊓ (CategoryTheory.Subobject.pullback g).obj f₂

full_name: CategoryTheory.Subobject.inf_map
code: /-- `⊓` commutes with map. -/
theorem inf_map {X Y : C} (g : Y ⟶ X) [Mono g] (f₁ f₂) :
    (map g).obj (f₁ ⊓ f₂) = (map g).obj f₁ ⊓ (map g).obj f₂ 
goal: (CategoryTheory.Subobject.map g).obj (f₁ ⊓ f₂) =
  (CategoryTheory.Subobject.map g).obj f₁ ⊓ (CategoryTheory.Subobject.map g).obj f₂

full_name: CategoryTheory.Subobject.sup
code: /-- The functorial supremum on `MonoOver A` descends to a supremum on `Subobject A`. -/
def sup {A : C} : Subobject A ⥤ Subobject A ⥤ Subobject A 
goal: CategoryTheory.Subobject A ⥤ CategoryTheory.Subobject A ⥤ CategoryTheory.Subobject A

full_name: CategoryTheory.Subobject.semilatticeSup
code: instance semilatticeSup {B : C} : SemilatticeSup (Subobject B) 
goal: SemilatticeSup (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.sup_factors_of_factors_left
code: theorem sup_factors_of_factors_left {A B : C} {X Y : Subobject B} {f : A ⟶ B} (P : X.Factors f) :
    (X ⊔ Y).Factors f 
goal: (X ⊔ Y).Factors f

full_name: CategoryTheory.Subobject.sup_factors_of_factors_right
code: theorem sup_factors_of_factors_right {A B : C} {X Y : Subobject B} {f : A ⟶ B} (P : Y.Factors f) :
    (X ⊔ Y).Factors f 
goal: (X ⊔ Y).Factors f

full_name: CategoryTheory.Subobject.finset_sup_factors
code: theorem finset_sup_factors {I : Type*} {A B : C} {s : Finset I} {P : I → Subobject B} {f : A ⟶ B}
    (h : ∃ i ∈ s, (P i).Factors f) : (s.sup P).Factors f 
goal: (s.sup P).Factors f

full_name: CategoryTheory.Subobject.boundedOrder
code: instance boundedOrder [HasInitial C] [InitialMonoClass C] {B : C} : BoundedOrder (Subobject B) 
goal: BoundedOrder (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.instLattice
code: instance {B : C} : Lattice (Subobject B) 
goal: Lattice (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.wideCospan
code: /-- The "wide cospan" diagram, with a small indexing type, constructed from a set of subobjects.
(This is just the diagram of all the subobjects pasted together, but using `WellPowered C`
to make the diagram small.)
-/
def wideCospan {A : C} (s : Set (Subobject A)) : WidePullbackShape (equivShrink _ '' s) ⥤ C 
goal: CategoryTheory.Limits.WidePullbackShape ↑(⇑(equivShrink (CategoryTheory.Subobject A)) '' s) ⥤ C

full_name: CategoryTheory.Subobject.wideCospan_map_term
code: @[simp]
theorem wideCospan_map_term {A : C} (s : Set (Subobject A)) (j) :
    (wideCospan s).map (WidePullbackShape.Hom.term j) =
      ((equivShrink (Subobject A)).symm j).arrow 
goal: (CategoryTheory.Subobject.wideCospan s).map (CategoryTheory.Limits.WidePullbackShape.Hom.term j) =
  ((equivShrink (CategoryTheory.Subobject A)).symm ↑j).arrow

full_name: CategoryTheory.Subobject.leInfCone
code: /-- Auxiliary construction of a cone for `le_inf`. -/
def leInfCone {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    Cone (wideCospan s) 
goal: CategoryTheory.Limits.Cone (CategoryTheory.Subobject.wideCospan s)

full_name: CategoryTheory.Subobject.leInfCone_π_app_none
code: @[simp]
theorem leInfCone_π_app_none {A : C} (s : Set (Subobject A)) (f : Subobject A)
    (k : ∀ g ∈ s, f ≤ g) : (leInfCone s f k).π.app none = f.arrow 
goal: (CategoryTheory.Subobject.leInfCone s f k).π.app none = f.arrow

full_name: CategoryTheory.Subobject.widePullback
code: /-- The limit of `wideCospan s`. (This will be the supremum of the set of subobjects.)
-/
def widePullback {A : C} (s : Set (Subobject A)) : C 
goal: C

full_name: CategoryTheory.Subobject.widePullbackι
code: /-- The inclusion map from `widePullback s` to `A`
-/
def widePullbackι {A : C} (s : Set (Subobject A)) : widePullback s ⟶ A 
goal: CategoryTheory.Subobject.widePullback s ⟶ A

full_name: CategoryTheory.Subobject.widePullbackι_mono
code: instance widePullbackι_mono {A : C} (s : Set (Subobject A)) : Mono (widePullbackι s) 
goal: CategoryTheory.Mono (CategoryTheory.Subobject.widePullbackι s)

full_name: CategoryTheory.Subobject.sInf
code: /-- When `[WellPowered C]` and `[HasWidePullbacks C]`, `Subobject A` has arbitrary infimums.
-/
def sInf {A : C} (s : Set (Subobject A)) : Subobject A 
goal: CategoryTheory.Subobject A

full_name: CategoryTheory.Subobject.sInf_le
code: theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f 
goal: CategoryTheory.Subobject.sInf s ≤ f

full_name: CategoryTheory.Subobject.le_sInf
code: theorem le_sInf {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    f ≤ sInf s 
goal: f ≤ CategoryTheory.Subobject.sInf s

full_name: CategoryTheory.Subobject.completeSemilatticeInf
code: instance completeSemilatticeInf {B : C} : CompleteSemilatticeInf (Subobject B) 
goal: CompleteSemilatticeInf (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.smallCoproductDesc
code: /-- The universal morphism out of the coproduct of a set of subobjects,
after using `[WellPowered C]` to reindex by a small type.
-/
def smallCoproductDesc {A : C} (s : Set (Subobject A)) 
goal: (∐ fun j => CategoryTheory.Subobject.underlying.obj ((equivShrink (CategoryTheory.Subobject A)).symm ↑j)) ⟶ A

full_name: CategoryTheory.Subobject.sSup
code: /-- When `[WellPowered C] [HasImages C] [HasCoproducts C]`,
`Subobject A` has arbitrary supremums. -/
def sSup {A : C} (s : Set (Subobject A)) : Subobject A 
goal: CategoryTheory.Subobject A

full_name: CategoryTheory.Subobject.le_sSup
code: theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s 
goal: f ≤ CategoryTheory.Subobject.sSup s

full_name: CategoryTheory.Subobject.symm_apply_mem_iff_mem_image
code: theorem symm_apply_mem_iff_mem_image {α β : Type*} (e : α ≃ β) (s : Set α) (x : β) :
    e.symm x ∈ s ↔ x ∈ e '' s 
goal: e.symm x ∈ s ↔ x ∈ ⇑e '' s

full_name: CategoryTheory.Subobject.sSup_le
code: theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f 
goal: CategoryTheory.Subobject.sSup s ≤ f

full_name: CategoryTheory.Subobject.completeSemilatticeSup
code: instance completeSemilatticeSup {B : C} : CompleteSemilatticeSup (Subobject B) 
goal: CompleteSemilatticeSup (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.instCompleteLattice
code: instance {B : C} : CompleteLattice (Subobject B) 
goal: CompleteLattice (CategoryTheory.Subobject B)

full_name: CategoryTheory.Subobject.nontrivial_of_not_isZero
code: /-- A nonzero object has nontrivial subobject lattice. -/
theorem nontrivial_of_not_isZero {X : C} (h : ¬IsZero X) : Nontrivial (Subobject X) 
goal: Nontrivial (CategoryTheory.Subobject X)

full_name: CategoryTheory.Subobject.subobjectOrderIso
code: /-- The subobject lattice of a subobject `Y` is order isomorphic to the interval `Set.Iic Y`. -/
def subobjectOrderIso {X : C} (Y : Subobject X) : Subobject (Y : C) ≃o Set.Iic Y 
goal: CategoryTheory.Subobject (CategoryTheory.Subobject.underlying.obj Y) ≃o ↑(Set.Iic Y)