Documentation

Mathlib.CategoryTheory.Limits.Types.Products

Products in Type #

We describe arbitrary products in the category of types, as well as binary products, and the terminal object.

@[simp]
theorem CategoryTheory.Limits.Types.pi_lift_π_apply {β : Type v} [Small.{u, v} β] (f : β → Type u) {P : Type u} (s : (b : β) → P ⟶ f b) (b : β) (x : P) :

A restatement of Types.Limit.lift_π_apply that uses Pi.π and Pi.lift.

theorem CategoryTheory.Limits.Types.pi_lift_π_apply' {β : Type v} (f : β → Type v) {P : Type v} (s : (b : β) → P ⟶ f b) (b : β) (x : P) :

A restatement of Types.Limit.lift_π_apply that uses Pi.π and Pi.lift, with specialized universes.

theorem CategoryTheory.Limits.Types.pi_map_π_apply {β : Type v} [Small.{u, v} β] {f g : β → Type u} (α : (j : β) → f j ⟶ g j) (b : β) (x : (fun (X : Type u) => X) (∏ᶜ f)) :

A restatement of Types.Limit.map_π_apply that uses Pi.π and Pi.map.

theorem CategoryTheory.Limits.Types.pi_map_π_apply' {β : Type v} {f g : β → Type v} (α : (j : β) → f j ⟶ g j) (b : β) (x : (fun (X : Type v) => X) (∏ᶜ f)) :

A restatement of Types.Limit.map_π_apply that uses Pi.π and Pi.map, with specialized universes.

A type is terminal if and only if it contains exactly one element.

Equations
  • One or more equations did not get rendered due to their size.
Instances For

    A type is terminal if and only if it is isomorphic to PUnit.

    Equations
    • One or more equations did not get rendered due to their size.
    Instances For

      The product type X × Y forms a cone for the binary product of X and Y.

      Equations
      Instances For

        The product type X × Y is a binary product for X and Y.

        Equations
        • One or more equations did not get rendered due to their size.
        Instances For

          The category of types has X × Y, the usual Cartesian product, as the binary product of X and Y.

          Equations
          Instances For
            noncomputable def CategoryTheory.Limits.Types.binaryProductIso (X Y : Type u) :
            X ⨯ Y ≅ X × Y

            The categorical binary product in Type u is Cartesian product.

            Equations
            Instances For

              The functor which sends X, Y to the product type X × Y.

              Equations
              • One or more equations did not get rendered due to their size.
              Instances For

                The product functor given by the instance HasBinaryProducts (Type u) is isomorphic to the explicit binary product functor given by the product type.

                Equations
                • One or more equations did not get rendered due to their size.
                Instances For

                  The category of types has Π j, f j as the product of a type family f : J → Type max v u.

                  Equations
                  • One or more equations did not get rendered due to their size.
                  Instances For
                    noncomputable def CategoryTheory.Limits.Types.productIso {J : Type v} (F : J → Type (max v u)) :
                    ∏ᶜ F ≅ (j : J) → F j

                    The categorical product in Type max v u is the type-theoretic product Π j, F j.

                    Equations
                    Instances For
                      @[simp]
                      theorem CategoryTheory.Limits.Types.productIso_hom_comp_eval {J : Type v} (F : J → Type (max v u)) (j : J) :
                      CategoryStruct.comp (productIso F).hom (TypeCat.ofHom fun (f : (j : J) → F j) => f j) = Pi.π F j
                      @[simp]
                      @[simp]
                      theorem CategoryTheory.Limits.Types.productIso_inv_comp_π {J : Type v} (F : J → Type (max v u)) (j : J) :
                      CategoryStruct.comp (productIso F).inv (Pi.π F j) = TypeCat.ofHom fun (f : (j : J) → F j) => f j
                      @[simp]
                      theorem CategoryTheory.Limits.Types.productIso_inv_comp_π_apply {J : Type v} (F : J → Type (max v u)) (j : J) (x : (j : J) → F j) :

                      A variant of productLimitCone using a Small hypothesis rather than a function to Type.

                      Equations
                      • One or more equations did not get rendered due to their size.
                      Instances For
                        noncomputable def CategoryTheory.Limits.Types.Small.productIso {J : Type v} (F : J → Type u) [Small.{u, v} J] :
                        ∏ᶜ F ≅ Shrink.{u, max u v} ((j : J) → F j)

                        The categorical product in Type u indexed in Type v is the type-theoretic product Π j, F j, after shrinking back to Type u.

                        Equations
                        Instances For
                          @[simp]
                          theorem CategoryTheory.Limits.Types.Small.productIso_hom_comp_eval {J : Type v} (F : J → Type u) [Small.{u, v} J] (j : J) :
                          CategoryStruct.comp (productIso F).hom (TypeCat.ofHom fun (f : Shrink.{u, max u v} ((j : J) → F j)) => (equivShrink ((j : J) → F j)).symm f j) = Pi.π F j
                          @[simp]
                          theorem CategoryTheory.Limits.Types.Small.productIso_inv_comp_π {J : Type v} (F : J → Type u) [Small.{u, v} J] (j : J) :
                          CategoryStruct.comp (productIso F).inv (Pi.π F j) = TypeCat.ofHom fun (f : Shrink.{u, max u v} ((j : J) → F j)) => (equivShrink ((j : J) → F j)).symm f j
                          @[simp]
                          theorem CategoryTheory.Limits.Types.Small.productIso_inv_comp_π_apply {J : Type v} (F : J → Type u) [Small.{u, v} J] (j : J) (x : Shrink.{u, max u v} ((j : J) → F j)) :