l3lab/ntp-mathlib huggingface dataset:
instance widePullbackι_mono {A : C} (s : Set (Subobject A)) : Mono (widePullbackι s) :=
  ⟨fun u v h =>
    limit.hom_ext fun j => by
      cases j
      · 

Proof state:
case none
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
Z✝ : C
u v : Z✝ ⟶ widePullback s
h : u ≫ widePullbackι s = v ≫ widePullbackι s
⊢ u ≫ limit.π (wideCospan s) none = v ≫ limit.π (wideCospan s) none

Next tactic:
exact h
instance widePullbackι_mono {A : C} (s : Set (Subobject A)) : Mono (widePullbackι s) :=
  ⟨fun u v h =>
    limit.hom_ext fun j => by
      cases j
      · exact h
      · 

Proof state:
case some
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
Z✝ : C
u v : Z✝ ⟶ widePullback s
h : u ≫ widePullbackι s = v ≫ widePullbackι s
val✝ : ↑(⇑(equivShrink (Subobject A)) '' s)
⊢ u ≫ limit.π (wideCospan s) (some val✝) = v ≫ limit.π (wideCospan s) (some val✝)

Next tactic:
apply (cancel_mono ((equivShrink (Subobject A)).symm _).arrow).1
instance widePullbackι_mono {A : C} (s : Set (Subobject A)) : Mono (widePullbackι s) :=
  ⟨fun u v h =>
    limit.hom_ext fun j => by
      cases j
      · exact h
      · apply (cancel_mono ((equivShrink (Subobject A)).symm _).arrow).1
        

Proof state:
case some
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
Z✝ : C
u v : Z✝ ⟶ widePullback s
h : u ≫ widePullbackι s = v ≫ widePullbackι s
val✝ : ↑(⇑(equivShrink (Subobject A)) '' s)
⊢ (u ≫ limit.π (wideCospan s) (some val✝)) ≫ arrow ((equivShrink (Subobject A)).symm ↑val✝) =
    (v ≫ limit.π (wideCospan s) (some val✝)) ≫ arrow ((equivShrink (Subobject A)).symm ↑val✝)

Next tactic:
rw [assoc, assoc]
instance widePullbackι_mono {A : C} (s : Set (Subobject A)) : Mono (widePullbackι s) :=
  ⟨fun u v h =>
    limit.hom_ext fun j => by
      cases j
      · exact h
      · apply (cancel_mono ((equivShrink (Subobject A)).symm _).arrow).1
        rw [assoc, assoc]
        

Proof state:
case some
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
Z✝ : C
u v : Z✝ ⟶ widePullback s
h : u ≫ widePullbackι s = v ≫ widePullbackι s
val✝ : ↑(⇑(equivShrink (Subobject A)) '' s)
⊢ u ≫ limit.π (wideCospan s) (some val✝) ≫ arrow ((equivShrink (Subobject A)).symm ↑val✝) =
    v ≫ limit.π (wideCospan s) (some val✝) ≫ arrow ((equivShrink (Subobject A)).symm ↑val✝)

Next tactic:
erw [limit.w (wideCospan s) (WidePullbackShape.Hom.term _)]
instance widePullbackι_mono {A : C} (s : Set (Subobject A)) : Mono (widePullbackι s) :=
  ⟨fun u v h =>
    limit.hom_ext fun j => by
      cases j
      · exact h
      · apply (cancel_mono ((equivShrink (Subobject A)).symm _).arrow).1
        rw [assoc, assoc]
        erw [limit.w (wideCospan s) (WidePullbackShape.Hom.term _)]
        

Proof state:
case some
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
Z✝ : C
u v : Z✝ ⟶ widePullback s
h : u ≫ widePullbackι s = v ≫ widePullbackι s
val✝ : ↑(⇑(equivShrink (Subobject A)) '' s)
⊢ u ≫ limit.π (wideCospan s) none = v ≫ limit.π (wideCospan s) none

Next tactic:
exact h
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f := by
  

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ sInf s ≤ f

Next tactic:
fapply le_of_comm
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f := by
  fapply le_of_comm
  · 

Proof state:
case f
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ underlying.obj (sInf s) ⟶ underlying.obj f

Next tactic:
exact (underlyingIso _).hom ≫
      Limits.limit.π (wideCospan s)
        (some ⟨equivShrink (Subobject A) f,
          Set.mem_image_of_mem (equivShrink (Subobject A)) hf⟩) ≫
      eqToHom (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _))
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f := by
  fapply le_of_comm
  · exact (underlyingIso _).hom ≫
      Limits.limit.π (wideCospan s)
        (some ⟨equivShrink (Subobject A) f,
          Set.mem_image_of_mem (equivShrink (Subobject A)) hf⟩) ≫
      eqToHom (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _))
  · 

Proof state:
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ ((underlyingIso (widePullbackι s)).hom ≫
        limit.π (wideCospan s)
            (some
              { val := (equivShrink (Subobject A)) f,
                property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) }) ≫
          eqToHom
            (_ :
              underlying.obj
                  ((equivShrink (Subobject A)).symm
                    ↑{ val := (equivShrink (Subobject A)) f,
                        property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) }) =
                underlying.obj f)) ≫
      arrow f =
    arrow (sInf s)

Next tactic:
dsimp [sInf]
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f := by
  fapply le_of_comm
  · exact (underlyingIso _).hom ≫
      Limits.limit.π (wideCospan s)
        (some ⟨equivShrink (Subobject A) f,
          Set.mem_image_of_mem (equivShrink (Subobject A)) hf⟩) ≫
      eqToHom (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _))
  · dsimp [sInf]
    

Proof state:
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ ((underlyingIso (widePullbackι s)).hom ≫
        limit.π (wideCospan s)
            (some
              { val := (equivShrink (Subobject A)) f,
                property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) }) ≫
          eqToHom
            (_ :
              underlying.obj ((equivShrink (Subobject A)).symm ((equivShrink (Subobject A)) f)) = underlying.obj f)) ≫
      arrow f =
    arrow (mk (widePullbackι s))

Next tactic:
simp only [Category.comp_id, Category.assoc, ← underlyingIso_hom_comp_eq_mk,
      Subobject.arrow_congr, congrArg_mpr_hom_left, Iso.cancel_iso_hom_left]
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f := by
  fapply le_of_comm
  · exact (underlyingIso _).hom ≫
      Limits.limit.π (wideCospan s)
        (some ⟨equivShrink (Subobject A) f,
          Set.mem_image_of_mem (equivShrink (Subobject A)) hf⟩) ≫
      eqToHom (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _))
  · dsimp [sInf]
    simp only [Category.comp_id, Category.assoc, ← underlyingIso_hom_comp_eq_mk,
      Subobject.arrow_congr, congrArg_mpr_hom_left, Iso.cancel_iso_hom_left]
    

Proof state:
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ limit.π (wideCospan s)
        (some
          { val := (equivShrink (Subobject A)) f,
            property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) }) ≫
      eqToHom
          (_ : underlying.obj ((equivShrink (Subobject A)).symm ((equivShrink (Subobject A)) f)) = underlying.obj f) ≫
        arrow f =
    widePullbackι s

Next tactic:
convert limit.w (wideCospan s) (WidePullbackShape.Hom.term _)
theorem sInf_le {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : sInf s ≤ f := by
  fapply le_of_comm
  · exact (underlyingIso _).hom ≫
      Limits.limit.π (wideCospan s)
        (some ⟨equivShrink (Subobject A) f,
          Set.mem_image_of_mem (equivShrink (Subobject A)) hf⟩) ≫
      eqToHom (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _))
  · dsimp [sInf]
    simp only [Category.comp_id, Category.assoc, ← underlyingIso_hom_comp_eq_mk,
      Subobject.arrow_congr, congrArg_mpr_hom_left, Iso.cancel_iso_hom_left]
    convert limit.w (wideCospan s) (WidePullbackShape.Hom.term _)
    

Proof state:
case h.e'_2.h.h.e'_7.h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
e_1✝ : (widePullback s ⟶ A) = (limit (wideCospan s) ⟶ (wideCospan s).obj none)
e_5✝ : A = (wideCospan s).obj none
⊢ eqToHom (_ : underlying.obj ((equivShrink (Subobject A)).symm ((equivShrink (Subobject A)) f)) = underlying.obj f) ≫
      arrow f =
    (wideCospan s).map
      (WidePullbackShape.Hom.term
        { val := (equivShrink (Subobject A)) f,
          property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) })

Next tactic:
aesop_cat
theorem le_sInf {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    f ≤ sInf s := by
  

Proof state:
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ f ≤ sInf s

Next tactic:
fapply le_of_comm
theorem le_sInf {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    f ≤ sInf s := by
  fapply le_of_comm
  · 

Proof state:
case f
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ underlying.obj f ⟶ underlying.obj (sInf s)

Next tactic:
exact Limits.limit.lift _ (leInfCone s f k) ≫ (underlyingIso _).inv
theorem le_sInf {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    f ≤ sInf s := by
  fapply le_of_comm
  · exact Limits.limit.lift _ (leInfCone s f k) ≫ (underlyingIso _).inv
  · 

Proof state:
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ (limit.lift (wideCospan s) (leInfCone s f k) ≫ (underlyingIso (widePullbackι s)).inv) ≫ arrow (sInf s) = arrow f

Next tactic:
dsimp [sInf]
theorem le_sInf {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, f ≤ g) :
    f ≤ sInf s := by
  fapply le_of_comm
  · exact Limits.limit.lift _ (leInfCone s f k) ≫ (underlyingIso _).inv
  · dsimp [sInf]
    

Proof state:
case w
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : WellPowered C
inst✝ : HasWidePullbacks C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, f ≤ g
⊢ (limit.lift (wideCospan s) (leInfCone s f k) ≫ (underlyingIso (widePullbackι s)).inv) ≫ arrow (mk (widePullbackι s)) =
    arrow f

Next tactic:
rw [assoc, underlyingIso_arrow, widePullbackι, limit.lift_π, leInfCone_π_app_none]
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s := by
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ f ≤ sSup s

Next tactic:
fapply le_of_comm
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s := by
  fapply le_of_comm
  · 

Proof state:
case f
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ underlying.obj f ⟶ underlying.obj (sSup s)

Next tactic:
refine' eqToHom _ ≫ Sigma.ι _ ⟨equivShrink (Subobject A) f, by simpa [Set.mem_image] using hf⟩
      ≫ factorThruImage _ ≫ (underlyingIso _).inv
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s := by
  fapply le_of_comm
  · refine' eqToHom _ ≫ Sigma.ι _ ⟨equivShrink (Subobject A) f, by 

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s

Next tactic:
simpa [Set.mem_image] using hf
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s := by
  fapply le_of_comm
  · refine' eqToHom _ ≫ Sigma.ι _ ⟨equivShrink (Subobject A) f, by simpa [Set.mem_image] using hf⟩
      ≫ factorThruImage _ ≫ (underlyingIso _).inv
    

Proof state:
case f
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ underlying.obj f =
    underlying.obj
      ((equivShrink (Subobject A)).symm
        ↑{ val := (equivShrink (Subobject A)) f,
            property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) })

Next tactic:
exact (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _).symm)
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s := by
  fapply le_of_comm
  · refine' eqToHom _ ≫ Sigma.ι _ ⟨equivShrink (Subobject A) f, by simpa [Set.mem_image] using hf⟩
      ≫ factorThruImage _ ≫ (underlyingIso _).inv
    exact (congr_arg (fun X : Subobject A => (X : C)) (Equiv.symm_apply_apply _ _).symm)
  · 

Proof state:
case w
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
hf : f ∈ s
⊢ (eqToHom
          (_ :
            underlying.obj f =
              underlying.obj
                ((equivShrink (Subobject A)).symm
                  ↑{ val := (equivShrink (Subobject A)) f,
                      property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) })) ≫
        Sigma.ι (fun j => underlying.obj ((equivShrink (Subobject A)).symm ↑j))
            { val := (equivShrink (Subobject A)) f,
              property := (_ : (equivShrink (Subobject A)) f ∈ ⇑(equivShrink (Subobject A)) '' s) } ≫
          factorThruImage (smallCoproductDesc s) ≫ (underlyingIso (image.ι (smallCoproductDesc s))).inv) ≫
      arrow (sSup s) =
    arrow f

Next tactic:
simp [sSup, smallCoproductDesc]
theorem symm_apply_mem_iff_mem_image {α β : Type*} (e : α ≃ β) (s : Set α) (x : β) :
    e.symm x ∈ s ↔ x ∈ e '' s :=
  ⟨fun h => ⟨e.symm x, h, by 

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
x : β
h : e.symm x ∈ s
⊢ e (e.symm x) = x

Next tactic:
simp
theorem symm_apply_mem_iff_mem_image {α β : Type*} (e : α ≃ β) (s : Set α) (x : β) :
    e.symm x ∈ s ↔ x ∈ e '' s :=
  ⟨fun h => ⟨e.symm x, h, by simp⟩, by
    

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
x : β
⊢ x ∈ ⇑e '' s → e.symm x ∈ s

Next tactic:
rintro ⟨a, m, rfl⟩
theorem symm_apply_mem_iff_mem_image {α β : Type*} (e : α ≃ β) (s : Set α) (x : β) :
    e.symm x ∈ s ↔ x ∈ e '' s :=
  ⟨fun h => ⟨e.symm x, h, by simp⟩, by
    rintro ⟨a, m, rfl⟩
    

Proof state:
case intro.intro
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
a : α
m : a ∈ s
⊢ e.symm (e a) ∈ s

Next tactic:
simpa using m
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  

Proof state:
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
⊢ sSup s ≤ f

Next tactic:
fapply le_of_comm
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · 

Proof state:
case f
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
⊢ underlying.obj (sSup s) ⟶ underlying.obj f

Next tactic:
refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · 

Proof state:
case f.refine'_1
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
⊢ (∐ fun j => underlying.obj ((equivShrink (Subobject A)).symm ↑j)) ⟶ underlying.obj f

Next tactic:
refine' Sigma.desc _
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      

Proof state:
case f.refine'_1
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
⊢ (b : ↑(⇑(equivShrink (Subobject A)) '' s)) → underlying.obj ((equivShrink (Subobject A)).symm ↑b) ⟶ underlying.obj f

Next tactic:
rintro ⟨g, m⟩
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      rintro ⟨g, m⟩
      

Proof state:
case f.refine'_1.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
g : Shrink.{v₁, max u₁ v₁} (Subobject A)
m : g ∈ ⇑(equivShrink (Subobject A)) '' s
⊢ underlying.obj ((equivShrink (Subobject A)).symm ↑{ val := g, property := m }) ⟶ underlying.obj f

Next tactic:
refine' underlying.map (homOfLE (k _ _))
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      rintro ⟨g, m⟩
      refine' underlying.map (homOfLE (k _ _))
      

Proof state:
case f.refine'_1.mk
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
g : Shrink.{v₁, max u₁ v₁} (Subobject A)
m : g ∈ ⇑(equivShrink (Subobject A)) '' s
⊢ (equivShrink (Subobject A)).symm ↑{ val := g, property := m } ∈ s

Next tactic:
simpa using m
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      rintro ⟨g, m⟩
      refine' underlying.map (homOfLE (k _ _))
      simpa using m
    · 

Proof state:
case f.refine'_2
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
⊢ (Sigma.desc fun b =>
        Subtype.casesOn b fun g m =>
          underlying.map (homOfLE (_ : (equivShrink (Subobject A)).symm ↑{ val := g, property := m } ≤ f))) ≫
      arrow f =
    smallCoproductDesc s

Next tactic:
ext
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      rintro ⟨g, m⟩
      refine' underlying.map (homOfLE (k _ _))
      simpa using m
    · ext
      

Proof state:
case f.refine'_2.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
b✝ : ↑(⇑(equivShrink (Subobject A)) '' s)
⊢ Sigma.ι (fun j => underlying.obj ((equivShrink (Subobject A)).symm ↑j)) b✝ ≫
      (Sigma.desc fun b =>
          Subtype.casesOn b fun g m =>
            underlying.map (homOfLE (_ : (equivShrink (Subobject A)).symm ↑{ val := g, property := m } ≤ f))) ≫
        arrow f =
    Sigma.ι (fun j => underlying.obj ((equivShrink (Subobject A)).symm ↑j)) b✝ ≫ smallCoproductDesc s

Next tactic:
dsimp [smallCoproductDesc]
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      rintro ⟨g, m⟩
      refine' underlying.map (homOfLE (k _ _))
      simpa using m
    · ext
      dsimp [smallCoproductDesc]
      

Proof state:
case f.refine'_2.h
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
b✝ : ↑(⇑(equivShrink (Subobject A)) '' s)
⊢ Sigma.ι (fun j => underlying.obj ((equivShrink (Subobject A)).symm ↑j)) b✝ ≫
      (Sigma.desc fun b => underlying.map (homOfLE (_ : (equivShrink (Subobject A)).symm ↑b ≤ f))) ≫ arrow f =
    Sigma.ι (fun j => underlying.obj ((equivShrink (Subobject A)).symm ↑j)) b✝ ≫
      Sigma.desc fun j => arrow ((equivShrink (Subobject A)).symm ↑j)

Next tactic:
simp
theorem sSup_le {A : C} (s : Set (Subobject A)) (f : Subobject A) (k : ∀ g ∈ s, g ≤ f) :
    sSup s ≤ f := by
  fapply le_of_comm
  · refine'(underlyingIso _).hom ≫ image.lift ⟨_, f.arrow, _, _⟩
    · refine' Sigma.desc _
      rintro ⟨g, m⟩
      refine' underlying.map (homOfLE (k _ _))
      simpa using m
    · ext
      dsimp [smallCoproductDesc]
      simp
  · 

Proof state:
case w
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
inst✝² : WellPowered C
inst✝¹ : HasCoproducts C
inst✝ : HasImages C
A : C
s : Set (Subobject A)
f : Subobject A
k : ∀ g ∈ s, g ≤ f
⊢ ((underlyingIso (image.ι (smallCoproductDesc s))).hom ≫
        image.lift
          (MonoFactorisation.mk (underlying.obj f) (arrow f)
            (Sigma.desc fun b =>
              Subtype.casesOn b fun g m =>
                underlying.map (homOfLE (_ : (equivShrink (Subobject A)).symm ↑{ val := g, property := m } ≤ f))))) ≫
      arrow f =
    arrow (sSup s)

Next tactic:
dsimp [sSup]