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

full_name: CategoryTheory.Limits.WidePullbackShape
code: /-- A wide pullback shape for any type `J` can be written simply as `Option J`. -/
def WidePullbackShape 
goal: Type w

full_name: CategoryTheory.Limits.instInhabitedWidePullbackShape
code: instance : Inhabited (WidePullbackShape J) 
goal: Inhabited (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.WidePushoutShape
code: /-- A wide pushout shape for any type `J` can be written simply as `Option J`. -/
def WidePushoutShape 
goal: Type w

full_name: CategoryTheory.Limits.instInhabitedWidePushoutShape
code: instance : Inhabited (WidePushoutShape J) 
goal: Inhabited (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.WidePullbackShape.Hom.term
code: /-- The type of arrows for the shape indexing a wide pullback. -/
inductive Hom : WidePullbackShape J → WidePullbackShape J → Type w
  | id : ∀ X, Hom X X
  | term : ∀ j : J, Hom (some j) none
  deriving DecidableEq
goal: CategoryTheory.Limits.WidePullbackShape.Hom (some j) none

full_name: CategoryTheory.Limits.WidePullbackShape.Hom.id
code: /-- The type of arrows for the shape indexing a wide pullback. -/
inductive Hom : WidePullbackShape J → WidePullbackShape J → Type w
  | id : ∀ X, Hom X X
  | term : ∀ j : J, Hom (some j) none
  deriving DecidableEq
goal: X.Hom X

full_name: CategoryTheory.Limits.WidePullbackShape.Hom
code: /-- The type of arrows for the shape indexing a wide pullback. -/
inductive Hom : WidePullbackShape J → WidePullbackShape J → Type w
  | id : ∀ X, Hom X X
  | term : ∀ j : J, Hom (some j) none
  deriving DecidableEq
goal: CategoryTheory.Limits.WidePullbackShape J → CategoryTheory.Limits.WidePullbackShape J → Type w

full_name: CategoryTheory.Limits.WidePullbackShape.struct
code: instance struct : CategoryStruct (WidePullbackShape J) 
goal: CategoryTheory.CategoryStruct.{w, w} (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.WidePullbackShape.Hom.inhabited
code: instance Hom.inhabited : Inhabited (Hom (none : WidePullbackShape J) none) 
goal: Inhabited (CategoryTheory.Limits.WidePullbackShape.Hom none none)

full_name: CategoryTheory.Limits.WidePullbackShape.evalCasesBash
code: /-- An aesop tactic for bulk cases on morphisms in `WidePushoutShape` -/
def evalCasesBash : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: CategoryTheory.Limits.WidePullbackShape.subsingleton_hom
code: instance subsingleton_hom : Quiver.IsThin (WidePullbackShape J) 
goal: Quiver.IsThin (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.WidePullbackShape.category
code: instance category : SmallCategory (WidePullbackShape J) 
goal: CategoryTheory.SmallCategory (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.WidePullbackShape.hom_id
code: @[simp]
theorem hom_id (X : WidePullbackShape J) : Hom.id X = 𝟙 X 
goal: CategoryTheory.Limits.WidePullbackShape.Hom.id X = 𝟙 X

full_name: CategoryTheory.Limits.WidePullbackShape.wideCospan_obj
code: /-- Construct a functor out of the wide pullback shape given a J-indexed collection of arrows to a
fixed object.
-/
@[simps]
def wideCospan (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B) : WidePullbackShape J ⥤ C 
goal: (CategoryTheory.Limits.WidePullbackShape.wideCospan B objs arrows).obj j = Option.casesOn j B objs

full_name: CategoryTheory.Limits.WidePullbackShape.wideCospan_map
code: /-- Construct a functor out of the wide pullback shape given a J-indexed collection of arrows to a
fixed object.
-/
@[simps]
def wideCospan (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B) : WidePullbackShape J ⥤ C 
goal: ∀ {X Y : CategoryTheory.Limits.WidePullbackShape J} (f : X ⟶ Y),
  (CategoryTheory.Limits.WidePullbackShape.wideCospan B objs arrows).map f =
    CategoryTheory.Limits.WidePullbackShape.Hom.casesOn (motive := fun a a_1 t =>
      X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y)) f
      (fun X_1 h =>
        Eq.ndrec (motive := fun X_2 =>
          Y = X_2 →
            HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.id X_2) →
              ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : X ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.id X) →
                  ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => 𝟙 ((fun j => Option.casesOn j B objs) X)) ⋯ f)
          h)
      (fun j h =>
        Eq.ndrec (motive := fun {X} =>
          (f : X ⟶ Y) →
            Y = none →
              HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.term j) →
                ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun f h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : some j ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePullbackShape.Hom.term j) →
                  ((fun j => Option.casesOn j B objs) (some j) ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => arrows j) ⋯ f)
          ⋯ f)
      ⋯ ⋯ ⋯

full_name: CategoryTheory.Limits.WidePullbackShape.wideCospan
code: /-- Construct a functor out of the wide pullback shape given a J-indexed collection of arrows to a
fixed object.
-/
@[simps]
def wideCospan (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B) : WidePullbackShape J ⥤ C 
goal: CategoryTheory.Limits.WidePullbackShape J ⥤ C

full_name: CategoryTheory.Limits.WidePullbackShape.diagramIsoWideCospan
code: /-- Every diagram is naturally isomorphic (actually, equal) to a `wideCospan` -/
def diagramIsoWideCospan (F : WidePullbackShape J ⥤ C) :
    F ≅ wideCospan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.term j) 
goal: F ≅
  CategoryTheory.Limits.WidePullbackShape.wideCospan (F.obj none) (fun j => F.obj (some j)) fun j =>
    F.map (CategoryTheory.Limits.WidePullbackShape.Hom.term j)

full_name: CategoryTheory.Limits.WidePullbackShape.mkCone_π_app
code: /-- Construct a cone over a wide cospan. -/
@[simps]
def mkCone {F : WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : ∀ j, X ⟶ F.obj (some j))
    (w : ∀ j, π j ≫ F.map (Hom.term j) = f) : Cone F 
goal: (CategoryTheory.Limits.WidePullbackShape.mkCone f π w).π.app j =
  match j with
  | none => f
  | some j => π j

full_name: CategoryTheory.Limits.WidePullbackShape.mkCone
code: /-- Construct a cone over a wide cospan. -/
@[simps]
def mkCone {F : WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : ∀ j, X ⟶ F.obj (some j))
    (w : ∀ j, π j ≫ F.map (Hom.term j) = f) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.WidePullbackShape.mkCone_pt
code: /-- Construct a cone over a wide cospan. -/
@[simps]
def mkCone {F : WidePullbackShape J ⥤ C} {X : C} (f : X ⟶ F.obj none) (π : ∀ j, X ⟶ F.obj (some j))
    (w : ∀ j, π j ≫ F.map (Hom.term j) = f) : Cone F 
goal: (CategoryTheory.Limits.WidePullbackShape.mkCone f π w).pt = X

full_name: CategoryTheory.Limits.WidePullbackShape.equivalenceOfEquiv
code: /-- Wide pullback diagrams of equivalent index types are equivalent. -/
def equivalenceOfEquiv (J' : Type w') (h : J ≃ J') :
    WidePullbackShape J ≌ WidePullbackShape J' 
goal: CategoryTheory.Limits.WidePullbackShape J ≌ CategoryTheory.Limits.WidePullbackShape J'

full_name: CategoryTheory.Limits.WidePullbackShape.uliftEquivalence
code: /-- Lifting universe and morphism levels preserves wide pullback diagrams. -/
def uliftEquivalence :
    ULiftHom.{w'} (ULift.{w'} (WidePullbackShape J)) ≌ WidePullbackShape (ULift J) 
goal: CategoryTheory.ULiftHom (ULift.{w', w} (CategoryTheory.Limits.WidePullbackShape J)) ≌
  CategoryTheory.Limits.WidePullbackShape (ULift.{w', w} J)

full_name: CategoryTheory.Limits.WidePushoutShape.Hom.id
code: /-- The type of arrows for the shape indexing a wide pushout. -/
inductive Hom : WidePushoutShape J → WidePushoutShape J → Type w
  | id : ∀ X, Hom X X
  | init : ∀ j : J, Hom none (some j)
  deriving DecidableEq
goal: X.Hom X

full_name: CategoryTheory.Limits.WidePushoutShape.Hom
code: /-- The type of arrows for the shape indexing a wide pushout. -/
inductive Hom : WidePushoutShape J → WidePushoutShape J → Type w
  | id : ∀ X, Hom X X
  | init : ∀ j : J, Hom none (some j)
  deriving DecidableEq
goal: CategoryTheory.Limits.WidePushoutShape J → CategoryTheory.Limits.WidePushoutShape J → Type w

full_name: CategoryTheory.Limits.WidePushoutShape.Hom.init
code: /-- The type of arrows for the shape indexing a wide pushout. -/
inductive Hom : WidePushoutShape J → WidePushoutShape J → Type w
  | id : ∀ X, Hom X X
  | init : ∀ j : J, Hom none (some j)
  deriving DecidableEq
goal: CategoryTheory.Limits.WidePushoutShape.Hom none (some j)

full_name: CategoryTheory.Limits.WidePushoutShape.struct
code: instance struct : CategoryStruct (WidePushoutShape J) 
goal: CategoryTheory.CategoryStruct.{w, w} (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.WidePushoutShape.Hom.inhabited
code: instance Hom.inhabited : Inhabited (Hom (none : WidePushoutShape J) none) 
goal: Inhabited (CategoryTheory.Limits.WidePushoutShape.Hom none none)

full_name: CategoryTheory.Limits.WidePushoutShape.evalCasesBash'
code: /-- An aesop tactic for bulk cases on morphisms in `WidePushoutShape` -/
def evalCasesBash' : TacticM Unit 
goal: Lean.Elab.Tactic.TacticM Unit

full_name: CategoryTheory.Limits.WidePushoutShape.subsingleton_hom
code: instance subsingleton_hom : Quiver.IsThin (WidePushoutShape J) 
goal: Quiver.IsThin (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.WidePushoutShape.category
code: instance category : SmallCategory (WidePushoutShape J) 
goal: CategoryTheory.SmallCategory (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.WidePushoutShape.hom_id
code: @[simp]
theorem hom_id (X : WidePushoutShape J) : Hom.id X = 𝟙 X 
goal: CategoryTheory.Limits.WidePushoutShape.Hom.id X = 𝟙 X

full_name: CategoryTheory.Limits.WidePushoutShape.wideSpan_map
code: /-- Construct a functor out of the wide pushout shape given a J-indexed collection of arrows from a
fixed object.
-/
@[simps]
def wideSpan (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : WidePushoutShape J ⥤ C 
goal: ∀ {X Y : CategoryTheory.Limits.WidePushoutShape J} (f : X ⟶ Y),
  (CategoryTheory.Limits.WidePushoutShape.wideSpan B objs arrows).map f =
    CategoryTheory.Limits.WidePushoutShape.Hom.casesOn (motive := fun a a_1 t =>
      X = a → Y = a_1 → HEq f t → ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y)) f
      (fun X_1 h =>
        Eq.ndrec (motive := fun X_2 =>
          Y = X_2 →
            HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.id X_2) →
              ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : X ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.id X) →
                  ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => 𝟙 ((fun j => Option.casesOn j B objs) X)) ⋯ f)
          h)
      (fun j h =>
        Eq.ndrec (motive := fun {X} =>
          (f : X ⟶ Y) →
            Y = some j →
              HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.init j) →
                ((fun j => Option.casesOn j B objs) X ⟶ (fun j => Option.casesOn j B objs) Y))
          (fun f h =>
            Eq.ndrec (motive := fun {Y} =>
              (f : none ⟶ Y) →
                HEq f (CategoryTheory.Limits.WidePushoutShape.Hom.init j) →
                  ((fun j => Option.casesOn j B objs) none ⟶ (fun j => Option.casesOn j B objs) Y))
              (fun f h => arrows j) ⋯ f)
          ⋯ f)
      ⋯ ⋯ ⋯

full_name: CategoryTheory.Limits.WidePushoutShape.wideSpan
code: /-- Construct a functor out of the wide pushout shape given a J-indexed collection of arrows from a
fixed object.
-/
@[simps]
def wideSpan (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : WidePushoutShape J ⥤ C 
goal: CategoryTheory.Limits.WidePushoutShape J ⥤ C

full_name: CategoryTheory.Limits.WidePushoutShape.wideSpan_obj
code: /-- Construct a functor out of the wide pushout shape given a J-indexed collection of arrows from a
fixed object.
-/
@[simps]
def wideSpan (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : WidePushoutShape J ⥤ C 
goal: (CategoryTheory.Limits.WidePushoutShape.wideSpan B objs arrows).obj j = Option.casesOn j B objs

full_name: CategoryTheory.Limits.WidePushoutShape.diagramIsoWideSpan
code: /-- Every diagram is naturally isomorphic (actually, equal) to a `wideSpan` -/
def diagramIsoWideSpan (F : WidePushoutShape J ⥤ C) :
    F ≅ wideSpan (F.obj none) (fun j => F.obj (some j)) fun j => F.map (Hom.init j) 
goal: F ≅
  CategoryTheory.Limits.WidePushoutShape.wideSpan (F.obj none) (fun j => F.obj (some j)) fun j =>
    F.map (CategoryTheory.Limits.WidePushoutShape.Hom.init j)

full_name: CategoryTheory.Limits.WidePushoutShape.mkCocone_ι_app
code: /-- Construct a cocone over a wide span. -/
@[simps]
def mkCocone {F : WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : ∀ j, F.obj (some j) ⟶ X)
    (w : ∀ j, F.map (Hom.init j) ≫ ι j = f) : Cocone F 
goal: (CategoryTheory.Limits.WidePushoutShape.mkCocone f ι w).ι.app j =
  match j with
  | none => f
  | some j => ι j

full_name: CategoryTheory.Limits.WidePushoutShape.mkCocone
code: /-- Construct a cocone over a wide span. -/
@[simps]
def mkCocone {F : WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : ∀ j, F.obj (some j) ⟶ X)
    (w : ∀ j, F.map (Hom.init j) ≫ ι j = f) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.WidePushoutShape.mkCocone_pt
code: /-- Construct a cocone over a wide span. -/
@[simps]
def mkCocone {F : WidePushoutShape J ⥤ C} {X : C} (f : F.obj none ⟶ X) (ι : ∀ j, F.obj (some j) ⟶ X)
    (w : ∀ j, F.map (Hom.init j) ≫ ι j = f) : Cocone F 
goal: (CategoryTheory.Limits.WidePushoutShape.mkCocone f ι w).pt = X

full_name: CategoryTheory.Limits.WidePushoutShape.equivalenceOfEquiv
code: /-- Wide pushout diagrams of equivalent index types are equivalent. -/
def equivalenceOfEquiv (J' : Type w') (h : J ≃ J') : WidePushoutShape J ≌ WidePushoutShape J' 
goal: CategoryTheory.Limits.WidePushoutShape J ≌ CategoryTheory.Limits.WidePushoutShape J'

full_name: CategoryTheory.Limits.WidePushoutShape.uliftEquivalence
code: /-- Lifting universe and morphism levels preserves wide pushout diagrams. -/
def uliftEquivalence :
    ULiftHom.{w'} (ULift.{w'} (WidePushoutShape J)) ≌ WidePushoutShape (ULift J) 
goal: CategoryTheory.ULiftHom (ULift.{w', w} (CategoryTheory.Limits.WidePushoutShape J)) ≌
  CategoryTheory.Limits.WidePushoutShape (ULift.{w', w} J)

full_name: CategoryTheory.Limits.HasWidePullbacks
code: /-- `HasWidePullbacks` represents a choice of wide pullback for every collection of morphisms -/
abbrev HasWidePullbacks : Prop 
goal: Prop

full_name: CategoryTheory.Limits.HasWidePushouts
code: /-- `HasWidePushouts` represents a choice of wide pushout for every collection of morphisms -/
abbrev HasWidePushouts : Prop 
goal: Prop

full_name: CategoryTheory.Limits.HasWidePullback
code: /-- `HasWidePullback B objs arrows` means that `wideCospan B objs arrows` has a limit. -/
abbrev HasWidePullback (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B) : Prop 
goal: Prop

full_name: CategoryTheory.Limits.HasWidePushout
code: /-- `HasWidePushout B objs arrows` means that `wideSpan B objs arrows` has a colimit. -/
abbrev HasWidePushout (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j) : Prop 
goal: Prop

full_name: CategoryTheory.Limits.widePullback
code: /-- A choice of wide pullback. -/
noncomputable abbrev widePullback (B : C) (objs : J → C) (arrows : ∀ j : J, objs j ⟶ B)
    [HasWidePullback B objs arrows] : C 
goal: C

full_name: CategoryTheory.Limits.widePushout
code: /-- A choice of wide pushout. -/
noncomputable abbrev widePushout (B : C) (objs : J → C) (arrows : ∀ j : J, B ⟶ objs j)
    [HasWidePushout B objs arrows] : C 
goal: C

full_name: CategoryTheory.Limits.WidePullback.π
code: /-- The `j`-th projection from the pullback. -/
noncomputable abbrev π (j : J) : widePullback _ _ arrows ⟶ objs j 
goal: CategoryTheory.Limits.widePullback B objs arrows ⟶ objs j

full_name: CategoryTheory.Limits.WidePullback.base
code: /-- The unique map to the base from the pullback. -/
noncomputable abbrev base : widePullback _ _ arrows ⟶ B 
goal: CategoryTheory.Limits.widePullback B objs arrows ⟶ B

full_name: CategoryTheory.Limits.WidePullback.π_arrow
code: @[reassoc (attr := simp)]
theorem π_arrow (j : J) : π arrows j ≫ arrows _ = base arrows 
goal: CategoryTheory.Limits.WidePullback.π arrows j ≫ arrows j = CategoryTheory.Limits.WidePullback.base arrows

full_name: CategoryTheory.Limits.WidePullback.lift
code: /-- Lift a collection of morphisms to a morphism to the pullback. -/
noncomputable abbrev lift {X : C} (f : X ⟶ B) (fs : ∀ j : J, X ⟶ objs j)
    (w : ∀ j, fs j ≫ arrows j = f) : X ⟶ widePullback _ _ arrows 
goal: X ⟶ CategoryTheory.Limits.widePullback B objs arrows

full_name: CategoryTheory.Limits.WidePullback.lift_π
code: @[reassoc]
theorem lift_π (j : J) : lift f fs w ≫ π arrows j = fs _ 
goal: CategoryTheory.Limits.WidePullback.lift f fs w ≫ CategoryTheory.Limits.WidePullback.π arrows j = fs j

full_name: CategoryTheory.Limits.WidePullback.lift_base
code: @[reassoc]
theorem lift_base : lift f fs w ≫ base arrows = f 
goal: CategoryTheory.Limits.WidePullback.lift f fs w ≫ CategoryTheory.Limits.WidePullback.base arrows = f

full_name: CategoryTheory.Limits.WidePullback.eq_lift_of_comp_eq
code: theorem eq_lift_of_comp_eq (g : X ⟶ widePullback _ _ arrows) :
    (∀ j : J, g ≫ π arrows j = fs j) → g ≫ base arrows = f → g = lift f fs w 
goal: (∀ (j : J), g ≫ CategoryTheory.Limits.WidePullback.π arrows j = fs j) →
  g ≫ CategoryTheory.Limits.WidePullback.base arrows = f → g = CategoryTheory.Limits.WidePullback.lift f fs w

full_name: CategoryTheory.Limits.WidePullback.hom_eq_lift
code: theorem hom_eq_lift (g : X ⟶ widePullback _ _ arrows) :
    g = lift (g ≫ base arrows) (fun j => g ≫ π arrows j) (by aesop_cat) 
goal: g =
  CategoryTheory.Limits.WidePullback.lift (g ≫ CategoryTheory.Limits.WidePullback.base arrows)
    (fun j => g ≫ CategoryTheory.Limits.WidePullback.π arrows j) ⋯

full_name: CategoryTheory.Limits.WidePullback.hom_ext
code: @[ext 1100]
theorem hom_ext (g1 g2 : X ⟶ widePullback _ _ arrows) : (∀ j : J,
    g1 ≫ π arrows j = g2 ≫ π arrows j) → g1 ≫ base arrows = g2 ≫ base arrows → g1 = g2 
goal: (∀ (j : J), g1 ≫ CategoryTheory.Limits.WidePullback.π arrows j = g2 ≫ CategoryTheory.Limits.WidePullback.π arrows j) →
  g1 ≫ CategoryTheory.Limits.WidePullback.base arrows = g2 ≫ CategoryTheory.Limits.WidePullback.base arrows → g1 = g2

full_name: CategoryTheory.Limits.WidePushout.ι
code: /-- The `j`-th inclusion to the pushout. -/
noncomputable abbrev ι (j : J) : objs j ⟶ widePushout _ _ arrows 
goal: objs j ⟶ CategoryTheory.Limits.widePushout B objs arrows

full_name: CategoryTheory.Limits.WidePushout.head
code: /-- The unique map from the head to the pushout. -/
noncomputable abbrev head : B ⟶ widePushout B objs arrows 
goal: B ⟶ CategoryTheory.Limits.widePushout B objs arrows

full_name: CategoryTheory.Limits.WidePushout.arrow_ι
code: @[reassoc (attr := simp)]
theorem arrow_ι (j : J) : arrows j ≫ ι arrows j = head arrows 
goal: arrows j ≫ CategoryTheory.Limits.WidePushout.ι arrows j = CategoryTheory.Limits.WidePushout.head arrows

full_name: CategoryTheory.Limits.WidePushout.desc
code: /-- Descend a collection of morphisms to a morphism from the pushout. -/
noncomputable abbrev desc {X : C} (f : B ⟶ X) (fs : ∀ j : J, objs j ⟶ X)
    (w : ∀ j, arrows j ≫ fs j = f) : widePushout _ _ arrows ⟶ X 
goal: CategoryTheory.Limits.widePushout B objs arrows ⟶ X

full_name: CategoryTheory.Limits.WidePushout.ι_desc
code: @[reassoc]
theorem ι_desc (j : J) : ι arrows j ≫ desc f fs w = fs _ 
goal: CategoryTheory.Limits.WidePushout.ι arrows j ≫ CategoryTheory.Limits.WidePushout.desc f fs w = fs j

full_name: CategoryTheory.Limits.WidePushout.head_desc
code: @[reassoc]
theorem head_desc : head arrows ≫ desc f fs w = f 
goal: CategoryTheory.Limits.WidePushout.head arrows ≫ CategoryTheory.Limits.WidePushout.desc f fs w = f

full_name: CategoryTheory.Limits.WidePushout.eq_desc_of_comp_eq
code: theorem eq_desc_of_comp_eq (g : widePushout _ _ arrows ⟶ X) :
    (∀ j : J, ι arrows j ≫ g = fs j) → head arrows ≫ g = f → g = desc f fs w 
goal: (∀ (j : J), CategoryTheory.Limits.WidePushout.ι arrows j ≫ g = fs j) →
  CategoryTheory.Limits.WidePushout.head arrows ≫ g = f → g = CategoryTheory.Limits.WidePushout.desc f fs w

full_name: CategoryTheory.Limits.WidePushout.hom_eq_desc
code: theorem hom_eq_desc (g : widePushout _ _ arrows ⟶ X) :
    g =
      desc (head arrows ≫ g) (fun j => ι arrows j ≫ g) fun j => by
        rw [← Category.assoc]
        simp 
goal: g =
  CategoryTheory.Limits.WidePushout.desc (CategoryTheory.Limits.WidePushout.head arrows ≫ g)
    (fun j => CategoryTheory.Limits.WidePushout.ι arrows j ≫ g) ⋯

full_name: CategoryTheory.Limits.WidePushout.hom_ext
code: @[ext 1100]
theorem hom_ext (g1 g2 : widePushout _ _ arrows ⟶ X) : (∀ j : J,
    ι arrows j ≫ g1 = ι arrows j ≫ g2) → head arrows ≫ g1 = head arrows ≫ g2 → g1 = g2 
goal: (∀ (j : J), CategoryTheory.Limits.WidePushout.ι arrows j ≫ g1 = CategoryTheory.Limits.WidePushout.ι arrows j ≫ g2) →
  CategoryTheory.Limits.WidePushout.head arrows ≫ g1 = CategoryTheory.Limits.WidePushout.head arrows ≫ g2 → g1 = g2

full_name: CategoryTheory.Limits.widePullbackShapeOpMap
code: /-- The action on morphisms of the obvious functor
  `WidePullbackShape_op : WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ`-/
def widePullbackShapeOpMap :
    ∀ X Y : WidePullbackShape J,
      (X ⟶ Y) → ((op X : (WidePushoutShape J)ᵒᵖ) ⟶ (op Y : (WidePushoutShape J)ᵒᵖ))
  
goal: (X ⟶ Y) → (Opposite.op X ⟶ Opposite.op Y)

full_name: CategoryTheory.Limits.widePullbackShapeOp_map
code: /-- The obvious functor `WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ` -/
@[simps]
def widePullbackShapeOp : WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ 
goal: ∀ (a : X₁ ⟶ X₂),
  (CategoryTheory.Limits.widePullbackShapeOp J).map a = CategoryTheory.Limits.widePullbackShapeOpMap J X₁ X₂ a

full_name: CategoryTheory.Limits.widePullbackShapeOp
code: /-- The obvious functor `WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ` -/
@[simps]
def widePullbackShapeOp : WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ 
goal: CategoryTheory.Limits.WidePullbackShape J ⥤ (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ

full_name: CategoryTheory.Limits.widePullbackShapeOp_obj
code: /-- The obvious functor `WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ` -/
@[simps]
def widePullbackShapeOp : WidePullbackShape J ⥤ (WidePushoutShape J)ᵒᵖ 
goal: (CategoryTheory.Limits.widePullbackShapeOp J).obj X = Opposite.op X

full_name: CategoryTheory.Limits.widePushoutShapeOpMap
code: /-- The action on morphisms of the obvious functor
`widePushoutShapeOp : WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ` -/
def widePushoutShapeOpMap :
    ∀ X Y : WidePushoutShape J,
      (X ⟶ Y) → ((op X : (WidePullbackShape J)ᵒᵖ) ⟶ (op Y : (WidePullbackShape J)ᵒᵖ))
  
goal: (X ⟶ Y) → (Opposite.op X ⟶ Opposite.op Y)

full_name: CategoryTheory.Limits.widePushoutShapeOp_map
code: /-- The obvious functor `WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ` -/
@[simps]
def widePushoutShapeOp : WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ 
goal: ∀ (a : X ⟶ Y), (CategoryTheory.Limits.widePushoutShapeOp J).map a = CategoryTheory.Limits.widePushoutShapeOpMap J X Y a

full_name: CategoryTheory.Limits.widePushoutShapeOp_obj
code: /-- The obvious functor `WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ` -/
@[simps]
def widePushoutShapeOp : WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ 
goal: (CategoryTheory.Limits.widePushoutShapeOp J).obj X = Opposite.op X

full_name: CategoryTheory.Limits.widePushoutShapeOp
code: /-- The obvious functor `WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ` -/
@[simps]
def widePushoutShapeOp : WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ 
goal: CategoryTheory.Limits.WidePushoutShape J ⥤ (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ

full_name: CategoryTheory.Limits.widePullbackShapeUnop_obj
code: /-- The obvious functor `(WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J`-/
@[simps!]
def widePullbackShapeUnop : (WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J 
goal: (CategoryTheory.Limits.widePullbackShapeUnop J).obj X = Opposite.unop X

full_name: CategoryTheory.Limits.widePullbackShapeUnop
code: /-- The obvious functor `(WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J`-/
@[simps!]
def widePullbackShapeUnop : (WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J 
goal: (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ ⥤ CategoryTheory.Limits.WidePushoutShape J

full_name: CategoryTheory.Limits.widePullbackShapeUnop_map
code: /-- The obvious functor `(WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J`-/
@[simps!]
def widePullbackShapeUnop : (WidePullbackShape J)ᵒᵖ ⥤ WidePushoutShape J 
goal: ∀ {X Y : (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.Limits.widePullbackShapeUnop J).map f =
    (CategoryTheory.Limits.widePullbackShapeOpMap J (Opposite.unop Y) (Opposite.unop X) f.unop).unop

full_name: CategoryTheory.Limits.widePushoutShapeUnop_map
code: /-- The obvious functor `(WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J` -/
@[simps!]
def widePushoutShapeUnop : (WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J 
goal: ∀ {X Y : (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ} (f : X ⟶ Y),
  (CategoryTheory.Limits.widePushoutShapeUnop J).map f =
    (CategoryTheory.Limits.widePushoutShapeOpMap J (Opposite.unop Y) (Opposite.unop X) f.unop).unop

full_name: CategoryTheory.Limits.widePushoutShapeUnop
code: /-- The obvious functor `(WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J` -/
@[simps!]
def widePushoutShapeUnop : (WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J 
goal: (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ ⥤ CategoryTheory.Limits.WidePullbackShape J

full_name: CategoryTheory.Limits.widePushoutShapeUnop_obj
code: /-- The obvious functor `(WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J` -/
@[simps!]
def widePushoutShapeUnop : (WidePushoutShape J)ᵒᵖ ⥤ WidePullbackShape J 
goal: (CategoryTheory.Limits.widePushoutShapeUnop J).obj X = Opposite.unop X

full_name: CategoryTheory.Limits.widePushoutShapeOpUnop
code: /-- The inverse of the unit isomorphism of the equivalence
`widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
def widePushoutShapeOpUnop : widePushoutShapeUnop J ⋙ widePullbackShapeOp J ≅ 𝟭 _ 
goal: CategoryTheory.Limits.widePushoutShapeUnop J ⋙ CategoryTheory.Limits.widePullbackShapeOp J ≅
  𝟭 (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ

full_name: CategoryTheory.Limits.widePushoutShapeUnopOp
code: /-- The counit isomorphism of the equivalence
`widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
def widePushoutShapeUnopOp : widePushoutShapeOp J ⋙ widePullbackShapeUnop J ≅ 𝟭 _ 
goal: CategoryTheory.Limits.widePushoutShapeOp J ⋙ CategoryTheory.Limits.widePullbackShapeUnop J ≅
  𝟭 (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.widePullbackShapeOpUnop
code: /-- The inverse of the unit isomorphism of the equivalence
`widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
def widePullbackShapeOpUnop : widePullbackShapeUnop J ⋙ widePushoutShapeOp J ≅ 𝟭 _ 
goal: CategoryTheory.Limits.widePullbackShapeUnop J ⋙ CategoryTheory.Limits.widePushoutShapeOp J ≅
  𝟭 (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ

full_name: CategoryTheory.Limits.widePullbackShapeUnopOp
code: /-- The counit isomorphism of the equivalence
`widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
def widePullbackShapeUnopOp : widePullbackShapeOp J ⋙ widePushoutShapeUnop J ≅ 𝟭 _ 
goal: CategoryTheory.Limits.widePullbackShapeOp J ⋙ CategoryTheory.Limits.widePushoutShapeUnop J ≅
  𝟭 (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.widePushoutShapeOpEquiv_functor
code: /-- The duality equivalence `(WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).functor = CategoryTheory.Limits.widePushoutShapeUnop J

full_name: CategoryTheory.Limits.widePushoutShapeOpEquiv_unitIso
code: /-- The duality equivalence `(WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).unitIso = (CategoryTheory.Limits.widePushoutShapeOpUnop J).symm

full_name: CategoryTheory.Limits.widePushoutShapeOpEquiv_inverse
code: /-- The duality equivalence `(WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).inverse = CategoryTheory.Limits.widePullbackShapeOp J

full_name: CategoryTheory.Limits.widePushoutShapeOpEquiv
code: /-- The duality equivalence `(WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
goal: (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ ≌ CategoryTheory.Limits.WidePullbackShape J

full_name: CategoryTheory.Limits.widePushoutShapeOpEquiv_counitIso
code: /-- The duality equivalence `(WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J` -/
@[simps]
def widePushoutShapeOpEquiv : (WidePushoutShape J)ᵒᵖ ≌ WidePullbackShape J 
goal: (CategoryTheory.Limits.widePushoutShapeOpEquiv J).counitIso = CategoryTheory.Limits.widePullbackShapeUnopOp J

full_name: CategoryTheory.Limits.widePullbackShapeOpEquiv_unitIso
code: /-- The duality equivalence `(WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).unitIso = (CategoryTheory.Limits.widePullbackShapeOpUnop J).symm

full_name: CategoryTheory.Limits.widePullbackShapeOpEquiv_functor
code: /-- The duality equivalence `(WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).functor = CategoryTheory.Limits.widePullbackShapeUnop J

full_name: CategoryTheory.Limits.widePullbackShapeOpEquiv_inverse
code: /-- The duality equivalence `(WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).inverse = CategoryTheory.Limits.widePushoutShapeOp J

full_name: CategoryTheory.Limits.widePullbackShapeOpEquiv
code: /-- The duality equivalence `(WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
goal: (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ ≌ CategoryTheory.Limits.WidePushoutShape J

full_name: CategoryTheory.Limits.widePullbackShapeOpEquiv_counitIso
code: /-- The duality equivalence `(WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J` -/
@[simps]
def widePullbackShapeOpEquiv : (WidePullbackShape J)ᵒᵖ ≌ WidePushoutShape J 
goal: (CategoryTheory.Limits.widePullbackShapeOpEquiv J).counitIso = CategoryTheory.Limits.widePushoutShapeUnopOp J

full_name: CategoryTheory.Limits.hasWidePushouts_shrink
code: /-- If a category has wide pushouts on a higher universe level it also has wide pushouts
on a lower universe level. -/
theorem hasWidePushouts_shrink [HasWidePushouts.{max w w'} C] : HasWidePushouts.{w} C 
goal: CategoryTheory.Limits.HasWidePushouts C

full_name: CategoryTheory.Limits.hasWidePullbacks_shrink
code: /-- If a category has wide pullbacks on a higher universe level it also has wide pullbacks
on a lower universe level. -/
theorem hasWidePullbacks_shrink [HasWidePullbacks.{max w w'} C] : HasWidePullbacks.{w} C 
goal: CategoryTheory.Limits.HasWidePullbacks C