File: Mathlib/CategoryTheory/Limits/Shapes/Types.lean

full_name: CategoryTheory.Limits.Types.instHasProductsType
code: instance : HasProducts.{v} (Type v) 
goal: CategoryTheory.Limits.HasProducts (Type v)

full_name: CategoryTheory.Limits.Types.pi_lift_π_apply
code: /-- A restatement of `Types.Limit.lift_π_apply` that uses `Pi.π` and `Pi.lift`. -/
@[simp 1001]
theorem pi_lift_π_apply {β : Type v} [Small.{u} β] (f : β → Type u) {P : Type u}
    (s : ∀ b, P ⟶ f b) (b : β) (x : P) :
    (Pi.π f b : (piObj f) → f b) (@Pi.lift β _ _ f _ P s x) = s b x 
goal: CategoryTheory.Limits.Pi.π f b (CategoryTheory.Limits.Pi.lift s x) = s b x

full_name: CategoryTheory.Limits.Types.pi_lift_π_apply'
code: /-- A restatement of `Types.Limit.lift_π_apply` that uses `Pi.π` and `Pi.lift`,
with specialized universes. -/
theorem pi_lift_π_apply' {β : Type v} (f : β → Type v) {P : Type v}
    (s : ∀ b, P ⟶ f b) (b : β) (x : P) :
    (Pi.π f b : (piObj f) → f b) (@Pi.lift β _ _ f _ P s x) = s b x 
goal: CategoryTheory.Limits.Pi.π f b (CategoryTheory.Limits.Pi.lift s x) = s b x

full_name: CategoryTheory.Limits.Types.pi_map_π_apply
code: /-- A restatement of `Types.Limit.map_π_apply` that uses `Pi.π` and `Pi.map`. -/
@[simp 1001]
theorem pi_map_π_apply {β : Type v} [Small.{u} β] {f g : β → Type u}
    (α : ∀ j, f j ⟶ g j) (b : β) (x) :
    (Pi.π g b : ∏ᶜ g → g b) (Pi.map α x) = α b ((Pi.π f b : ∏ᶜ f → f b) x) 
goal: CategoryTheory.Limits.Pi.π g b (CategoryTheory.Limits.Pi.map α x) = α b (CategoryTheory.Limits.Pi.π f b x)

full_name: CategoryTheory.Limits.Types.pi_map_π_apply'
code: /-- A restatement of `Types.Limit.map_π_apply` that uses `Pi.π` and `Pi.map`,
with specialized universes. -/
theorem pi_map_π_apply' {β : Type v} {f g : β → Type v} (α : ∀ j, f j ⟶ g j) (b : β) (x) :
    (Pi.π g b : ∏ᶜ g → g b) (Pi.map α x) = α b ((Pi.π f b : ∏ᶜ f → f b) x) 
goal: CategoryTheory.Limits.Pi.π g b (CategoryTheory.Limits.Pi.map α x) = α b (CategoryTheory.Limits.Pi.π f b x)

full_name: CategoryTheory.Limits.Types.terminalLimitCone
code: /-- The category of types has `PUnit` as a terminal object. -/
def terminalLimitCone : Limits.LimitCone (Functor.empty (Type u)) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Functor.empty (Type u))

full_name: CategoryTheory.Limits.Types.terminalIso
code: /-- The terminal object in `Type u` is `PUnit`. -/
noncomputable def terminalIso : ⊤_ Type u ≅ PUnit 
goal: ⊤_ Type u ≅ PUnit.{u + 1}

full_name: CategoryTheory.Limits.Types.isTerminalPunit
code: /-- The terminal object in `Type u` is `PUnit`. -/
noncomputable def isTerminalPunit : IsTerminal (PUnit : Type u) 
goal: CategoryTheory.Limits.IsTerminal PUnit.{u + 1}

full_name: CategoryTheory.Limits.Types.instInhabitedTerminalType
code: noncomputable instance : Inhabited (⊤_ (Type u)) 
goal: Inhabited (⊤_ Type u)

full_name: CategoryTheory.Limits.Types.instSubsingletonTerminalType
code: instance : Subsingleton (⊤_ (Type u)) 
goal: Subsingleton (⊤_ Type u)

full_name: CategoryTheory.Limits.Types.instUniqueTerminalType
code: noncomputable instance : Unique (⊤_ (Type u)) 
goal: Unique (⊤_ Type u)

full_name: CategoryTheory.Limits.Types.isTerminalEquivUnique
code: /-- A type is terminal if and only if it contains exactly one element. -/
noncomputable def isTerminalEquivUnique (X : Type u) : IsTerminal X ≃ Unique X 
goal: CategoryTheory.Limits.IsTerminal X ≃ Unique X

full_name: CategoryTheory.Limits.Types.isTerminalEquivIsoPUnit
code: /-- A type is terminal if and only if it is isomorphic to `PUnit`. -/
noncomputable def isTerminalEquivIsoPUnit (X : Type u) : IsTerminal X ≃ (X ≅ PUnit) 
goal: CategoryTheory.Limits.IsTerminal X ≃ (X ≅ PUnit.{u + 1})

full_name: CategoryTheory.Limits.Types.initialColimitCocone
code: /-- The category of types has `PEmpty` as an initial object. -/
def initialColimitCocone : Limits.ColimitCocone (Functor.empty (Type u)) 
goal: CategoryTheory.Limits.ColimitCocone (CategoryTheory.Functor.empty (Type u))

full_name: CategoryTheory.Limits.Types.initialIso
code: /-- The initial object in `Type u` is `PEmpty`. -/
noncomputable def initialIso : ⊥_ Type u ≅ PEmpty 
goal: ⊥_ Type u ≅ PEmpty.{u + 1}

full_name: CategoryTheory.Limits.Types.isInitialPunit
code: /-- The initial object in `Type u` is `PEmpty`. -/
noncomputable def isInitialPunit : IsInitial (PEmpty : Type u) 
goal: CategoryTheory.Limits.IsInitial PEmpty.{u + 1}

full_name: CategoryTheory.Limits.Types.initial_iff_empty
code: /-- An object in `Type u` is initial if and only if it is empty. -/
lemma initial_iff_empty (X : Type u) : Nonempty (IsInitial X) ↔ IsEmpty X 
goal: Nonempty (CategoryTheory.Limits.IsInitial X) ↔ IsEmpty X

full_name: CategoryTheory.Limits.Types.binaryProductCone
code: /-- The product type `X × Y` forms a cone for the binary product of `X` and `Y`. -/
@[simps! pt]
def binaryProductCone (X Y : Type u) : BinaryFan X Y 
goal: CategoryTheory.Limits.BinaryFan X Y

full_name: CategoryTheory.Limits.Types.binaryProductCone_pt
code: /-- The product type `X × Y` forms a cone for the binary product of `X` and `Y`. -/
@[simps! pt]
def binaryProductCone (X Y : Type u) : BinaryFan X Y 
goal: (CategoryTheory.Limits.Types.binaryProductCone X Y).pt = (X × Y)

full_name: CategoryTheory.Limits.Types.binaryProductCone_fst
code: @[simp]
theorem binaryProductCone_fst (X Y : Type u) : (binaryProductCone X Y).fst = _root_.Prod.fst 
goal: (CategoryTheory.Limits.Types.binaryProductCone X Y).fst = Prod.fst

full_name: CategoryTheory.Limits.Types.binaryProductCone_snd
code: @[simp]
theorem binaryProductCone_snd (X Y : Type u) : (binaryProductCone X Y).snd = _root_.Prod.snd 
goal: (CategoryTheory.Limits.Types.binaryProductCone X Y).snd = Prod.snd

full_name: CategoryTheory.Limits.Types.binaryProductLimit_lift
code: /-- The product type `X × Y` is a binary product for `X` and `Y`. -/
@[simps]
def binaryProductLimit (X Y : Type u) : IsLimit (binaryProductCone X Y) 
goal: (CategoryTheory.Limits.Types.binaryProductLimit X Y).lift s x = (s.fst x, s.snd x)

full_name: CategoryTheory.Limits.Types.binaryProductLimit
code: /-- The product type `X × Y` is a binary product for `X` and `Y`. -/
@[simps]
def binaryProductLimit (X Y : Type u) : IsLimit (binaryProductCone X Y) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Types.binaryProductCone X Y)

full_name: CategoryTheory.Limits.Types.binaryProductLimitCone
code: /-- The category of types has `X × Y`, the usual cartesian product,
as the binary product of `X` and `Y`.
-/
@[simps]
def binaryProductLimitCone (X Y : Type u) : Limits.LimitCone (pair X Y) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)

full_name: CategoryTheory.Limits.Types.binaryProductLimitCone_cone
code: /-- The category of types has `X × Y`, the usual cartesian product,
as the binary product of `X` and `Y`.
-/
@[simps]
def binaryProductLimitCone (X Y : Type u) : Limits.LimitCone (pair X Y) 
goal: (CategoryTheory.Limits.Types.binaryProductLimitCone X Y).cone = CategoryTheory.Limits.Types.binaryProductCone X Y

full_name: CategoryTheory.Limits.Types.binaryProductLimitCone_isLimit
code: /-- The category of types has `X × Y`, the usual cartesian product,
as the binary product of `X` and `Y`.
-/
@[simps]
def binaryProductLimitCone (X Y : Type u) : Limits.LimitCone (pair X Y) 
goal: (CategoryTheory.Limits.Types.binaryProductLimitCone X Y).isLimit = CategoryTheory.Limits.Types.binaryProductLimit X Y

full_name: CategoryTheory.Limits.Types.binaryProductIso
code: /-- The categorical binary product in `Type u` is cartesian product. -/
noncomputable def binaryProductIso (X Y : Type u) : Limits.prod X Y ≅ X × Y 
goal: X ⨯ Y ≅ X × Y

full_name: CategoryTheory.Limits.Types.binaryProductIso_hom_comp_fst
code: @[elementwise (attr := simp)]
theorem binaryProductIso_hom_comp_fst (X Y : Type u) :
    (binaryProductIso X Y).hom ≫ _root_.Prod.fst = Limits.prod.fst 
goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).hom ≫ Prod.fst = CategoryTheory.Limits.prod.fst

full_name: CategoryTheory.Limits.Types.binaryProductIso_hom_comp_snd
code: @[elementwise (attr := simp)]
theorem binaryProductIso_hom_comp_snd (X Y : Type u) :
    (binaryProductIso X Y).hom ≫ _root_.Prod.snd = Limits.prod.snd 
goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).hom ≫ Prod.snd = CategoryTheory.Limits.prod.snd

full_name: CategoryTheory.Limits.Types.binaryProductIso_inv_comp_fst
code: @[elementwise (attr := simp)]
theorem binaryProductIso_inv_comp_fst (X Y : Type u) :
    (binaryProductIso X Y).inv ≫ Limits.prod.fst = _root_.Prod.fst 
goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).inv ≫ CategoryTheory.Limits.prod.fst = Prod.fst

full_name: CategoryTheory.Limits.Types.binaryProductIso_inv_comp_snd
code: @[elementwise (attr := simp)]
theorem binaryProductIso_inv_comp_snd (X Y : Type u) :
    (binaryProductIso X Y).inv ≫ Limits.prod.snd = _root_.Prod.snd 
goal: (CategoryTheory.Limits.Types.binaryProductIso X Y).inv ≫ CategoryTheory.Limits.prod.snd = Prod.snd

full_name: CategoryTheory.Limits.Types.binaryProductFunctor_obj_map
code: /-- The functor which sends `X, Y` to the product type `X × Y`. -/
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
goal: ∀ (a : (CategoryTheory.Limits.BinaryFan.mk Prod.fst (Prod.snd ≫ f)).pt),
  (CategoryTheory.Limits.Types.binaryProductFunctor.obj X).map f a =
    (CategoryTheory.Limits.Types.binaryProductLimit X Y₂).lift
      (CategoryTheory.Limits.BinaryFan.mk Prod.fst (Prod.snd ≫ f)) a

full_name: CategoryTheory.Limits.Types.binaryProductFunctor
code: /-- The functor which sends `X, Y` to the product type `X × Y`. -/
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
goal: Type u ⥤ Type u ⥤ Type u

full_name: CategoryTheory.Limits.Types.binaryProductFunctor_obj_obj
code: /-- The functor which sends `X, Y` to the product type `X × Y`. -/
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
goal: (CategoryTheory.Limits.Types.binaryProductFunctor.obj X).obj Y = (X × Y)

full_name: CategoryTheory.Limits.Types.binaryProductFunctor_map_app
code: /-- The functor which sends `X, Y` to the product type `X × Y`. -/
@[simps]
def binaryProductFunctor : Type u ⥤ Type u ⥤ Type u 
goal: ∀ (a : (CategoryTheory.Limits.BinaryFan.mk (Prod.fst ≫ f) Prod.snd).pt),
  (CategoryTheory.Limits.Types.binaryProductFunctor.map f).app Y a =
    (CategoryTheory.Limits.Types.binaryProductLimit X₂ Y).lift
      (CategoryTheory.Limits.BinaryFan.mk (Prod.fst ≫ f) Prod.snd) a

full_name: CategoryTheory.Limits.Types.binaryProductIsoProd
code: /-- The product functor given by the instance `HasBinaryProducts (Type u)` is isomorphic to the
explicit binary product functor given by the product type.
-/
noncomputable def binaryProductIsoProd : binaryProductFunctor ≅ (prod.functor : Type u ⥤ _) 
goal: CategoryTheory.Limits.Types.binaryProductFunctor ≅ CategoryTheory.Limits.prod.functor

full_name: CategoryTheory.Limits.Types.binaryCoproductCocone
code: /-- The sum type `X ⊕ Y` forms a cocone for the binary coproduct of `X` and `Y`. -/
@[simps!]
def binaryCoproductCocone (X Y : Type u) : Cocone (pair X Y) 
goal: CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)

full_name: CategoryTheory.Limits.Types.binaryCoproductCocone_pt
code: /-- The sum type `X ⊕ Y` forms a cocone for the binary coproduct of `X` and `Y`. -/
@[simps!]
def binaryCoproductCocone (X Y : Type u) : Cocone (pair X Y) 
goal: (CategoryTheory.Limits.Types.binaryCoproductCocone X Y).pt = (X ⊕ Y)

full_name: CategoryTheory.Limits.Types.binaryCoproductCocone_ι_app
code: /-- The sum type `X ⊕ Y` forms a cocone for the binary coproduct of `X` and `Y`. -/
@[simps!]
def binaryCoproductCocone (X Y : Type u) : Cocone (pair X Y) 
goal: ∀ (x : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) (a : (CategoryTheory.Limits.pair X Y).obj x),
  (CategoryTheory.Limits.Types.binaryCoproductCocone X Y).ι.app x a =
    (match x.as with
      | CategoryTheory.Limits.WalkingPair.left => Sum.inl
      | CategoryTheory.Limits.WalkingPair.right => Sum.inr)
      a

full_name: CategoryTheory.Limits.Types.binaryCoproductColimit
code: /-- The sum type `X ⊕ Y` is a binary coproduct for `X` and `Y`. -/
@[simps]
def binaryCoproductColimit (X Y : Type u) : IsColimit (binaryCoproductCocone X Y) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.binaryCoproductCocone X Y)

full_name: CategoryTheory.Limits.Types.binaryCoproductColimit_desc
code: /-- The sum type `X ⊕ Y` is a binary coproduct for `X` and `Y`. -/
@[simps]
def binaryCoproductColimit (X Y : Type u) : IsColimit (binaryCoproductCocone X Y) 
goal: ∀ (a : X ⊕ Y), (CategoryTheory.Limits.Types.binaryCoproductColimit X Y).desc s a = Sum.elim s.inl s.inr a

full_name: CategoryTheory.Limits.Types.binaryCoproductColimitCocone
code: /-- The category of types has `X ⊕ Y`,
as the binary coproduct of `X` and `Y`.
-/
def binaryCoproductColimitCocone (X Y : Type u) : Limits.ColimitCocone (pair X Y) 
goal: CategoryTheory.Limits.ColimitCocone (CategoryTheory.Limits.pair X Y)

full_name: CategoryTheory.Limits.Types.binaryCoproductIso
code: /-- The categorical binary coproduct in `Type u` is the sum `X ⊕ Y`. -/
noncomputable def binaryCoproductIso (X Y : Type u) : Limits.coprod X Y ≅ X ⊕ Y 
goal: X ⨿ Y ≅ X ⊕ Y

full_name: CategoryTheory.Limits.Types.binaryCoproductIso_inl_comp_hom
code: @[elementwise (attr := simp)]
theorem binaryCoproductIso_inl_comp_hom (X Y : Type u) :
    Limits.coprod.inl ≫ (binaryCoproductIso X Y).hom = Sum.inl 
goal: CategoryTheory.Limits.coprod.inl ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).hom = Sum.inl

full_name: CategoryTheory.Limits.Types.binaryCoproductIso_inr_comp_hom
code: @[elementwise (attr := simp)]
theorem binaryCoproductIso_inr_comp_hom (X Y : Type u) :
    Limits.coprod.inr ≫ (binaryCoproductIso X Y).hom = Sum.inr 
goal: CategoryTheory.Limits.coprod.inr ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).hom = Sum.inr

full_name: CategoryTheory.Limits.Types.binaryCoproductIso_inl_comp_inv
code: @[elementwise (attr := simp)]
theorem binaryCoproductIso_inl_comp_inv (X Y : Type u) :
    ↾(Sum.inl : X ⟶ X ⊕ Y) ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inl 
goal: ↾Sum.inl ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).inv = CategoryTheory.Limits.coprod.inl

full_name: CategoryTheory.Limits.Types.binaryCoproductIso_inr_comp_inv
code: @[elementwise (attr := simp)]
theorem binaryCoproductIso_inr_comp_inv (X Y : Type u) :
    ↾(Sum.inr : Y ⟶ X ⊕ Y) ≫ (binaryCoproductIso X Y).inv = Limits.coprod.inr 
goal: ↾Sum.inr ≫ (CategoryTheory.Limits.Types.binaryCoproductIso X Y).inv = CategoryTheory.Limits.coprod.inr

full_name: CategoryTheory.Limits.Types.binaryCofan_isColimit_iff
code: theorem binaryCofan_isColimit_iff {X Y : Type u} (c : BinaryCofan X Y) :
    Nonempty (IsColimit c) ↔
      Injective c.inl ∧ Injective c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr) 
goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔
  Function.Injective c.inl ∧ Function.Injective c.inr ∧ IsCompl (Set.range c.inl) (Set.range c.inr)

full_name: CategoryTheory.Limits.Types.isCoprodOfMono
code: /-- Any monomorphism in `Type` is a coproduct injection. -/
noncomputable def isCoprodOfMono {X Y : Type u} (f : X ⟶ Y) [Mono f] :
    IsColimit (BinaryCofan.mk f (Subtype.val : ↑(Set.range f)ᶜ → Y)) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk f Subtype.val)

full_name: CategoryTheory.Limits.Types.productLimitCone
code: /--
The category of types has `Π j, f j` as the product of a type family `f : J → TypeMax.{v, u}`.
-/
def productLimitCone {J : Type v} (F : J → TypeMax.{v, u}) :
    Limits.LimitCone (Discrete.functor F) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor F)

full_name: CategoryTheory.Limits.Types.productIso
code: /-- The categorical product in `TypeMax.{v, u}` is the type theoretic product `Π j, F j`. -/
noncomputable def productIso {J : Type v} (F : J → TypeMax.{v, u}) : ∏ᶜ F ≅ ∀ j, F j 
goal: ∏ᶜ F ≅ (j : J) → F j

full_name: CategoryTheory.Limits.Types.productIso_hom_comp_eval
code: @[simp]
theorem productIso_hom_comp_eval {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    ((productIso.{v, u} F).hom ≫ fun f => f j) = Pi.π F j 
goal: ((CategoryTheory.Limits.Types.productIso F).hom ≫ fun f => f j) = CategoryTheory.Limits.Pi.π F j

full_name: CategoryTheory.Limits.Types.productIso_hom_comp_eval_apply
code: @[simp]
theorem productIso_hom_comp_eval_apply {J : Type v} (F : J → TypeMax.{v, u}) (j : J) (x) :
    ((productIso.{v, u} F).hom x) j = Pi.π F j x 
goal: (CategoryTheory.Limits.Types.productIso F).hom x j = CategoryTheory.Limits.Pi.π F j x

full_name: CategoryTheory.Limits.Types.productIso_inv_comp_π
code: @[elementwise (attr := simp)]
theorem productIso_inv_comp_π {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    (productIso.{v, u} F).inv ≫ Pi.π F j = fun f => f j 
goal: (CategoryTheory.Limits.Types.productIso F).inv ≫ CategoryTheory.Limits.Pi.π F j = fun f => f j

full_name: CategoryTheory.Limits.Types.Small.productLimitCone
code: /--
A variant of `productLimitCone` using a `Small` hypothesis rather than a function to `TypeMax`.
-/
noncomputable def productLimitCone :
    Limits.LimitCone (Discrete.functor F) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor F)

full_name: CategoryTheory.Limits.Types.Small.productIso
code: /-- The categorical product in `Type u` indexed in `Type v`
is the type theoretic product `Π j, F j`, after shrinking back to `Type u`. -/
noncomputable def productIso :
    (∏ᶜ F : Type u) ≅ Shrink.{u} (∀ j, F j) 
goal: ∏ᶜ F ≅ Shrink.{u, max u v} ((j : J) → F j)

full_name: CategoryTheory.Limits.Types.Small.productIso_hom_comp_eval
code: @[simp]
theorem productIso_hom_comp_eval (j : J) :
    ((productIso.{v, u} F).hom ≫ fun f => (equivShrink (∀ j, F j)).symm f j) = Pi.π F j 
goal: ((CategoryTheory.Limits.Types.Small.productIso F).hom ≫ fun f => (equivShrink ((j : J) → F j)).symm f j) =
  CategoryTheory.Limits.Pi.π F j

full_name: CategoryTheory.Limits.Types.Small.productIso_hom_comp_eval_apply
code: @[simp]
theorem productIso_hom_comp_eval_apply (j : J) (x) :
    (equivShrink (∀ j, F j)).symm ((productIso F).hom x) j = Pi.π F j x 
goal: (equivShrink ((j : J) → F j)).symm ((CategoryTheory.Limits.Types.Small.productIso F).hom x) j =
  CategoryTheory.Limits.Pi.π F j x

full_name: CategoryTheory.Limits.Types.Small.productIso_inv_comp_π
code: @[elementwise (attr := simp)]
theorem productIso_inv_comp_π (j : J) :
    (productIso.{v, u} F).inv ≫ Pi.π F j = fun f => ((equivShrink (∀ j, F j)).symm f) j 
goal: (CategoryTheory.Limits.Types.Small.productIso F).inv ≫ CategoryTheory.Limits.Pi.π F j = fun f =>
  (equivShrink ((j : J) → F j)).symm f j

full_name: CategoryTheory.Limits.Types.coproductColimitCocone
code: /-- The category of types has `Σ j, f j` as the coproduct of a type family `f : J → Type`.
-/
def coproductColimitCocone {J : Type v} (F : J → TypeMax.{v, u}) :
    Limits.ColimitCocone (Discrete.functor F) 
goal: CategoryTheory.Limits.ColimitCocone (CategoryTheory.Discrete.functor F)

full_name: CategoryTheory.Limits.Types.coproductIso
code: /-- The categorical coproduct in `Type u` is the type theoretic coproduct `Σ j, F j`. -/
noncomputable def coproductIso {J : Type v} (F : J → TypeMax.{v, u}) : ∐ F ≅ Σj, F j 
goal: ∐ F ≅ (j : J) × F j

full_name: CategoryTheory.Limits.Types.coproductIso_ι_comp_hom
code: @[elementwise (attr := simp)]
theorem coproductIso_ι_comp_hom {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    Sigma.ι F j ≫ (coproductIso F).hom = fun x : F j => (⟨j, x⟩ : Σj, F j) 
goal: CategoryTheory.Limits.Sigma.ι F j ≫ (CategoryTheory.Limits.Types.coproductIso F).hom = fun x => ⟨j, x⟩

full_name: CategoryTheory.Limits.Types.coproductIso_mk_comp_inv
code: theorem coproductIso_mk_comp_inv {J : Type v} (F : J → TypeMax.{v, u}) (j : J) :
    (↾fun x : F j => (⟨j, x⟩ : Σj, F j)) ≫ (coproductIso F).inv = Sigma.ι F j 
goal: (↾fun x => ⟨j, x⟩) ≫ (CategoryTheory.Limits.Types.coproductIso F).inv = CategoryTheory.Limits.Sigma.ι F j

full_name: CategoryTheory.Limits.Types.typeEqualizerOfUnique
code: /--
Show the given fork in `Type u` is an equalizer given that any element in the "difference kernel"
comes from `X`.
The converse of `unique_of_type_equalizer`.
-/
noncomputable def typeEqualizerOfUnique (t : ∀ y : Y, g y = h y → ∃! x : X, f x = y) :
    IsLimit (Fork.ofι _ w) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι f w)

full_name: CategoryTheory.Limits.Types.unique_of_type_equalizer
code: /-- The converse of `type_equalizer_of_unique`. -/
theorem unique_of_type_equalizer (t : IsLimit (Fork.ofι _ w)) (y : Y) (hy : g y = h y) :
    ∃! x : X, f x = y 
goal: ∃! x, f x = y

full_name: CategoryTheory.Limits.Types.type_equalizer_iff_unique
code: theorem type_equalizer_iff_unique :
    Nonempty (IsLimit (Fork.ofι _ w)) ↔ ∀ y : Y, g y = h y → ∃! x : X, f x = y 
goal: Nonempty (CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Fork.ofι f w)) ↔ ∀ (y : Y), g y = h y → ∃! x, f x = y

full_name: CategoryTheory.Limits.Types.equalizerLimit
code: /-- Show that the subtype `{x : Y // g x = h x}` is an equalizer for the pair `(g,h)`. -/
def equalizerLimit : Limits.LimitCone (parallelPair g h) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.parallelPair g h)

full_name: CategoryTheory.Limits.Types.equalizerIso
code: /-- The categorical equalizer in `Type u` is `{x : Y // g x = h x}`. -/
noncomputable def equalizerIso : equalizer g h ≅ { x : Y // g x = h x } 
goal: CategoryTheory.Limits.equalizer g h ≅ { x // g x = h x }

full_name: CategoryTheory.Limits.Types.equalizerIso_hom_comp_subtype
code: @[simp]
theorem equalizerIso_hom_comp_subtype : (equalizerIso g h).hom ≫ Subtype.val = equalizer.ι g h 
goal: (CategoryTheory.Limits.Types.equalizerIso g h).hom ≫ Subtype.val = CategoryTheory.Limits.equalizer.ι g h

full_name: CategoryTheory.Limits.Types.equalizerIso_inv_comp_ι
code: @[elementwise (attr := simp)]
theorem equalizerIso_inv_comp_ι : (equalizerIso g h).inv ≫ equalizer.ι g h = Subtype.val 
goal: (CategoryTheory.Limits.Types.equalizerIso g h).inv ≫ CategoryTheory.Limits.equalizer.ι g h = Subtype.val

full_name: CategoryTheory.Limits.Types.CoequalizerRel.Rel
code: /-- (Implementation) The relation to be quotiented to obtain the coequalizer. -/
inductive CoequalizerRel : Y → Y → Prop
  | Rel (x : X) : CoequalizerRel (f x) (g x)
goal: CategoryTheory.Limits.Types.CoequalizerRel f g (f x) (g x)

full_name: CategoryTheory.Limits.Types.CoequalizerRel
code: /-- (Implementation) The relation to be quotiented to obtain the coequalizer. -/
inductive CoequalizerRel : Y → Y → Prop
  | Rel (x : X) : CoequalizerRel (f x) (g x)
goal: Y → Y → Prop

full_name: CategoryTheory.Limits.Types.coequalizerColimit
code: /-- Show that the quotient by the relation generated by `f(x) ~ g(x)`
is a coequalizer for the pair `(f, g)`.
-/
def coequalizerColimit : Limits.ColimitCocone (parallelPair f g) 
goal: CategoryTheory.Limits.ColimitCocone (CategoryTheory.Limits.parallelPair f g)

full_name: CategoryTheory.Limits.Types.coequalizer_preimage_image_eq_of_preimage_eq
code: /-- If `π : Y ⟶ Z` is an equalizer for `(f, g)`, and `U ⊆ Y` such that `f ⁻¹' U = g ⁻¹' U`,
then `π ⁻¹' (π '' U) = U`.
-/
theorem coequalizer_preimage_image_eq_of_preimage_eq (π : Y ⟶ Z) (e : f ≫ π = g ≫ π)
    (h : IsColimit (Cofork.ofπ π e)) (U : Set Y) (H : f ⁻¹' U = g ⁻¹' U) : π ⁻¹' (π '' U) = U 
goal: π ⁻¹' (π '' U) = U

full_name: CategoryTheory.Limits.Types.coequalizerIso
code: /-- The categorical coequalizer in `Type u` is the quotient by `f g ~ g x`. -/
noncomputable def coequalizerIso : coequalizer f g ≅ _root_.Quot (CoequalizerRel f g) 
goal: CategoryTheory.Limits.coequalizer f g ≅ Quot (CategoryTheory.Limits.Types.CoequalizerRel f g)

full_name: CategoryTheory.Limits.Types.coequalizerIso_π_comp_hom
code: @[elementwise (attr := simp)]
theorem coequalizerIso_π_comp_hom :
    coequalizer.π f g ≫ (coequalizerIso f g).hom = Quot.mk (CoequalizerRel f g) 
goal: CategoryTheory.Limits.coequalizer.π f g ≫ (CategoryTheory.Limits.Types.coequalizerIso f g).hom =
  Quot.mk (CategoryTheory.Limits.Types.CoequalizerRel f g)

full_name: CategoryTheory.Limits.Types.coequalizerIso_quot_comp_inv
code: @[simp]
theorem coequalizerIso_quot_comp_inv :
    ↾Quot.mk (CoequalizerRel f g) ≫ (coequalizerIso f g).inv = coequalizer.π f g 
goal: ↾Quot.mk (CategoryTheory.Limits.Types.CoequalizerRel f g) ≫ (CategoryTheory.Limits.Types.coequalizerIso f g).inv =
  CategoryTheory.Limits.coequalizer.π f g

full_name: CategoryTheory.Limits.Types.instHasPullbacksType
code: instance : HasPullbacks.{u} (Type u) 
goal: CategoryTheory.Limits.HasPullbacks (Type u)

full_name: CategoryTheory.Limits.Types.instHasPushoutsType
code: instance : HasPushouts.{u} (Type u) 
goal: CategoryTheory.Limits.HasPushouts (Type u)

full_name: CategoryTheory.Limits.Types.PullbackObj
code: /-- The usual explicit pullback in the category of types, as a subtype of the product.
The full `LimitCone` data is bundled as `pullbackLimitCone f g`.
-/
abbrev PullbackObj : Type u 
goal: Type u

full_name: CategoryTheory.Limits.Types.pullbackCone
code: /-- The explicit pullback cone on `PullbackObj f g`.
This is bundled with the `IsLimit` data as `pullbackLimitCone f g`.
-/
abbrev pullbackCone : Limits.PullbackCone f g 
goal: CategoryTheory.Limits.PullbackCone f g

full_name: CategoryTheory.Limits.Types.pullbackLimitCone_cone
code: /-- The explicit pullback in the category of types, bundled up as a `LimitCone`
for given `f` and `g`.
-/
@[simps]
def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g) 
goal: (CategoryTheory.Limits.Types.pullbackLimitCone f g).cone = CategoryTheory.Limits.Types.pullbackCone f g

full_name: CategoryTheory.Limits.Types.pullbackLimitCone
code: /-- The explicit pullback in the category of types, bundled up as a `LimitCone`
for given `f` and `g`.
-/
@[simps]
def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g) 
goal: CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.cospan f g)

full_name: CategoryTheory.Limits.Types.pullbackLimitCone_isLimit
code: /-- The explicit pullback in the category of types, bundled up as a `LimitCone`
for given `f` and `g`.
-/
@[simps]
def pullbackLimitCone (f : X ⟶ Z) (g : Y ⟶ Z) : Limits.LimitCone (cospan f g) 
goal: (CategoryTheory.Limits.Types.pullbackLimitCone f g).isLimit =
  (CategoryTheory.Limits.Types.pullbackCone f g).isLimitAux (fun s x => ⟨(s.fst x, s.snd x), ⋯⟩) ⋯ ⋯ ⋯

full_name: CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj
code: /-- A limit pullback cone in the category of types identifies to the explicit pullback. -/
noncomputable def equivPullbackObj : c.pt ≃ Types.PullbackObj f g 
goal: c.pt ≃ CategoryTheory.Limits.Types.PullbackObj f g

full_name: CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_apply_fst
code: @[simp]
lemma equivPullbackObj_apply_fst (x : c.pt) : (equivPullbackObj hc x).1.1 = c.fst x 
goal: (↑((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc) x)).1 = c.fst x

full_name: CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_apply_snd
code: @[simp]
lemma equivPullbackObj_apply_snd (x : c.pt) : (equivPullbackObj hc x).1.2 = c.snd x 
goal: (↑((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc) x)).2 = c.snd x

full_name: CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_symm_apply_fst
code: @[simp]
lemma equivPullbackObj_symm_apply_fst (x : Types.PullbackObj f g) :
    c.fst ((equivPullbackObj hc).symm x) = x.1.1 
goal: c.fst ((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc).symm x) = (↑x).1

full_name: CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj_symm_apply_snd
code: @[simp]
lemma equivPullbackObj_symm_apply_snd (x : Types.PullbackObj f g) :
    c.snd ((equivPullbackObj hc).symm x) = x.1.2 
goal: c.snd ((CategoryTheory.Limits.PullbackCone.IsLimit.equivPullbackObj hc).symm x) = (↑x).2

full_name: CategoryTheory.Limits.PullbackCone.IsLimit.type_ext
code: lemma type_ext {x y : c.pt} (h₁ : c.fst x = c.fst y) (h₂ : c.snd x = c.snd y) : x = y 
goal: x = y

full_name: CategoryTheory.Limits.PullbackCone.toPullbackObj_coe_fst
code: /-- Given `c : PullbackCone f g` in the category of types, this is
the canonical map `c.pt → Types.PullbackObj f g`. -/
@[simps coe_fst coe_snd]
def toPullbackObj (x : c.pt) : Types.PullbackObj f g 
goal: (↑(c.toPullbackObj x)).1 = c.fst x

full_name: CategoryTheory.Limits.PullbackCone.toPullbackObj_coe_snd
code: /-- Given `c : PullbackCone f g` in the category of types, this is
the canonical map `c.pt → Types.PullbackObj f g`. -/
@[simps coe_fst coe_snd]
def toPullbackObj (x : c.pt) : Types.PullbackObj f g 
goal: (↑(c.toPullbackObj x)).2 = c.snd x

full_name: CategoryTheory.Limits.PullbackCone.toPullbackObj
code: /-- Given `c : PullbackCone f g` in the category of types, this is
the canonical map `c.pt → Types.PullbackObj f g`. -/
@[simps coe_fst coe_snd]
def toPullbackObj (x : c.pt) : Types.PullbackObj f g 
goal: CategoryTheory.Limits.Types.PullbackObj f g

full_name: CategoryTheory.Limits.PullbackCone.isLimitEquivBijective
code: /-- A pullback cone `c` in the category of types is limit iff the
map `c.toPullbackObj : c.pt → Types.PullbackObj f g` is a bijection. -/
noncomputable def isLimitEquivBijective :
    IsLimit c ≃ Function.Bijective c.toPullbackObj 
goal: CategoryTheory.Limits.IsLimit c ≃ Function.Bijective c.toPullbackObj

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback
code: /-- The pullback given by the instance `HasPullbacks (Type u)` is isomorphic to the
explicit pullback object given by `PullbackObj`.
-/
noncomputable def pullbackIsoPullback : pullback f g ≅ PullbackObj f g 
goal: CategoryTheory.Limits.pullback f g ≅ CategoryTheory.Limits.Types.PullbackObj f g

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback_hom_fst
code: @[simp]
theorem pullbackIsoPullback_hom_fst (p : pullback f g) :
    ((pullbackIsoPullback f g).hom p : X × Y).fst = (pullback.fst f g) p 
goal: (↑((CategoryTheory.Limits.Types.pullbackIsoPullback f g).hom p)).1 = CategoryTheory.Limits.pullback.fst f g p

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback_hom_snd
code: @[simp]
theorem pullbackIsoPullback_hom_snd (p : pullback f g) :
    ((pullbackIsoPullback f g).hom p : X × Y).snd = (pullback.snd f g) p 
goal: (↑((CategoryTheory.Limits.Types.pullbackIsoPullback f g).hom p)).2 = CategoryTheory.Limits.pullback.snd f g p

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback_inv_fst_apply
code: @[simp]
theorem pullbackIsoPullback_inv_fst_apply (x : (Types.pullbackCone f g).pt) :
    (pullback.fst f g) ((pullbackIsoPullback f g).inv x) = (fun p => (p.1 : X × Y).fst) x 
goal: CategoryTheory.Limits.pullback.fst f g ((CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv x) =
  (fun p => (↑p).1) x

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback_inv_snd_apply
code: @[simp]
theorem pullbackIsoPullback_inv_snd_apply (x : (Types.pullbackCone f g).pt) :
    (pullback.snd f g) ((pullbackIsoPullback f g).inv x) = (fun p => (p.1 : X × Y).snd) x 
goal: CategoryTheory.Limits.pullback.snd f g ((CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv x) =
  (fun p => (↑p).2) x

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback_inv_fst
code: @[simp]
theorem pullbackIsoPullback_inv_fst :
    (pullbackIsoPullback f g).inv ≫ pullback.fst _ _ = fun p => (p.1 : X × Y).fst 
goal: (CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv ≫ CategoryTheory.Limits.pullback.fst f g = fun p => (↑p).1

full_name: CategoryTheory.Limits.Types.pullbackIsoPullback_inv_snd
code: @[simp]
theorem pullbackIsoPullback_inv_snd :
    (pullbackIsoPullback f g).inv ≫ pullback.snd _ _ = fun p => (p.1 : X × Y).snd 
goal: (CategoryTheory.Limits.Types.pullbackIsoPullback f g).inv ≫ CategoryTheory.Limits.pullback.snd f g = fun p => (↑p).2

full_name: CategoryTheory.Limits.Types.Pushout.Rel
code: /-- The pushout of two maps `f : S ⟶ X₁` and `g : S ⟶ X₂` is the quotient
by the equivalence relation on `X₁ ⊕ X₂` generated by this relation. -/
inductive Pushout.Rel (f : S ⟶ X₁) (g : S ⟶ X₂) : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | inl_inr (s : S) : Pushout.Rel f g (Sum.inl (f s)) (Sum.inr (g s))
goal: X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop

full_name: CategoryTheory.Limits.Types.Pushout.Rel.inl_inr
code: /-- The pushout of two maps `f : S ⟶ X₁` and `g : S ⟶ X₂` is the quotient
by the equivalence relation on `X₁ ⊕ X₂` generated by this relation. -/
inductive Pushout.Rel (f : S ⟶ X₁) (g : S ⟶ X₂) : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | inl_inr (s : S) : Pushout.Rel f g (Sum.inl (f s)) (Sum.inr (g s))
goal: CategoryTheory.Limits.Types.Pushout.Rel f g (Sum.inl (f s)) (Sum.inr (g s))

full_name: CategoryTheory.Limits.Types.Pushout
code: /-- Construction of the pushout in the category of types, as a quotient of `X₁ ⊕ X₂`. -/
def Pushout : Type u 
goal: Type u

full_name: CategoryTheory.Limits.Types.Pushout.Rel'.inr_inl
code: /-- In case `f : S ⟶ X₁` is a monomorphism, this relation is the equivalence relation
generated by `Pushout.Rel f g`. -/
inductive Pushout.Rel' : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | refl (x : X₁ ⊕ X₂) : Rel' x x
  | inl_inl (x₀ y₀ : S) (h : g x₀ = g y₀) : Rel' (Sum.inl (f x₀)) (Sum.inl (f y₀))
  | inl_inr (s : S) : Rel' (Sum.inl (f s)) (Sum.inr (g s))
  | inr_inl (s : S) : Rel' (Sum.inr (g s)) (Sum.inl (f s))
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr (g s)) (Sum.inl (f s))

full_name: CategoryTheory.Limits.Types.Pushout.Rel'.inl_inl
code: /-- In case `f : S ⟶ X₁` is a monomorphism, this relation is the equivalence relation
generated by `Pushout.Rel f g`. -/
inductive Pushout.Rel' : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | refl (x : X₁ ⊕ X₂) : Rel' x x
  | inl_inl (x₀ y₀ : S) (h : g x₀ = g y₀) : Rel' (Sum.inl (f x₀)) (Sum.inl (f y₀))
  | inl_inr (s : S) : Rel' (Sum.inl (f s)) (Sum.inr (g s))
  | inr_inl (s : S) : Rel' (Sum.inr (g s)) (Sum.inl (f s))
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inl (f x₀)) (Sum.inl (f y₀))

full_name: CategoryTheory.Limits.Types.Pushout.Rel'.refl
code: /-- In case `f : S ⟶ X₁` is a monomorphism, this relation is the equivalence relation
generated by `Pushout.Rel f g`. -/
inductive Pushout.Rel' : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | refl (x : X₁ ⊕ X₂) : Rel' x x
  | inl_inl (x₀ y₀ : S) (h : g x₀ = g y₀) : Rel' (Sum.inl (f x₀)) (Sum.inl (f y₀))
  | inl_inr (s : S) : Rel' (Sum.inl (f s)) (Sum.inr (g s))
  | inr_inl (s : S) : Rel' (Sum.inr (g s)) (Sum.inl (f s))
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g x x

full_name: CategoryTheory.Limits.Types.Pushout.Rel'
code: /-- In case `f : S ⟶ X₁` is a monomorphism, this relation is the equivalence relation
generated by `Pushout.Rel f g`. -/
inductive Pushout.Rel' : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | refl (x : X₁ ⊕ X₂) : Rel' x x
  | inl_inl (x₀ y₀ : S) (h : g x₀ = g y₀) : Rel' (Sum.inl (f x₀)) (Sum.inl (f y₀))
  | inl_inr (s : S) : Rel' (Sum.inl (f s)) (Sum.inr (g s))
  | inr_inl (s : S) : Rel' (Sum.inr (g s)) (Sum.inl (f s))
goal: X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop

full_name: CategoryTheory.Limits.Types.Pushout.Rel'.inl_inr
code: /-- In case `f : S ⟶ X₁` is a monomorphism, this relation is the equivalence relation
generated by `Pushout.Rel f g`. -/
inductive Pushout.Rel' : X₁ ⊕ X₂ → X₁ ⊕ X₂ → Prop
  | refl (x : X₁ ⊕ X₂) : Rel' x x
  | inl_inl (x₀ y₀ : S) (h : g x₀ = g y₀) : Rel' (Sum.inl (f x₀)) (Sum.inl (f y₀))
  | inl_inr (s : S) : Rel' (Sum.inl (f s)) (Sum.inr (g s))
  | inr_inl (s : S) : Rel' (Sum.inr (g s)) (Sum.inl (f s))
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inl (f s)) (Sum.inr (g s))

full_name: CategoryTheory.Limits.Types.Pushout'
code: /-- The quotient of `X₁ ⊕ X₂` by the relation `PushoutRel' f g`. -/
def Pushout' : Type u 
goal: Type u

full_name: CategoryTheory.Limits.Types.Pushout.inl
code: /-- The left inclusion in the constructed pushout `Pushout f g`. -/
@[simp]
def inl : X₁ ⟶ Pushout f g 
goal: X₁ ⟶ CategoryTheory.Limits.Types.Pushout f g

full_name: CategoryTheory.Limits.Types.Pushout.inr
code: /-- The right inclusion in the constructed pushout `Pushout f g`. -/
@[simp]
def inr : X₂ ⟶ Pushout f g 
goal: X₂ ⟶ CategoryTheory.Limits.Types.Pushout f g

full_name: CategoryTheory.Limits.Types.Pushout.condition
code: lemma condition : f ≫ inl f g = g ≫ inr f g 
goal: f ≫ CategoryTheory.Limits.Types.Pushout.inl f g = g ≫ CategoryTheory.Limits.Types.Pushout.inr f g

full_name: CategoryTheory.Limits.Types.Pushout.cocone
code: /-- The constructed pushout cocone in the category of types. -/
@[simps!]
def cocone : PushoutCocone f g 
goal: CategoryTheory.Limits.PushoutCocone f g

full_name: CategoryTheory.Limits.Types.Pushout.cocone_ι_app
code: /-- The constructed pushout cocone in the category of types. -/
@[simps!]
def cocone : PushoutCocone f g 
goal: ∀ (a : (CategoryTheory.Limits.span f g).obj j),
  (CategoryTheory.Limits.Types.Pushout.cocone f g).ι.app j a =
    Option.rec (f ≫ CategoryTheory.Limits.Types.Pushout.inl f g)
      (fun val =>
        CategoryTheory.Limits.WalkingPair.rec (CategoryTheory.Limits.Types.Pushout.inl f g)
          (CategoryTheory.Limits.Types.Pushout.inr f g) val)
      j a

full_name: CategoryTheory.Limits.Types.Pushout.cocone_pt
code: /-- The constructed pushout cocone in the category of types. -/
@[simps!]
def cocone : PushoutCocone f g 
goal: (CategoryTheory.Limits.Types.Pushout.cocone f g).pt = CategoryTheory.Limits.Types.Pushout f g

full_name: CategoryTheory.Limits.Types.Pushout.isColimitCocone
code: /-- The cocone `cocone f g` is colimit. -/
def isColimitCocone : IsColimit (cocone f g) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.Pushout.cocone f g)

full_name: CategoryTheory.Limits.Types.Pushout.inl_rel'_inl_iff
code: @[simp]
lemma inl_rel'_inl_iff (x₁ y₁ : X₁) :
    Rel' f g (Sum.inl x₁) (Sum.inl y₁) ↔ x₁ = y₁ ∨
      ∃ (x₀ y₀ : S) (_ : g x₀ = g y₀), x₁ = f x₀ ∧ y₁ = f y₀ 
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inl x₁) (Sum.inl y₁) ↔
  x₁ = y₁ ∨ ∃ x₀ y₀, ∃ (_ : g x₀ = g y₀), x₁ = f x₀ ∧ y₁ = f y₀

full_name: CategoryTheory.Limits.Types.Pushout.inl_rel'_inr_iff
code: @[simp]
lemma inl_rel'_inr_iff (x₁ : X₁) (x₂ : X₂) :
    Rel' f g (Sum.inl x₁) (Sum.inr x₂) ↔
      ∃ (s : S), x₁ = f s ∧ x₂ = g s 
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inl x₁) (Sum.inr x₂) ↔ ∃ s, x₁ = f s ∧ x₂ = g s

full_name: CategoryTheory.Limits.Types.Pushout.inr_rel'_inr_iff
code: @[simp]
lemma inr_rel'_inr_iff (x₂ y₂ : X₂) :
    Rel' f g (Sum.inr x₂) (Sum.inr y₂) ↔ x₂ = y₂ 
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr x₂) (Sum.inr y₂) ↔ x₂ = y₂

full_name: CategoryTheory.Limits.Types.Pushout.Rel'.symm
code: lemma Rel'.symm {x y : X₁ ⊕ X₂} (h : Rel' f g x y) :
    Rel' f g y x 
goal: CategoryTheory.Limits.Types.Pushout.Rel' f g y x

full_name: CategoryTheory.Limits.Types.Pushout.equivalence_rel'
code: lemma equivalence_rel' [Mono f] : _root_.Equivalence (Rel' f g) 
goal: Equivalence (CategoryTheory.Limits.Types.Pushout.Rel' f g)

full_name: CategoryTheory.Limits.Types.Pushout.equivPushout'
code: /-- The obvious equivalence `Pushout f g ≃ Pushout' f g`. -/
def equivPushout' : Pushout f g ≃ Pushout' f g 
goal: CategoryTheory.Limits.Types.Pushout f g ≃ CategoryTheory.Limits.Types.Pushout' f g

full_name: CategoryTheory.Limits.Types.Pushout.quot_mk_eq_iff
code: lemma quot_mk_eq_iff [Mono f] (a b : X₁ ⊕ X₂) :
    (Quot.mk _ a : Pushout f g) = Quot.mk _ b ↔ Rel' f g a b 
goal: Quot.mk (CategoryTheory.Limits.Types.Pushout.Rel f g) a = Quot.mk (CategoryTheory.Limits.Types.Pushout.Rel f g) b ↔
  CategoryTheory.Limits.Types.Pushout.Rel' f g a b

full_name: CategoryTheory.Limits.Types.Pushout.inl_eq_inr_iff
code: lemma inl_eq_inr_iff [Mono f] (x₁ : X₁) (x₂ : X₂) :
    (inl f g x₁ = inr f g x₂) ↔
      ∃ (s : S), f s = x₁ ∧ g s = x₂ 
goal: CategoryTheory.Limits.Types.Pushout.inl f g x₁ = CategoryTheory.Limits.Types.Pushout.inr f g x₂ ↔
  ∃ s, f s = x₁ ∧ g s = x₂

full_name: CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_imp_of_iso
code: lemma pushoutCocone_inl_eq_inr_imp_of_iso {c c' : PushoutCocone f g} (e : c ≅ c')
    (x₁ : X₁) (x₂ : X₂) (h : c.inl x₁ = c.inr x₂) :
    c'.inl x₁ = c'.inr x₂ 
goal: c'.inl x₁ = c'.inr x₂

full_name: CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_iff_of_iso
code: lemma pushoutCocone_inl_eq_inr_iff_of_iso {c c' : PushoutCocone f g} (e : c ≅ c')
    (x₁ : X₁) (x₂ : X₂) :
    c.inl x₁ = c.inr x₂ ↔ c'.inl x₁ = c'.inr x₂ 
goal: c.inl x₁ = c.inr x₂ ↔ c'.inl x₁ = c'.inr x₂

full_name: CategoryTheory.Limits.Types.pushoutCocone_inl_eq_inr_iff_of_isColimit
code: lemma pushoutCocone_inl_eq_inr_iff_of_isColimit {c : PushoutCocone f g} (hc : IsColimit c)
    (h₁ : Function.Injective f) (x₁ : X₁) (x₂ : X₂) :
    c.inl x₁ = c.inr x₂ ↔ ∃ (s : S), f s = x₁ ∧ g s = x₂ 
goal: c.inl x₁ = c.inr x₂ ↔ ∃ s, f s = x₁ ∧ g s = x₂

full_name: CategoryTheory.Limits.MulticospanIndex.sections
code: /-- Given `I : MulticospanIndex (Type u)`, this is a type which identifies
to the sections of the functor `I.multicospan`. -/
@[ext]
structure MulticospanIndex.sections where
  /-- The data of an element in `I.left i` for each `i : I.L`. -/
  val (i : I.L) : I.left i
  property (r : I.R) : I.fst r (val _) = I.snd r (val _)
goal: Type (max u u_1)

full_name: CategoryTheory.Limits.MulticospanIndex.sections.val
code: /-- Given `I : MulticospanIndex (Type u)`, this is a type which identifies
to the sections of the functor `I.multicospan`. -/
@[ext]
structure MulticospanIndex.sections where
  /-- The data of an element in `I.left i` for each `i : I.L`. -/
  val (i : I.L) : I.left i
  property (r : I.R) : I.fst r (val _) = I.snd r (val _)
goal: I.left i

full_name: CategoryTheory.Limits.MulticospanIndex.sections.property
code: /-- Given `I : MulticospanIndex (Type u)`, this is a type which identifies
to the sections of the functor `I.multicospan`. -/
@[ext]
structure MulticospanIndex.sections where
  /-- The data of an element in `I.left i` for each `i : I.L`. -/
  val (i : I.L) : I.left i
  property (r : I.R) : I.fst r (val _) = I.snd r (val _)
goal: I.fst r (self.val (I.fstTo r)) = I.snd r (self.val (I.sndTo r))

full_name: CategoryTheory.Limits.MulticospanIndex.sectionsEquiv
code: /-- The bijection `I.sections ≃ I.multicospan.sections` when `I : MulticospanIndex (Type u)`
is a multiequalizer diagram in the category of types. -/
@[simps]
def MulticospanIndex.sectionsEquiv :
    I.sections ≃ I.multicospan.sections 
goal: I.sections ≃ ↑I.multicospan.sections

full_name: CategoryTheory.Limits.MulticospanIndex.sectionsEquiv_symm_apply_val
code: /-- The bijection `I.sections ≃ I.multicospan.sections` when `I : MulticospanIndex (Type u)`
is a multiequalizer diagram in the category of types. -/
@[simps]
def MulticospanIndex.sectionsEquiv :
    I.sections ≃ I.multicospan.sections 
goal: (I.sectionsEquiv.symm s).val i = ↑s (CategoryTheory.Limits.WalkingMulticospan.left i)

full_name: CategoryTheory.Limits.MulticospanIndex.sectionsEquiv_apply_coe
code: /-- The bijection `I.sections ≃ I.multicospan.sections` when `I : MulticospanIndex (Type u)`
is a multiequalizer diagram in the category of types. -/
@[simps]
def MulticospanIndex.sectionsEquiv :
    I.sections ≃ I.multicospan.sections 
goal: ↑(I.sectionsEquiv s) i =
  match i with
  | CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
  | CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (s.val (I.fstTo j))

full_name: CategoryTheory.Limits.Multifork.toSections
code: /-- Given a multiequalizer diagram `I : MulticospanIndex (Type u)` in the category of
types and `c` a multifork for `I`, this is the canonical map `c.pt → I.sections`. -/
@[simps]
def toSections (x : c.pt) : I.sections 
goal: I.sections

full_name: CategoryTheory.Limits.Multifork.toSections_val
code: /-- Given a multiequalizer diagram `I : MulticospanIndex (Type u)` in the category of
types and `c` a multifork for `I`, this is the canonical map `c.pt → I.sections`. -/
@[simps]
def toSections (x : c.pt) : I.sections 
goal: (c.toSections x).val i = c.ι i x

full_name: CategoryTheory.Limits.Multifork.toSections_fac
code: lemma toSections_fac : I.sectionsEquiv.symm ∘ Types.sectionOfCone c = c.toSections 
goal: ⇑I.sectionsEquiv.symm ∘ CategoryTheory.Limits.Types.sectionOfCone c = c.toSections

full_name: CategoryTheory.Limits.Multifork.isLimit_types_iff
code: /-- A multifork `c : Multifork I` in the category of types is limit iff the
map `c.toSections : c.pt → I.sections` is a bijection. -/
lemma isLimit_types_iff : Nonempty (IsLimit c) ↔ Function.Bijective c.toSections 
goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ Function.Bijective c.toSections

full_name: CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv
code: /-- The bijection `I.sections ≃ c.pt` when `c : Multifork I` is a limit multifork
in the category of types. -/
noncomputable def sectionsEquiv : I.sections ≃ c.pt 
goal: I.sections ≃ c.pt

full_name: CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv_symm_apply_val
code: @[simp]
lemma sectionsEquiv_symm_apply_val (x : c.pt) (i : I.L) :
    ((sectionsEquiv hc).symm x).val i = c.ι i x 
goal: ((CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv hc).symm x).val i = c.ι i x

full_name: CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv_apply_val
code: @[simp]
lemma sectionsEquiv_apply_val (s : I.sections) (i : I.L) :
    c.ι i (sectionsEquiv hc s) = s.val i 
goal: c.ι i ((CategoryTheory.Limits.Multifork.IsLimit.sectionsEquiv hc) s) = s.val i