File: Mathlib/CategoryTheory/Square.lean

full_name: CategoryTheory.Square.fac
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: CategoryTheory.CategoryStruct.comp self.f₁₂ self.f₂₄ = CategoryTheory.CategoryStruct.comp self.f₁₃ self.f₃₄

full_name: CategoryTheory.Square.f₃₄
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: self.X₃ ⟶ self.X₄

full_name: CategoryTheory.Square.X₁
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: C

full_name: CategoryTheory.Square.f₁₂
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: self.X₁ ⟶ self.X₂

full_name: CategoryTheory.Square.f₂₄
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: self.X₂ ⟶ self.X₄

full_name: CategoryTheory.Square.X₂
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: C

full_name: CategoryTheory.Square.f₁₃
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: self.X₁ ⟶ self.X₃

full_name: CategoryTheory.Square
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: Type (max u v)

full_name: CategoryTheory.Square.X₄
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: C

full_name: CategoryTheory.Square.X₃
code: /-- The category of commutative squares in a category. -/
structure Square where
  /-- the top-left object -/
  {X₁ : C}
  /-- the top-right object -/
  {X₂ : C}
  /-- the bottom-left object -/
  {X₃ : C}
  /-- the bottom-right object -/
  {X₄ : C}
  /-- the top morphism -/
  f₁₂ : X₁ ⟶ X₂
  /-- the left morphism -/
  f₁₃ : X₁ ⟶ X₃
  /-- the right morphism -/
  f₂₄ : X₂ ⟶ X₄
  /-- the bottom morphism -/
  f₃₄ : X₃ ⟶ X₄
  fac : f₁₂ ≫ f₂₄ = f₁₃ ≫ f₃₄
goal: C

full_name: CategoryTheory.Square.commSq
code: lemma commSq (sq : Square C) : CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄ 
goal: CategoryTheory.CommSq sq.f₁₂ sq.f₁₃ sq.f₂₄ sq.f₃₄

full_name: CategoryTheory.Square.Hom.comm₁₃
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp sq₁.f₁₃ self.τ₃ = CategoryTheory.CategoryStruct.comp self.τ₁ sq₂.f₁₃

full_name: CategoryTheory.Square.Hom.τ₁
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: sq₁.X₁ ⟶ sq₂.X₁

full_name: CategoryTheory.Square.Hom
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: Type v

full_name: CategoryTheory.Square.Hom.comm₃₄
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp sq₁.f₃₄ self.τ₄ = CategoryTheory.CategoryStruct.comp self.τ₃ sq₂.f₃₄

full_name: CategoryTheory.Square.Hom.comm₁₂
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp sq₁.f₁₂ self.τ₂ = CategoryTheory.CategoryStruct.comp self.τ₁ sq₂.f₁₂

full_name: CategoryTheory.Square.Hom.τ₂
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: sq₁.X₂ ⟶ sq₂.X₂

full_name: CategoryTheory.Square.Hom.τ₃
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: sq₁.X₃ ⟶ sq₂.X₃

full_name: CategoryTheory.Square.Hom.comm₂₄
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: CategoryTheory.CategoryStruct.comp sq₁.f₂₄ self.τ₄ = CategoryTheory.CategoryStruct.comp self.τ₂ sq₂.f₂₄

full_name: CategoryTheory.Square.Hom.τ₄
code: /-- A morphism between two commutative squares consists of 4 morphisms
which extend these two squares into a commuting cube. -/
@[ext]
structure Hom (sq₁ sq₂ : Square C) where
  /-- 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 -/
  τ₄ : sq₁.X₄ ⟶ sq₂.X₄
  comm₁₂ : sq₁.f₁₂ ≫ τ₂ = τ₁ ≫ sq₂.f₁₂ := by aesop_cat
  comm₁₃ : sq₁.f₁₃ ≫ τ₃ = τ₁ ≫ sq₂.f₁₃ := by aesop_cat
  comm₂₄ : sq₁.f₂₄ ≫ τ₄ = τ₂ ≫ sq₂.f₂₄ := by aesop_cat
  comm₃₄ : sq₁.f₃₄ ≫ τ₄ = τ₃ ≫ sq₂.f₃₄ := by aesop_cat
goal: sq₁.X₄ ⟶ sq₂.X₄

full_name: CategoryTheory.Square.Hom.id_τ₂
code: /-- The identity of a commutative square. -/
@[simps]
def id (sq : Square C) : Hom sq sq 
goal: (CategoryTheory.Square.Hom.id sq).τ₂ = CategoryTheory.CategoryStruct.id sq.X₂

full_name: CategoryTheory.Square.Hom.id_τ₃
code: /-- The identity of a commutative square. -/
@[simps]
def id (sq : Square C) : Hom sq sq 
goal: (CategoryTheory.Square.Hom.id sq).τ₃ = CategoryTheory.CategoryStruct.id sq.X₃

full_name: CategoryTheory.Square.Hom.id
code: /-- The identity of a commutative square. -/
@[simps]
def id (sq : Square C) : Hom sq sq 
goal: sq.Hom sq

full_name: CategoryTheory.Square.Hom.id_τ₄
code: /-- The identity of a commutative square. -/
@[simps]
def id (sq : Square C) : Hom sq sq 
goal: (CategoryTheory.Square.Hom.id sq).τ₄ = CategoryTheory.CategoryStruct.id sq.X₄

full_name: CategoryTheory.Square.Hom.id_τ₁
code: /-- The identity of a commutative square. -/
@[simps]
def id (sq : Square C) : Hom sq sq 
goal: (CategoryTheory.Square.Hom.id sq).τ₁ = CategoryTheory.CategoryStruct.id sq.X₁

full_name: CategoryTheory.Square.Hom.comp_τ₂
code: /-- The composition of morphisms of squares. -/
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
goal: (f.comp g).τ₂ = CategoryTheory.CategoryStruct.comp f.τ₂ g.τ₂

full_name: CategoryTheory.Square.Hom.comp_τ₄
code: /-- The composition of morphisms of squares. -/
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
goal: (f.comp g).τ₄ = CategoryTheory.CategoryStruct.comp f.τ₄ g.τ₄

full_name: CategoryTheory.Square.Hom.comp_τ₃
code: /-- The composition of morphisms of squares. -/
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
goal: (f.comp g).τ₃ = CategoryTheory.CategoryStruct.comp f.τ₃ g.τ₃

full_name: CategoryTheory.Square.Hom.comp
code: /-- The composition of morphisms of squares. -/
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
goal: sq₁.Hom sq₃

full_name: CategoryTheory.Square.Hom.comp_τ₁
code: /-- The composition of morphisms of squares. -/
@[simps]
def comp {sq₁ sq₂ sq₃ : Square C} (f : Hom sq₁ sq₂) (g : Hom sq₂ sq₃) : Hom sq₁ sq₃ 
goal: (f.comp g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁

full_name: CategoryTheory.Square.category_comp_τ₁
code: @[simps!]
instance category : Category (Square C) 
goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₁ = CategoryTheory.CategoryStruct.comp f.τ₁ g.τ₁

full_name: CategoryTheory.Square.category_id_τ₁
code: @[simps!]
instance category : Category (Square C) 
goal: (CategoryTheory.CategoryStruct.id sq).τ₁ = CategoryTheory.CategoryStruct.id sq.X₁

full_name: CategoryTheory.Square.category
code: @[simps!]
instance category : Category (Square C) 
goal: CategoryTheory.Category.{v, max u v} (CategoryTheory.Square C)

full_name: CategoryTheory.Square.category_id_τ₂
code: @[simps!]
instance category : Category (Square C) 
goal: (CategoryTheory.CategoryStruct.id sq).τ₂ = CategoryTheory.CategoryStruct.id sq.X₂

full_name: CategoryTheory.Square.category_comp_τ₂
code: @[simps!]
instance category : Category (Square C) 
goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₂ = CategoryTheory.CategoryStruct.comp f.τ₂ g.τ₂

full_name: CategoryTheory.Square.category_id_τ₃
code: @[simps!]
instance category : Category (Square C) 
goal: (CategoryTheory.CategoryStruct.id sq).τ₃ = CategoryTheory.CategoryStruct.id sq.X₃

full_name: CategoryTheory.Square.category_comp_τ₃
code: @[simps!]
instance category : Category (Square C) 
goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₃ = CategoryTheory.CategoryStruct.comp f.τ₃ g.τ₃

full_name: CategoryTheory.Square.category_id_τ₄
code: @[simps!]
instance category : Category (Square C) 
goal: (CategoryTheory.CategoryStruct.id sq).τ₄ = CategoryTheory.CategoryStruct.id sq.X₄

full_name: CategoryTheory.Square.category_comp_τ₄
code: @[simps!]
instance category : Category (Square C) 
goal: ∀ {X Y Z : CategoryTheory.Square C} (f : X.Hom Y) (g : Y.Hom Z),
  (CategoryTheory.CategoryStruct.comp f g).τ₄ = CategoryTheory.CategoryStruct.comp f.τ₄ g.τ₄

full_name: CategoryTheory.Square.hom_ext
code: @[ext]
lemma hom_ext {sq₁ sq₂ : Square C} {f g : sq₁ ⟶ sq₂}
    (h₁ : f.τ₁ = g.τ₁) (h₂ : f.τ₂ = g.τ₂)
    (h₃ : f.τ₃ = g.τ₃) (h₄ : f.τ₄ = g.τ₄) : f = g 
goal: f = g

full_name: CategoryTheory.Square.isoMk
code: /-- Constructor for isomorphisms in `Square c` -/
def isoMk {sq₁ sq₂ : Square C} (e₁ : sq₁.X₁ ≅ sq₂.X₁) (e₂ : sq₁.X₂ ≅ sq₂.X₂)
    (e₃ : sq₁.X₃ ≅ sq₂.X₃) (e₄ : sq₁.X₄ ≅ sq₂.X₄)
    (comm₁₂ : sq₁.f₁₂ ≫ e₂.hom = e₁.hom ≫ sq₂.f₁₂)
    (comm₁₃ : sq₁.f₁₃ ≫ e₃.hom = e₁.hom ≫ sq₂.f₁₃)
    (comm₂₄ : sq₁.f₂₄ ≫ e₄.hom = e₂.hom ≫ sq₂.f₂₄)
    (comm₃₄ : sq₁.f₃₄ ≫ e₄.hom = e₃.hom ≫ sq₂.f₃₄) :
    sq₁ ≅ sq₂ 
goal: sq₁ ≅ sq₂

full_name: CategoryTheory.Square.flip_X₄
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.X₄ = sq.X₄

full_name: CategoryTheory.Square.flip_f₃₄
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.f₃₄ = sq.f₂₄

full_name: CategoryTheory.Square.flip_f₂₄
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.f₂₄ = sq.f₃₄

full_name: CategoryTheory.Square.flip_X₃
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.X₃ = sq.X₂

full_name: CategoryTheory.Square.flip_f₁₃
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.f₁₃ = sq.f₁₂

full_name: CategoryTheory.Square.flip
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: CategoryTheory.Square C

full_name: CategoryTheory.Square.flip_X₁
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.X₁ = sq.X₁

full_name: CategoryTheory.Square.flip_X₂
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.X₂ = sq.X₃

full_name: CategoryTheory.Square.flip_f₁₂
code: /-- Flipping a square by switching the top-right and the bottom-left objects. -/
@[simps]
def flip (sq : Square C) : Square C 
goal: sq.flip.f₁₂ = sq.f₁₃

full_name: CategoryTheory.Square.flipFunctor_map_τ₃
code: /-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₃ = φ.τ₂

full_name: CategoryTheory.Square.flipFunctor_map_τ₁
code: /-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₁ = φ.τ₁

full_name: CategoryTheory.Square.flipFunctor_map_τ₄
code: /-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₄ = φ.τ₄

full_name: CategoryTheory.Square.flipFunctor_obj
code: /-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C 
goal: CategoryTheory.Square.flipFunctor.obj sq = sq.flip

full_name: CategoryTheory.Square.flipFunctor_map_τ₂
code: /-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.flipFunctor.map φ).τ₂ = φ.τ₃

full_name: CategoryTheory.Square.flipFunctor
code: /-- The functor which flips commutative squares. -/
@[simps]
def flipFunctor : Square C ⥤ Square C 
goal: CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Square C)

full_name: CategoryTheory.Square.flipEquivalence_unitIso
code: /-- Flipping commutative squares is an auto-equivalence. -/
@[simps]
def flipEquivalence : Square C ≌ Square C 
goal: CategoryTheory.Square.flipEquivalence.unitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))

full_name: CategoryTheory.Square.flipEquivalence
code: /-- Flipping commutative squares is an auto-equivalence. -/
@[simps]
def flipEquivalence : Square C ≌ Square C 
goal: CategoryTheory.Square C ≌ CategoryTheory.Square C

full_name: CategoryTheory.Square.flipEquivalence_functor
code: /-- Flipping commutative squares is an auto-equivalence. -/
@[simps]
def flipEquivalence : Square C ≌ Square C 
goal: CategoryTheory.Square.flipEquivalence.functor = CategoryTheory.Square.flipFunctor

full_name: CategoryTheory.Square.flipEquivalence_inverse
code: /-- Flipping commutative squares is an auto-equivalence. -/
@[simps]
def flipEquivalence : Square C ≌ Square C 
goal: CategoryTheory.Square.flipEquivalence.inverse = CategoryTheory.Square.flipFunctor

full_name: CategoryTheory.Square.flipEquivalence_counitIso
code: /-- Flipping commutative squares is an auto-equivalence. -/
@[simps]
def flipEquivalence : Square C ≌ Square C 
goal: CategoryTheory.Square.flipEquivalence.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Square.flipFunctor.comp CategoryTheory.Square.flipFunctor)

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_left_hom
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.hom = sq.f₁₃

full_name: CategoryTheory.Square.toArrowArrowFunctor_map_left_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).left.right = φ.τ₃

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_left_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.right = sq.X₃

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_hom_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.left = sq.f₁₂

full_name: CategoryTheory.Square.toArrowArrowFunctor_map_right_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).right.left = φ.τ₂

full_name: CategoryTheory.Square.toArrowArrowFunctor
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Arrow (CategoryTheory.Arrow C))

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_right_hom
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.hom = sq.f₂₄

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_right_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.right = sq.X₄

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_right_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).right.left = sq.X₂

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_hom_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).hom.right = sq.f₃₄

full_name: CategoryTheory.Square.toArrowArrowFunctor_obj_left_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor.obj sq).left.left = sq.X₁

full_name: CategoryTheory.Square.toArrowArrowFunctor_map_right_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).right.right = φ.τ₄

full_name: CategoryTheory.Square.toArrowArrowFunctor_map_left_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor.map φ).left.left = φ.τ₁

full_name: CategoryTheory.Square.fromArrowArrowFunctor_map_τ₁
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₁ = φ.left.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: CategoryTheory.Functor (CategoryTheory.Arrow (CategoryTheory.Arrow C)) (CategoryTheory.Square C)

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_f₃₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₃₄ = f.hom.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor_map_τ₂
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₂ = φ.right.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_X₃
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₃ = f.left.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_X₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₄ = f.right.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_X₂
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₂ = f.right.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₂
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₂ = f.hom.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_f₁₃
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₁₃ = f.left.hom

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_f₂₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).f₂₄ = f.right.hom

full_name: CategoryTheory.Square.fromArrowArrowFunctor_map_τ₃
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₃ = φ.left.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor_map_τ₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor.map φ).τ₄ = φ.right.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor_obj_X₁
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor.obj f).X₁ = f.left.left

full_name: CategoryTheory.Square.arrowArrowEquivalence_unitIso
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence.unitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))

full_name: CategoryTheory.Square.arrowArrowEquivalence_functor
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence.functor = CategoryTheory.Square.toArrowArrowFunctor

full_name: CategoryTheory.Square.arrowArrowEquivalence_inverse
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence.inverse = CategoryTheory.Square.fromArrowArrowFunctor

full_name: CategoryTheory.Square.arrowArrowEquivalence_counitIso
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Square.fromArrowArrowFunctor.comp CategoryTheory.Square.toArrowArrowFunctor)

full_name: CategoryTheory.Square.arrowArrowEquivalence
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square C ≌ CategoryTheory.Arrow (CategoryTheory.Arrow C)

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_right_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).right.right = sq.X₄

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_right_hom
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).right.hom = sq.f₃₄

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_hom_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).hom.right = sq.f₂₄

full_name: CategoryTheory.Square.toArrowArrowFunctor'_map_left_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor'.map φ).left.left = φ.τ₁

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_left_hom
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.hom = sq.f₁₂

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_hom_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).hom.left = sq.f₁₃

full_name: CategoryTheory.Square.toArrowArrowFunctor'_map_right_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor'.map φ).right.left = φ.τ₃

full_name: CategoryTheory.Square.toArrowArrowFunctor'_map_left_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor'.map φ).left.right = φ.τ₂

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_left_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.left = sq.X₁

full_name: CategoryTheory.Square.toArrowArrowFunctor'
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Arrow (CategoryTheory.Arrow C))

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_right_left
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).right.left = sq.X₃

full_name: CategoryTheory.Square.toArrowArrowFunctor'_obj_left_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: (CategoryTheory.Square.toArrowArrowFunctor'.obj sq).left.right = sq.X₂

full_name: CategoryTheory.Square.toArrowArrowFunctor'_map_right_right
code: /-- 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`. -/
@[simps!]
def toArrowArrowFunctor' : Square C ⥤ Arrow (Arrow C) 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), (CategoryTheory.Square.toArrowArrowFunctor'.map φ).right.right = φ.τ₄

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₂₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₂₄ = f.hom.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₁
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₁ = f.left.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₂
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₂ = f.left.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₁
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₁ = φ.left.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₂
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₂ = φ.left.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₄ = φ.right.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₃
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₃ = f.right.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₁₃
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₁₃ = f.hom.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_map_τ₃
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: ∀ {X Y : CategoryTheory.Arrow (CategoryTheory.Arrow C)} (φ : X ⟶ Y),
  (CategoryTheory.Square.fromArrowArrowFunctor'.map φ).τ₃ = φ.right.left

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₃₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₃₄ = f.right.hom

full_name: CategoryTheory.Square.fromArrowArrowFunctor'
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: CategoryTheory.Functor (CategoryTheory.Arrow (CategoryTheory.Arrow C)) (CategoryTheory.Square C)

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_X₄
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).X₄ = f.right.right

full_name: CategoryTheory.Square.fromArrowArrowFunctor'_obj_f₁₂
code: /-- 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. -/
@[simps!]
def fromArrowArrowFunctor' : Arrow (Arrow C) ⥤ Square C 
goal: (CategoryTheory.Square.fromArrowArrowFunctor'.obj f).f₁₂ = f.left.hom

full_name: CategoryTheory.Square.arrowArrowEquivalence'_unitIso
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence'.unitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.Square C))

full_name: CategoryTheory.Square.arrowArrowEquivalence'
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square C ≌ CategoryTheory.Arrow (CategoryTheory.Arrow C)

full_name: CategoryTheory.Square.arrowArrowEquivalence'_functor
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence'.functor = CategoryTheory.Square.toArrowArrowFunctor'

full_name: CategoryTheory.Square.arrowArrowEquivalence'_inverse
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence'.inverse = CategoryTheory.Square.fromArrowArrowFunctor'

full_name: CategoryTheory.Square.arrowArrowEquivalence'_counitIso
code: /-- 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`. -/
@[simps]
def arrowArrowEquivalence' : Square C ≌ Arrow (Arrow C) 
goal: CategoryTheory.Square.arrowArrowEquivalence'.counitIso =
  CategoryTheory.Iso.refl (CategoryTheory.Square.fromArrowArrowFunctor'.comp CategoryTheory.Square.toArrowArrowFunctor')

full_name: CategoryTheory.Square.evaluation₁_obj
code: /-- The top-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₁ : Square C ⥤ C 
goal: CategoryTheory.Square.evaluation₁.obj sq = sq.X₁

full_name: CategoryTheory.Square.evaluation₁_map
code: /-- The top-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₁ : Square C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₁.map φ = φ.τ₁

full_name: CategoryTheory.Square.evaluation₁
code: /-- The top-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₁ : Square C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Square C) C

full_name: CategoryTheory.Square.evaluation₂_map
code: /-- The top-right evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₂ : Square C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₂.map φ = φ.τ₂

full_name: CategoryTheory.Square.evaluation₂
code: /-- The top-right evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₂ : Square C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Square C) C

full_name: CategoryTheory.Square.evaluation₂_obj
code: /-- The top-right evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₂ : Square C ⥤ C 
goal: CategoryTheory.Square.evaluation₂.obj sq = sq.X₂

full_name: CategoryTheory.Square.evaluation₃_obj
code: /-- The bottom-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₃ : Square C ⥤ C 
goal: CategoryTheory.Square.evaluation₃.obj sq = sq.X₃

full_name: CategoryTheory.Square.evaluation₃
code: /-- The bottom-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₃ : Square C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Square C) C

full_name: CategoryTheory.Square.evaluation₃_map
code: /-- The bottom-left evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₃ : Square C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₃.map φ = φ.τ₃

full_name: CategoryTheory.Square.evaluation₄_map
code: /-- The bottom-right evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₄ : Square C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), CategoryTheory.Square.evaluation₄.map φ = φ.τ₄

full_name: CategoryTheory.Square.evaluation₄
code: /-- The bottom-right evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₄ : Square C ⥤ C 
goal: CategoryTheory.Functor (CategoryTheory.Square C) C

full_name: CategoryTheory.Square.evaluation₄_obj
code: /-- The bottom-right evaluation `Square C ⥤ C`. -/
@[simps]
def evaluation₄ : Square C ⥤ C 
goal: CategoryTheory.Square.evaluation₄.obj sq = sq.X₄

full_name: CategoryTheory.Square.op_f₃₄
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.f₃₄ = sq.f₁₃.op

full_name: CategoryTheory.Square.op_X₃
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.X₃ = Opposite.op sq.X₃

full_name: CategoryTheory.Square.op_f₁₂
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.f₁₂ = sq.f₂₄.op

full_name: CategoryTheory.Square.op_f₁₃
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.f₁₃ = sq.f₃₄.op

full_name: CategoryTheory.Square.op
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: CategoryTheory.Square Cᵒᵖ

full_name: CategoryTheory.Square.op_X₄
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.X₄ = Opposite.op sq.X₁

full_name: CategoryTheory.Square.op_X₁
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.X₁ = Opposite.op sq.X₄

full_name: CategoryTheory.Square.op_X₂
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.X₂ = Opposite.op sq.X₂

full_name: CategoryTheory.Square.op_f₂₄
code: /-- The map `Square C → Square Cᵒᵖ` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def op (sq : Square C) : Square Cᵒᵖ 
goal: sq.op.f₂₄ = sq.f₁₂.op

full_name: CategoryTheory.Square.unop_X₁
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.X₁ = Opposite.unop sq.X₄

full_name: CategoryTheory.Square.unop_f₁₂
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.f₁₂ = sq.f₂₄.unop

full_name: CategoryTheory.Square.unop_f₂₄
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.f₂₄ = sq.f₁₂.unop

full_name: CategoryTheory.Square.unop_X₃
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.X₃ = Opposite.unop sq.X₃

full_name: CategoryTheory.Square.unop_X₄
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.X₄ = Opposite.unop sq.X₁

full_name: CategoryTheory.Square.unop_f₃₄
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.f₃₄ = sq.f₁₃.unop

full_name: CategoryTheory.Square.unop
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: CategoryTheory.Square C

full_name: CategoryTheory.Square.unop_f₁₃
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.f₁₃ = sq.f₃₄.unop

full_name: CategoryTheory.Square.unop_X₂
code: /-- The map `Square Cᵒᵖ → Square C` which switches `X₁` and `X₃`, but
does not move `X₂` and `X₃`. -/
@[simps]
protected def unop (sq : Square Cᵒᵖ) : Square C 
goal: sq.unop.X₂ = Opposite.unop sq.X₂

full_name: CategoryTheory.Square.opFunctor_obj
code: /-- The functor `(Square C)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
goal: CategoryTheory.Square.opFunctor.obj sq = (Opposite.unop sq).op

full_name: CategoryTheory.Square.opFunctor_map_τ₃
code: /-- The functor `(Square C)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₃ = φ.unop.τ₃.op

full_name: CategoryTheory.Square.opFunctor
code: /-- The functor `(Square C)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
goal: CategoryTheory.Functor (CategoryTheory.Square C)ᵒᵖ (CategoryTheory.Square Cᵒᵖ)

full_name: CategoryTheory.Square.opFunctor_map_τ₄
code: /-- The functor `(Square C)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₄ = φ.unop.τ₁.op

full_name: CategoryTheory.Square.opFunctor_map_τ₂
code: /-- The functor `(Square C)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₂ = φ.unop.τ₂.op

full_name: CategoryTheory.Square.opFunctor_map_τ₁
code: /-- The functor `(Square C)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
@[simps]
def opFunctor : (Square C)ᵒᵖ ⥤ Square Cᵒᵖ 
goal: ∀ {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y), (CategoryTheory.Square.opFunctor.map φ).τ₁ = φ.unop.τ₄.op

full_name: CategoryTheory.Square.unopFunctor
code: /-- The functor `(Square Cᵒᵖ)ᵒᵖ ⥤ Square Cᵒᵖ`. -/
def unopFunctor : (Square Cᵒᵖ)ᵒᵖ ⥤ Square C 
goal: CategoryTheory.Functor (CategoryTheory.Square Cᵒᵖ)ᵒᵖ (CategoryTheory.Square C)

full_name: CategoryTheory.Square.opEquivalence
code: /-- The equivalence `(Square C)ᵒᵖ ≌ Square Cᵒᵖ`. -/
def opEquivalence : (Square C)ᵒᵖ ≌ Square Cᵒᵖ 
goal: (CategoryTheory.Square C)ᵒᵖ ≌ CategoryTheory.Square Cᵒᵖ

full_name: CategoryTheory.Square.map_f₁₃
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).f₁₃ = F.map sq.f₁₃

full_name: CategoryTheory.Square.map_f₃₄
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).f₃₄ = F.map sq.f₃₄

full_name: CategoryTheory.Square.map_f₂₄
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).f₂₄ = F.map sq.f₂₄

full_name: CategoryTheory.Square.map_f₁₂
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).f₁₂ = F.map sq.f₁₂

full_name: CategoryTheory.Square.map
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: CategoryTheory.Square D

full_name: CategoryTheory.Square.map_X₃
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).X₃ = F.obj sq.X₃

full_name: CategoryTheory.Square.map_X₁
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).X₁ = F.obj sq.X₁

full_name: CategoryTheory.Square.map_X₄
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).X₄ = F.obj sq.X₄

full_name: CategoryTheory.Square.map_X₂
code: /-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D 
goal: (sq.map F).X₂ = F.obj sq.X₂

full_name: CategoryTheory.Functor.mapSquare_map_τ₁
code: /-- The functor `Square C ⥤ Square D` induced by a functor `C ⥤ D`. -/
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₁ = F.map φ.τ₁

full_name: CategoryTheory.Functor.mapSquare_map_τ₂
code: /-- The functor `Square C ⥤ Square D` induced by a functor `C ⥤ D`. -/
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₂ = F.map φ.τ₂

full_name: CategoryTheory.Functor.mapSquare_map_τ₃
code: /-- The functor `Square C ⥤ Square D` induced by a functor `C ⥤ D`. -/
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₃ = F.map φ.τ₃

full_name: CategoryTheory.Functor.mapSquare_map_τ₄
code: /-- The functor `Square C ⥤ Square D` induced by a functor `C ⥤ D`. -/
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
goal: ∀ {X Y : CategoryTheory.Square C} (φ : X ⟶ Y), ((CategoryTheory.Functor.mapSquare C F).map φ).τ₄ = F.map φ.τ₄

full_name: CategoryTheory.Functor.mapSquare
code: /-- The functor `Square C ⥤ Square D` induced by a functor `C ⥤ D`. -/
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
goal: CategoryTheory.Functor (CategoryTheory.Square C) (CategoryTheory.Square D)

full_name: CategoryTheory.Functor.mapSquare_obj
code: /-- The functor `Square C ⥤ Square D` induced by a functor `C ⥤ D`. -/
@[simps]
def mapSquare (F : C ⥤ D) : Square C ⥤ Square D 
goal: (CategoryTheory.Functor.mapSquare C F).obj sq = sq.map F