Documentation

Mathlib.CategoryTheory.Square

The category of commutative squares #

In this file, we define a bundled version of CommSq which allows to consider commutative squares as objects in a category Square C.

The four objects in a commutative square are numbered as follows:

X₁ --> X₂
|      |
v      v
X₃ --> X₄

We define the flip functor, and two equivalences with the category Arrow (Arrow C), depending on whether we consider a commutative square as a horizontal morphism between two vertical maps (arrowArrowEquivalence) or a vertical morphism between two horizontal maps (arrowArrowEquivalence').

structure CategoryTheory.Square (C : Type u) [CategoryTheory.Category.{v, u} C] :

Type (max u v)

The category of commutative squares in a category.

X₁ : C
the top-left object
X₂ : C
the top-right object
X₃ : C
the bottom-left object
X₄ : C
the bottom-right object
f₁₂ : self.X₁ ⟶ self.X₂
the top morphism
f₁₃ : self.X₁ ⟶ self.X₃
the left morphism
f₂₄ : self.X₂ ⟶ self.X₄
the right morphism
f₃₄ : self.X₃ ⟶ self.X₄
the bottom morphism
fac : CategoryTheory.CategoryStruct.comp self.f₁₂ self.f₂₄ = CategoryTheory.CategoryStruct.comp self.f₁₃ self.f₃₄

Instances For

theorem CategoryTheory.Square.commSq {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄

structure CategoryTheory.Square.Hom {C : Type u} [CategoryTheory.Category.{v, u} C] (sq₁ sq₂ : CategoryTheory.Square C) :

A morphism between two commutative squares consists of 4 morphisms which extend these two squares into a commuting cube.

τ₁ : sq₁.X₁ ⟶ sq₂.X₁
the top-left morphism
τ₂ : sq₁.X₂ ⟶ sq₂.X₂
the top-right morphism
τ₃ : sq₁.X₃ ⟶ sq₂.X₃
the bottom-left morphism
τ₄ : sq₁.X₄ ⟶ sq₂.X₄
the bottom-right morphism
comm₁₂ : CategoryTheory.CategoryStruct.comp sq₁.f₁₂ self.τ₂ = CategoryTheory.CategoryStruct.comp self.τ₁ sq₂.f₁₂
comm₁₃ : CategoryTheory.CategoryStruct.comp sq₁.f₁₃ self.τ₃ = CategoryTheory.CategoryStruct.comp self.τ₁ sq₂.f₁₃
comm₂₄ : CategoryTheory.CategoryStruct.comp sq₁.f₂₄ self.τ₄ = CategoryTheory.CategoryStruct.comp self.τ₂ sq₂.f₂₄
comm₃₄ : CategoryTheory.CategoryStruct.comp sq₁.f₃₄ self.τ₄ = CategoryTheory.CategoryStruct.comp self.τ₃ sq₂.f₃₄

Instances For

theorem CategoryTheory.Square.Hom.ext {C : Type u} {inst✝ : CategoryTheory.Category.{v, u} C} {sq₁ sq₂ : CategoryTheory.Square C} {x y : sq₁.Hom sq₂} (τ₁ : x.τ₁ = y.τ₁) (τ₂ : x.τ₂ = y.τ₂) (τ₃ : x.τ₃ = y.τ₃) (τ₄ : x.τ₄ = y.τ₄) :

x = y

@[simp]

theorem CategoryTheory.Square.Hom.comm₁₃_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂) {Z : C} (h : sq₂.X₃ ⟶ Z) :

CategoryTheory.CategoryStruct.comp sq₁.f₁₃ (CategoryTheory.CategoryStruct.comp self.τ₃ h) = CategoryTheory.CategoryStruct.comp self.τ₁ (CategoryTheory.CategoryStruct.comp sq₂.f₁₃ h)

@[simp]

theorem CategoryTheory.Square.Hom.comm₁₂_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂) {Z : C} (h : sq₂.X₂ ⟶ Z) :

CategoryTheory.CategoryStruct.comp sq₁.f₁₂ (CategoryTheory.CategoryStruct.comp self.τ₂ h) = CategoryTheory.CategoryStruct.comp self.τ₁ (CategoryTheory.CategoryStruct.comp sq₂.f₁₂ h)

@[simp]

theorem CategoryTheory.Square.Hom.comm₃₄_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂) {Z : C} (h : sq₂.X₄ ⟶ Z) :

CategoryTheory.CategoryStruct.comp sq₁.f₃₄ (CategoryTheory.CategoryStruct.comp self.τ₄ h) = CategoryTheory.CategoryStruct.comp self.τ₃ (CategoryTheory.CategoryStruct.comp sq₂.f₃₄ h)

@[simp]

theorem CategoryTheory.Square.Hom.comm₂₄_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (self : sq₁.Hom sq₂) {Z : C} (h : sq₂.X₄ ⟶ Z) :

CategoryTheory.CategoryStruct.comp sq₁.f₂₄ (CategoryTheory.CategoryStruct.comp self.τ₄ h) = CategoryTheory.CategoryStruct.comp self.τ₂ (CategoryTheory.CategoryStruct.comp sq₂.f₂₄ h)

def CategoryTheory.Square.Hom.id {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.Hom sq

The identity of a commutative square.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.Hom.id_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.Hom.id sq).τ₁ = CategoryTheory.CategoryStruct.id sq.X₁

@[simp]

theorem CategoryTheory.Square.Hom.id_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.Hom.id sq).τ₃ = CategoryTheory.CategoryStruct.id sq.X₃

@[simp]

theorem CategoryTheory.Square.Hom.id_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.Hom.id sq).τ₄ = CategoryTheory.CategoryStruct.id sq.X₄

@[simp]

theorem CategoryTheory.Square.Hom.id_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.Hom.id sq).τ₂ = CategoryTheory.CategoryStruct.id sq.X₂

def CategoryTheory.Square.Hom.comp {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃) :

sq₁.Hom sq₃

The composition of morphisms of squares.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.Hom.comp_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃) :

(f.comp g).τ₂ = CategoryTheory.CategoryStruct.comp f.τ₂ g.τ₂

@[simp]

theorem CategoryTheory.Square.Hom.comp_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃) :

(f.comp g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁

@[simp]

theorem CategoryTheory.Square.Hom.comp_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃) :

(f.comp g).τ₃ = CategoryTheory.CategoryStruct.comp f.τ₃ g.τ₃

@[simp]

theorem CategoryTheory.Square.Hom.comp_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ sq₃ : CategoryTheory.Square C} (f : sq₁.Hom sq₂) (g : sq₂.Hom sq₃) :

(f.comp g).τ₄ = CategoryTheory.CategoryStruct.comp f.τ₄ g.τ₄

instance CategoryTheory.Square.category {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Category.{v, max u v} (CategoryTheory.Square C)

Equations

CategoryTheory.Square.category = CategoryTheory.Category.mk ⋯ ⋯ ⋯

@[simp]

theorem CategoryTheory.Square.category_comp_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ Z✝ : CategoryTheory.Square C} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) :

(CategoryTheory.CategoryStruct.comp f g).τ₄ = CategoryTheory.CategoryStruct.comp f.τ₄ g.τ₄

@[simp]

theorem CategoryTheory.Square.category_id_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.CategoryStruct.id sq).τ₂ = CategoryTheory.CategoryStruct.id sq.X₂

@[simp]

theorem CategoryTheory.Square.category_id_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.CategoryStruct.id sq).τ₃ = CategoryTheory.CategoryStruct.id sq.X₃

@[simp]

theorem CategoryTheory.Square.category_comp_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ Z✝ : CategoryTheory.Square C} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) :

(CategoryTheory.CategoryStruct.comp f g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁

@[simp]

theorem CategoryTheory.Square.category_id_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.CategoryStruct.id sq).τ₄ = CategoryTheory.CategoryStruct.id sq.X₄

@[simp]

theorem CategoryTheory.Square.category_comp_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ Z✝ : CategoryTheory.Square C} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) :

(CategoryTheory.CategoryStruct.comp f g).τ₂ = CategoryTheory.CategoryStruct.comp f.τ₂ g.τ₂

@[simp]

theorem CategoryTheory.Square.category_comp_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ Z✝ : CategoryTheory.Square C} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) :

(CategoryTheory.CategoryStruct.comp f g).τ₃ = CategoryTheory.CategoryStruct.comp f.τ₃ g.τ₃

@[simp]

theorem CategoryTheory.Square.category_id_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.CategoryStruct.id sq).τ₁ = CategoryTheory.CategoryStruct.id sq.X₁

theorem CategoryTheory.Square.hom_ext {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} {f g : sq₁ ⟶ sq₂} (h₁ : f.τ₁ = g.τ₁) (h₂ : f.τ₂ = g.τ₂) (h₃ : f.τ₃ = g.τ₃) (h₄ : f.τ₄ = g.τ₄) :

f = g

def CategoryTheory.Square.isoMk {C : Type u} [CategoryTheory.Category.{v, u} C] {sq₁ sq₂ : CategoryTheory.Square C} (e₁ : sq₁.X₁ ≅ sq₂.X₁) (e₂ : sq₁.X₂ ≅ sq₂.X₂) (e₃ : sq₁.X₃ ≅ sq₂.X₃) (e₄ : sq₁.X₄ ≅ sq₂.X₄) (comm₁₂ : CategoryTheory.CategoryStruct.comp sq₁.f₁₂ e₂.hom = CategoryTheory.CategoryStruct.comp e₁.hom sq₂.f₁₂) (comm₁₃ : CategoryTheory.CategoryStruct.comp sq₁.f₁₃ e₃.hom = CategoryTheory.CategoryStruct.comp e₁.hom sq₂.f₁₃) (comm₂₄ : CategoryTheory.CategoryStruct.comp sq₁.f₂₄ e₄.hom = CategoryTheory.CategoryStruct.comp e₂.hom sq₂.f₂₄) (comm₃₄ : CategoryTheory.CategoryStruct.comp sq₁.f₃₄ e₄.hom = CategoryTheory.CategoryStruct.comp e₃.hom sq₂.f₃₄) :

sq₁ ≅ sq₂

Constructor for isomorphisms in Square c

Equations

One or more equations did not get rendered due to their size.

Instances For

def CategoryTheory.Square.flip {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square C

Flipping a square by switching the top-right and the bottom-left objects.

Equations

sq.flip = CategoryTheory.Square.mk sq.f₁₃ sq.f₁₂ sq.f₃₄ sq.f₂₄ ⋯

Instances For

@[simp]

theorem CategoryTheory.Square.flip_X₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.X₂ = sq.X₃

@[simp]

theorem CategoryTheory.Square.flip_X₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.X₁ = sq.X₁

@[simp]

theorem CategoryTheory.Square.flip_f₁₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.f₁₂ = sq.f₁₃

@[simp]

theorem CategoryTheory.Square.flip_f₃₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.f₃₄ = sq.f₂₄

@[simp]

theorem CategoryTheory.Square.flip_f₂₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.f₂₄ = sq.f₃₄

@[simp]

theorem CategoryTheory.Square.flip_f₁₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.f₁₃ = sq.f₁₂

@[simp]

theorem CategoryTheory.Square.flip_X₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.X₃ = sq.X₂

@[simp]

theorem CategoryTheory.Square.flip_X₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.flip.X₄ = sq.X₄

def CategoryTheory.Square.flipFunctor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Square C)

The functor which flips commutative squares.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.flipFunctor_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square.flipFunctor.obj sq = sq.flip

@[simp]

theorem CategoryTheory.Square.flipFunctor_map_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.flipFunctor.map φ).τ₂ = φ.τ₃

@[simp]

theorem CategoryTheory.Square.flipFunctor_map_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.flipFunctor.map φ).τ₁ = φ.τ₁

@[simp]

theorem CategoryTheory.Square.flipFunctor_map_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.flipFunctor.map φ).τ₃ = φ.τ₂

@[simp]

theorem CategoryTheory.Square.flipFunctor_map_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.flipFunctor.map φ).τ₄ = φ.τ₄

def CategoryTheory.Square.flipEquivalence {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square C ≌ CategoryTheory.Square C

Flipping commutative squares is an auto-equivalence.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.flipEquivalence_counitIso {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.flipEquivalence.counitIso = CategoryTheory.Iso.refl (CategoryTheory.Square.flipFunctor.comp CategoryTheory.Square.flipFunctor)

@[simp]

theorem CategoryTheory.Square.flipEquivalence_unitIso {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.flipEquivalence.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))

@[simp]

theorem CategoryTheory.Square.flipEquivalence_functor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.flipEquivalence.functor = CategoryTheory.Square.flipFunctor

@[simp]

theorem CategoryTheory.Square.flipEquivalence_inverse {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.flipEquivalence.inverse = CategoryTheory.Square.flipFunctor

def CategoryTheory.Square.toArrowArrowFunctor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Arrow (CategoryTheory.Arrow C))

The functor Square C ⥤ Arrow (Arrow C) which sends a commutative square sq to the obvious arrow from the left morphism of sq to the right morphism of sq.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_right_hom {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.hom = sq.f₂₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_map_right_left {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor.map φ).right.left = φ.τ₂

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_map_left_left {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor.map φ).left.left = φ.τ₁

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_right_right {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.right = sq.X₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_left_right {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.right = sq.X₃

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_left_hom {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.hom = sq.f₁₃

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_hom_left {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.left = sq.f₁₂

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_hom_right {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.right = sq.f₃₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_right_left {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.left = sq.X₂

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_obj_left_left {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.left = sq.X₁

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_map_right_right {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor.map φ).right.right = φ.τ₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor_map_left_right {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor.map φ).left.right = φ.τ₃

def CategoryTheory.Square.fromArrowArrowFunctor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Arrow (CategoryTheory.Arrow C)) (CategoryTheory.Square C)

The functor Arrow (Arrow C) ⥤ Square C which sends a morphism Arrow.mk f ⟶ Arrow.mk g to the commutative square with f on the left side and g on the right side.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_map_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₃ = φ.left.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_X₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₁ = f.left.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_f₂₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₂₄ = f.right.hom

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_X₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₂ = f.right.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_X₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₄ = f.right.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₂ = f.hom.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₃ = f.left.hom

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_X₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₃ = f.left.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_map_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₄ = φ.right.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_obj_f₃₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₃₄ = f.hom.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_map_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₂ = φ.right.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor_map_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₁ = φ.left.left

def CategoryTheory.Square.arrowArrowEquivalence {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square C ≌ CategoryTheory.Arrow (CategoryTheory.Arrow C)

The equivalence Square C ≌ Arrow (Arrow C) which sends a commutative square sq to the obvious arrow from the left morphism of sq to the right morphism of sq.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence_inverse {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence.inverse = CategoryTheory.Square.fromArrowArrowFunctor

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence_functor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence.functor = CategoryTheory.Square.toArrowArrowFunctor

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence_counitIso {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence.counitIso = CategoryTheory.Iso.refl (CategoryTheory.Square.fromArrowArrowFunctor.comp CategoryTheory.Square.toArrowArrowFunctor)

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence_unitIso {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))

def CategoryTheory.Square.toArrowArrowFunctor' {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Arrow (CategoryTheory.Arrow C))

The functor Square C ⥤ Arrow (Arrow C) which sends a commutative square sq to the obvious arrow from the top morphism of sq to the bottom morphism of sq.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_left_left {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.left = sq.X₁

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_left_right {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.right = sq.X₂

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_hom_left {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).hom.left = sq.f₁₃

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_hom_right {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).hom.right = sq.f₂₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_map_left_right {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor'.map φ).left.right = φ.τ₂

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_map_left_left {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor'.map φ).left.left = φ.τ₁

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_right_hom {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).right.hom = sq.f₃₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_right_left {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).right.left = sq.X₃

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_map_right_left {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor'.map φ).right.left = φ.τ₃

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_left_hom {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.hom = sq.f₁₂

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_obj_right_right {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

(CategoryTheory.Square.toArrowArrowFunctor'.obj sq).right.right = sq.X₄

@[simp]

theorem CategoryTheory.Square.toArrowArrowFunctor'_map_right_right {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.toArrowArrowFunctor'.map φ).right.right = φ.τ₄

def CategoryTheory.Square.fromArrowArrowFunctor' {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Arrow (CategoryTheory.Arrow C)) (CategoryTheory.Square C)

The functor Arrow (Arrow C) ⥤ Square C which sends a morphism Arrow.mk f ⟶ Arrow.mk g to the commutative square with f on the top side and g on the bottom side.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₁ = φ.left.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₁ = f.left.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₄ = φ.right.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₂ = f.left.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₃₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₃₄ = f.right.hom

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₂ = φ.left.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₄ = f.right.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₃ = φ.right.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₁₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₁₂ = f.left.hom

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₂₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₂₄ = f.hom.right

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₁₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₁₃ = f.hom.left

@[simp]

theorem CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (f : CategoryTheory.Arrow (CategoryTheory.Arrow C)) :

(CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₃ = f.right.left

def CategoryTheory.Square.arrowArrowEquivalence' {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square C ≌ CategoryTheory.Arrow (CategoryTheory.Arrow C)

The equivalence Square C ≌ Arrow (Arrow C) which sends a commutative square sq to the obvious arrow from the top morphism of sq to the bottom morphism of sq.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence'_unitIso {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence'.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence'_functor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence'.functor = CategoryTheory.Square.toArrowArrowFunctor'

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence'_inverse {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence'.inverse = CategoryTheory.Square.fromArrowArrowFunctor'

@[simp]

theorem CategoryTheory.Square.arrowArrowEquivalence'_counitIso {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Square.arrowArrowEquivalence'.counitIso = CategoryTheory.Iso.refl (CategoryTheory.Square.fromArrowArrowFunctor'.comp CategoryTheory.Square.toArrowArrowFunctor')

def CategoryTheory.Square.evaluation₁ {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) C

The top-left evaluation Square C ⥤ C.

Equations

CategoryTheory.Square.evaluation₁ = { obj := fun (sq : CategoryTheory.Square C) => sq.X₁, map := fun {X Y : CategoryTheory.Square C} (φ : X ⟶ Y) => φ.τ₁, map_id := ⋯, map_comp := ⋯ }

Instances For

@[simp]

theorem CategoryTheory.Square.evaluation₁_map {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

CategoryTheory.Square.evaluation₁.map φ = φ.τ₁

@[simp]

theorem CategoryTheory.Square.evaluation₁_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square.evaluation₁.obj sq = sq.X₁

def CategoryTheory.Square.evaluation₂ {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) C

The top-right evaluation Square C ⥤ C.

Equations

CategoryTheory.Square.evaluation₂ = { obj := fun (sq : CategoryTheory.Square C) => sq.X₂, map := fun {X Y : CategoryTheory.Square C} (φ : X ⟶ Y) => φ.τ₂, map_id := ⋯, map_comp := ⋯ }

Instances For

@[simp]

theorem CategoryTheory.Square.evaluation₂_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square.evaluation₂.obj sq = sq.X₂

@[simp]

theorem CategoryTheory.Square.evaluation₂_map {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

CategoryTheory.Square.evaluation₂.map φ = φ.τ₂

def CategoryTheory.Square.evaluation₃ {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) C

The bottom-left evaluation Square C ⥤ C.

Equations

CategoryTheory.Square.evaluation₃ = { obj := fun (sq : CategoryTheory.Square C) => sq.X₃, map := fun {X Y : CategoryTheory.Square C} (φ : X ⟶ Y) => φ.τ₃, map_id := ⋯, map_comp := ⋯ }

Instances For

@[simp]

theorem CategoryTheory.Square.evaluation₃_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square.evaluation₃.obj sq = sq.X₃

@[simp]

theorem CategoryTheory.Square.evaluation₃_map {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

CategoryTheory.Square.evaluation₃.map φ = φ.τ₃

def CategoryTheory.Square.evaluation₄ {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C) C

The bottom-right evaluation Square C ⥤ C.

Equations

CategoryTheory.Square.evaluation₄ = { obj := fun (sq : CategoryTheory.Square C) => sq.X₄, map := fun {X Y : CategoryTheory.Square C} (φ : X ⟶ Y) => φ.τ₄, map_id := ⋯, map_comp := ⋯ }

Instances For

@[simp]

theorem CategoryTheory.Square.evaluation₄_map {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

CategoryTheory.Square.evaluation₄.map φ = φ.τ₄

@[simp]

theorem CategoryTheory.Square.evaluation₄_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square.evaluation₄.obj sq = sq.X₄

def CategoryTheory.Square.op {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

CategoryTheory.Square Cᵒᵖ

The map Square C → Square Cᵒᵖ which switches X₁ and X₃, but does not move X₂ and X₃.

Equations

sq.op = CategoryTheory.Square.mk sq.f₂₄.op sq.f₃₄.op sq.f₁₂.op sq.f₁₃.op ⋯

Instances For

@[simp]

theorem CategoryTheory.Square.op_f₃₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.f₃₄ = sq.f₁₃.op

@[simp]

theorem CategoryTheory.Square.op_X₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.X₃ = Opposite.op sq.X₃

@[simp]

theorem CategoryTheory.Square.op_f₂₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.f₂₄ = sq.f₁₂.op

@[simp]

theorem CategoryTheory.Square.op_X₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.X₄ = Opposite.op sq.X₁

@[simp]

theorem CategoryTheory.Square.op_X₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.X₂ = Opposite.op sq.X₂

@[simp]

theorem CategoryTheory.Square.op_X₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.X₁ = Opposite.op sq.X₄

@[simp]

theorem CategoryTheory.Square.op_f₁₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.f₁₃ = sq.f₃₄.op

@[simp]

theorem CategoryTheory.Square.op_f₁₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square C) :

sq.op.f₁₂ = sq.f₂₄.op

def CategoryTheory.Square.unop {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

CategoryTheory.Square C

The map Square Cᵒᵖ → Square C which switches X₁ and X₃, but does not move X₂ and X₃.

Equations

sq.unop = CategoryTheory.Square.mk sq.f₂₄.unop sq.f₃₄.unop sq.f₁₂.unop sq.f₁₃.unop ⋯

Instances For

@[simp]

theorem CategoryTheory.Square.unop_f₁₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.f₁₂ = sq.f₂₄.unop

@[simp]

theorem CategoryTheory.Square.unop_X₂ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.X₂ = Opposite.unop sq.X₂

@[simp]

theorem CategoryTheory.Square.unop_X₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.X₄ = Opposite.unop sq.X₁

@[simp]

theorem CategoryTheory.Square.unop_f₂₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.f₂₄ = sq.f₁₂.unop

@[simp]

theorem CategoryTheory.Square.unop_X₁ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.X₁ = Opposite.unop sq.X₄

@[simp]

theorem CategoryTheory.Square.unop_f₃₄ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.f₃₄ = sq.f₁₃.unop

@[simp]

theorem CategoryTheory.Square.unop_f₁₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.f₁₃ = sq.f₃₄.unop

@[simp]

theorem CategoryTheory.Square.unop_X₃ {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ) :

sq.unop.X₃ = Opposite.unop sq.X₃

def CategoryTheory.Square.opFunctor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square C)ᵒᵖ (CategoryTheory.Square Cᵒᵖ)

The functor (Square C)ᵒᵖ ⥤ Square Cᵒᵖ.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.opFunctor_map_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : (CategoryTheory.Square C)ᵒᵖ} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.opFunctor.map φ).τ₂ = φ.unop.τ₂.op

@[simp]

theorem CategoryTheory.Square.opFunctor_map_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : (CategoryTheory.Square C)ᵒᵖ} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.opFunctor.map φ).τ₄ = φ.unop.τ₁.op

@[simp]

theorem CategoryTheory.Square.opFunctor_map_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : (CategoryTheory.Square C)ᵒᵖ} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.opFunctor.map φ).τ₃ = φ.unop.τ₃.op

@[simp]

theorem CategoryTheory.Square.opFunctor_obj {C : Type u} [CategoryTheory.Category.{v, u} C] (sq : (CategoryTheory.Square C)ᵒᵖ) :

CategoryTheory.Square.opFunctor.obj sq = (Opposite.unop sq).op

@[simp]

theorem CategoryTheory.Square.opFunctor_map_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {X✝ Y✝ : (CategoryTheory.Square C)ᵒᵖ} (φ : X✝ ⟶ Y✝) :

(CategoryTheory.Square.opFunctor.map φ).τ₁ = φ.unop.τ₄.op

def CategoryTheory.Square.unopFunctor {C : Type u} [CategoryTheory.Category.{v, u} C] :

CategoryTheory.Functor (CategoryTheory.Square Cᵒᵖ)ᵒᵖ (CategoryTheory.Square C)

The functor (Square Cᵒᵖ)ᵒᵖ ⥤ Square Cᵒᵖ.

Equations

One or more equations did not get rendered due to their size.

Instances For

def CategoryTheory.Square.opEquivalence {C : Type u} [CategoryTheory.Category.{v, u} C] :

(CategoryTheory.Square C)ᵒᵖ ≌ CategoryTheory.Square Cᵒᵖ

The equivalence (Square C)ᵒᵖ ≌ Square Cᵒᵖ.

Equations

One or more equations did not get rendered due to their size.

Instances For

def CategoryTheory.Square.map {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

CategoryTheory.Square D

The image of a commutative square by a functor.

Equations

sq.map F = CategoryTheory.Square.mk (F.map sq.f₁₂) (F.map sq.f₁₃) (F.map sq.f₂₄) (F.map sq.f₃₄) ⋯

Instances For

@[simp]

theorem CategoryTheory.Square.map_f₂₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).f₂₄ = F.map sq.f₂₄

@[simp]

theorem CategoryTheory.Square.map_X₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).X₂ = F.obj sq.X₂

@[simp]

theorem CategoryTheory.Square.map_f₁₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).f₁₂ = F.map sq.f₁₂

@[simp]

theorem CategoryTheory.Square.map_X₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).X₁ = F.obj sq.X₁

@[simp]

theorem CategoryTheory.Square.map_X₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).X₄ = F.obj sq.X₄

@[simp]

theorem CategoryTheory.Square.map_f₃₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).f₃₄ = F.map sq.f₃₄

@[simp]

theorem CategoryTheory.Square.map_X₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).X₃ = F.obj sq.X₃

@[simp]

theorem CategoryTheory.Square.map_f₁₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (sq : CategoryTheory.Square C) (F : CategoryTheory.Functor C D) :

(sq.map F).f₁₃ = F.map sq.f₁₃

def CategoryTheory.Functor.mapSquare {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) :

CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Square D)

The functor Square C ⥤ Square D induced by a functor C ⥤ D.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Functor.mapSquare_map_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(F.mapSquare.map φ).τ₁ = F.map φ.τ₁

@[simp]

theorem CategoryTheory.Functor.mapSquare_map_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(F.mapSquare.map φ).τ₃ = F.map φ.τ₃

@[simp]

theorem CategoryTheory.Functor.mapSquare_map_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(F.mapSquare.map φ).τ₂ = F.map φ.τ₂

@[simp]

theorem CategoryTheory.Functor.mapSquare_map_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) {X✝ Y✝ : CategoryTheory.Square C} (φ : X✝ ⟶ Y✝) :

(F.mapSquare.map φ).τ₄ = F.map φ.τ₄

@[simp]

theorem CategoryTheory.Functor.mapSquare_obj {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) (sq : CategoryTheory.Square C) :

F.mapSquare.obj sq = sq.map F

def CategoryTheory.NatTrans.mapSquare {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) :

F.mapSquare ⟶ G.mapSquare

The natural transformation F.mapSquare ⟶ G.mapSquare induces by a natural transformation F ⟶ G.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.NatTrans.mapSquare_app_τ₂ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) (sq : CategoryTheory.Square C) :

((CategoryTheory.NatTrans.mapSquare τ).app sq).τ₂ = τ.app sq.X₂

@[simp]

theorem CategoryTheory.NatTrans.mapSquare_app_τ₃ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) (sq : CategoryTheory.Square C) :

((CategoryTheory.NatTrans.mapSquare τ).app sq).τ₃ = τ.app sq.X₃

@[simp]

theorem CategoryTheory.NatTrans.mapSquare_app_τ₁ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) (sq : CategoryTheory.Square C) :

((CategoryTheory.NatTrans.mapSquare τ).app sq).τ₁ = τ.app sq.X₁

@[simp]

theorem CategoryTheory.NatTrans.mapSquare_app_τ₄ {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {F G : CategoryTheory.Functor C D} (τ : F ⟶ G) (sq : CategoryTheory.Square C) :

((CategoryTheory.NatTrans.mapSquare τ).app sq).τ₄ = τ.app sq.X₄

def CategoryTheory.Square.mapFunctor {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] :

CategoryTheory.Functor (CategoryTheory.Functor C D) (CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Square D))

The functor (C ⥤ D) ⥤ Square C ⥤ Square D.

Equations

One or more equations did not get rendered due to their size.

Instances For

@[simp]

theorem CategoryTheory.Square.mapFunctor_obj {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] (F : CategoryTheory.Functor C D) :

CategoryTheory.Square.mapFunctor.obj F = F.mapSquare

@[simp]

theorem CategoryTheory.Square.mapFunctor_map {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u'} [CategoryTheory.Category.{v', u'} D] {X✝ Y✝ : CategoryTheory.Functor C D} (τ : X✝ ⟶ Y✝) :

CategoryTheory.Square.mapFunctor.map τ = CategoryTheory.NatTrans.mapSquare τ