fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
homMk₄_app_four :
(homMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).app ⟨4, by valid⟩ = app₄ := rfl | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₄_app_four | null |
@[ext]
hom_ext₄ {f g : ComposableArrows C 4} {φ φ' : f ⟶ g}
(h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
(h₃ : app' φ 3 = app' φ' 3) (h₄ : app' φ 4 = app' φ' 4) :
φ = φ' :=
hom_ext_succ h₀ (hom_ext₃ h₁ h₂ h₃ h₄) | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | hom_ext₄ | null |
map'_inv_eq_inv_map' {n m : ℕ} (h : n + 1 ≤ m) {f g : ComposableArrows C m}
(app : f.obj' n ≅ g.obj' n) (app' : f.obj' (n + 1) ≅ g.obj' (n + 1))
(w : f.map' n (n + 1) ≫ app'.hom = app.hom ≫ g.map' n (n + 1)) :
map' g n (n + 1) ≫ app'.inv = app.inv ≫ map' f n (n + 1) := by
rw [← cancel_epi app.hom, ← reassoc_of% w, app'.hom_inv_id, comp_id, app.hom_inv_id_assoc] | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | map'_inv_eq_inv_map' | null |
@[simps]
isoMk₄ {f g : ComposableArrows C 4}
(app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
(app₃ : f.obj' 3 ≅ g.obj' 3) (app₄ : f.obj' 4 ≅ g.obj' 4)
(w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
(w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2)
(w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
(w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4) :
f ≅ g where
hom := homMk₄ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom w₀ w₁ w₂ w₃
inv := homMk₄ app₀.inv app₁.inv app₂.inv app₃.inv app₄.inv
(by rw [map'_inv_eq_inv_map' (by valid) app₀ app₁ w₀])
(by rw [map'_inv_eq_inv_map' (by valid) app₁ app₂ w₁])
(by rw [map'_inv_eq_inv_map' (by valid) app₂ app₃ w₂])
(by rw [map'_inv_eq_inv_map' (by valid) app₃ app₄ w₃]) | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | isoMk₄ | Constructor for isomorphisms in `ComposableArrows C 4`. |
ext₄ {f g : ComposableArrows C 4}
(h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
(h₃ : f.obj' 3 = g.obj' 3) (h₄ : f.obj' 4 = g.obj' 4)
(w₀ : f.map' 0 1 = eqToHom h₀ ≫ g.map' 0 1 ≫ eqToHom h₁.symm)
(w₁ : f.map' 1 2 = eqToHom h₁ ≫ g.map' 1 2 ≫ eqToHom h₂.symm)
(w₂ : f.map' 2 3 = eqToHom h₂ ≫ g.map' 2 3 ≫ eqToHom h₃.symm)
(w₃ : f.map' 3 4 = eqToHom h₃ ≫ g.map' 3 4 ≫ eqToHom h₄.symm) :
f = g :=
ext_succ h₀ (ext₃ h₁ h₂ h₃ h₄ w₁ w₂ w₃) w₀ | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | ext₄ | null |
mk₄_surjective (X : ComposableArrows C 4) :
∃ (X₀ X₁ X₂ X₃ X₄ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃) (f₃ : X₃ ⟶ X₄),
X = mk₄ f₀ f₁ f₂ f₃ :=
⟨_, _, _, _, _, X.map' 0 1, X.map' 1 2, X.map' 2 3, X.map' 3 4,
ext₄ rfl rfl rfl rfl rfl (by simp) (by simp) (by simp) (by simp)⟩ | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mk₄_surjective | null |
homMk₅ : f ⟶ g := homMkSucc app₀ (homMk₄ app₁ app₂ app₃ app₄ app₅ w₁ w₂ w₃ w₄) w₀
@[simp] | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅ | Constructor for morphisms in `ComposableArrows C 5`. |
homMk₅_app_zero : (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 0 = app₀ := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅_app_zero | null |
homMk₅_app_one : (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app 1 = app₁ := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅_app_one | null |
homMk₅_app_two :
(homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨2, by valid⟩ = app₂ := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅_app_two | null |
homMk₅_app_three :
(homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨3, by valid⟩ = app₃ := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅_app_three | null |
homMk₅_app_four :
(homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨4, by valid⟩ = app₄ := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅_app_four | null |
homMk₅_app_five :
(homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨5, by valid⟩ = app₅ := rfl | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | homMk₅_app_five | null |
@[ext]
hom_ext₅ {f g : ComposableArrows C 5} {φ φ' : f ⟶ g}
(h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
(h₃ : app' φ 3 = app' φ' 3) (h₄ : app' φ 4 = app' φ' 4) (h₅ : app' φ 5 = app' φ' 5) :
φ = φ' :=
hom_ext_succ h₀ (hom_ext₄ h₁ h₂ h₃ h₄ h₅) | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | hom_ext₅ | null |
@[simps]
isoMk₅ {f g : ComposableArrows C 5}
(app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
(app₃ : f.obj' 3 ≅ g.obj' 3) (app₄ : f.obj' 4 ≅ g.obj' 4) (app₅ : f.obj' 5 ≅ g.obj' 5)
(w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
(w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2)
(w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
(w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4)
(w₄ : f.map' 4 5 ≫ app₅.hom = app₄.hom ≫ g.map' 4 5) :
f ≅ g where
hom := homMk₅ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom app₅.hom w₀ w₁ w₂ w₃ w₄
inv := homMk₅ app₀.inv app₁.inv app₂.inv app₃.inv app₄.inv app₅.inv
(by rw [map'_inv_eq_inv_map' (by valid) app₀ app₁ w₀])
(by rw [map'_inv_eq_inv_map' (by valid) app₁ app₂ w₁])
(by rw [map'_inv_eq_inv_map' (by valid) app₂ app₃ w₂])
(by rw [map'_inv_eq_inv_map' (by valid) app₃ app₄ w₃])
(by rw [map'_inv_eq_inv_map' (by valid) app₄ app₅ w₄]) | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | isoMk₅ | Constructor for isomorphisms in `ComposableArrows C 5`. |
ext₅ {f g : ComposableArrows C 5}
(h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
(h₃ : f.obj' 3 = g.obj' 3) (h₄ : f.obj' 4 = g.obj' 4) (h₅ : f.obj' 5 = g.obj' 5)
(w₀ : f.map' 0 1 = eqToHom h₀ ≫ g.map' 0 1 ≫ eqToHom h₁.symm)
(w₁ : f.map' 1 2 = eqToHom h₁ ≫ g.map' 1 2 ≫ eqToHom h₂.symm)
(w₂ : f.map' 2 3 = eqToHom h₂ ≫ g.map' 2 3 ≫ eqToHom h₃.symm)
(w₃ : f.map' 3 4 = eqToHom h₃ ≫ g.map' 3 4 ≫ eqToHom h₄.symm)
(w₄ : f.map' 4 5 = eqToHom h₄ ≫ g.map' 4 5 ≫ eqToHom h₅.symm) :
f = g :=
ext_succ h₀ (ext₄ h₁ h₂ h₃ h₄ h₅ w₁ w₂ w₃ w₄) w₀ | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | ext₅ | null |
mk₅_surjective (X : ComposableArrows C 5) :
∃ (X₀ X₁ X₂ X₃ X₄ X₅ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃)
(f₃ : X₃ ⟶ X₄) (f₄ : X₄ ⟶ X₅), X = mk₅ f₀ f₁ f₂ f₃ f₄ :=
⟨_, _, _, _, _, _, X.map' 0 1, X.map' 1 2, X.map' 2 3, X.map' 3 4, X.map' 4 5,
ext₅ rfl rfl rfl rfl rfl rfl (by simp) (by simp) (by simp) (by simp) (by simp)⟩ | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mk₅_surjective | null |
arrow (i : ℕ) (hi : i < n := by valid) :
ComposableArrows C 1 := mk₁ (F.map' i (i + 1)) | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | arrow | The `i`th arrow of `F : ComposableArrows C n`. |
mkOfObjOfMapSucc_exists : ∃ (F : ComposableArrows C n) (e : ∀ i, F.obj i ≅ obj i),
∀ (i : ℕ) (hi : i < n), mapSucc ⟨i, hi⟩ =
(e ⟨i, _⟩).inv ≫ F.map' i (i + 1) ≫ (e ⟨i + 1, _⟩).hom := by
induction n with
| zero => exact ⟨mk₀ (obj 0), fun 0 => Iso.refl _, fun i hi => by simp at hi⟩
| succ n hn =>
obtain ⟨F, e, h⟩ := hn (fun i => obj i.succ) (fun i => mapSucc i.succ)
refine ⟨F.precomp (mapSucc 0 ≫ (e 0).inv), fun i => match i with
| 0 => Iso.refl _
| ⟨i + 1, hi⟩ => e _, fun i hi => ?_⟩
obtain _ | i := i
· simp
· exact h i (by valid) | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mkOfObjOfMapSucc_exists | null |
noncomputable mkOfObjOfMapSucc : ComposableArrows C n :=
(mkOfObjOfMapSucc_exists obj mapSucc).choose.copyObj obj
(mkOfObjOfMapSucc_exists obj mapSucc).choose_spec.choose
@[simp] | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mkOfObjOfMapSucc | Given `obj : Fin (n + 1) → C` and `mapSucc i : obj i.castSucc ⟶ obj i.succ`
for all `i : Fin n`, this is `F : ComposableArrows C n` such that `F.obj i` is
definitionally equal to `obj i` and such that `F.map' i (i + 1) = mapSucc ⟨i, hi⟩`. |
mkOfObjOfMapSucc_obj (i : Fin (n + 1)) :
(mkOfObjOfMapSucc obj mapSucc).obj i = obj i := rfl | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mkOfObjOfMapSucc_obj | null |
mkOfObjOfMapSucc_map_succ (i : ℕ) (hi : i < n := by valid) :
(mkOfObjOfMapSucc obj mapSucc).map' i (i + 1) = mapSucc ⟨i, hi⟩ :=
((mkOfObjOfMapSucc_exists obj mapSucc).choose_spec.choose_spec i hi).symm | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mkOfObjOfMapSucc_map_succ | null |
mkOfObjOfMapSucc_arrow (i : ℕ) (hi : i < n := by valid) :
(mkOfObjOfMapSucc obj mapSucc).arrow i = mk₁ (mapSucc ⟨i, hi⟩) :=
ext₁ rfl rfl (by simpa using mkOfObjOfMapSucc_map_succ obj mapSucc i hi) | lemma | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | mkOfObjOfMapSucc_arrow | null |
@[simps!]
opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n :=
((orderDualEquivalence (Fin (n + 1))).symm.trans
Fin.revOrderIso.equivalence).symm.congrLeft.op.trans
(Functor.leftOpRightOpEquiv (Fin (n + 1)) C) | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | opEquivalence | The equivalence `(ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n` obtained
by reversing the arrows. |
@[simps!]
Functor.mapComposableArrows :
ComposableArrows C n ⥤ ComposableArrows D n :=
(whiskeringRight _ _ _).obj G
suppress_compilation in | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | Functor.mapComposableArrows | The functor `ComposableArrows C n ⥤ ComposableArrows D n` obtained by postcomposition
with a functor `C ⥤ D`. |
Functor.mapComposableArrowsOpIso :
G.mapComposableArrows n ⋙ (opEquivalence D n).functor.rightOp ≅
(opEquivalence C n).functor.rightOp ⋙ (G.op.mapComposableArrows n).op :=
Iso.refl _ | def | CategoryTheory | [
"Mathlib.Algebra.Group.Nat.Defs",
"Mathlib.CategoryTheory.Category.Preorder",
"Mathlib.CategoryTheory.EqToHom",
"Mathlib.CategoryTheory.Functor.Const",
"Mathlib.Order.Fin.Basic",
"Mathlib.Tactic.FinCases",
"Mathlib.Tactic.SuppressCompilation"
] | Mathlib/CategoryTheory/ComposableArrows.lean | Functor.mapComposableArrowsOpIso | The functor `ComposableArrows C n ⥤ ComposableArrows D n` induced by `G : C ⥤ D`
commutes with `opEquivalence`. |
conj : End X ≃* End Y :=
{ homCongr α α with map_mul' := fun f g => homCongr_comp α α α g f } | def | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conj | An isomorphism between two objects defines a monoid isomorphism between their
monoid of endomorphisms. |
conj_apply (f : End X) : α.conj f = α.inv ≫ f ≫ α.hom :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conj_apply | null |
conj_comp (f g : End X) : α.conj (f ≫ g) = α.conj f ≫ α.conj g :=
map_mul α.conj g f
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conj_comp | null |
conj_id : α.conj (𝟙 X) = 𝟙 Y :=
map_one α.conj
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conj_id | null |
refl_conj (f : End X) : (Iso.refl X).conj f = f := by
rw [conj_apply, Iso.refl_inv, Iso.refl_hom, Category.id_comp, Category.comp_id]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | refl_conj | null |
trans_conj {Z : C} (β : Y ≅ Z) (f : End X) : (α ≪≫ β).conj f = β.conj (α.conj f) :=
homCongr_trans α α β β f
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | trans_conj | null |
symm_self_conj (f : End X) : α.symm.conj (α.conj f) = f := by
rw [← trans_conj, α.self_symm_id, refl_conj]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | symm_self_conj | null |
self_symm_conj (f : End Y) : α.conj (α.symm.conj f) = f :=
α.symm.symm_self_conj f
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | self_symm_conj | null |
conj_pow (f : End X) (n : ℕ) : α.conj (f ^ n) = α.conj f ^ n :=
α.conj.toMonoidHom.map_pow f n | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conj_pow | null |
conjAut : Aut X ≃* Aut Y :=
(Aut.unitsEndEquivAut X).symm.trans <| (Units.mapEquiv α.conj).trans <| Aut.unitsEndEquivAut Y | def | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut | `conj` defines a group isomorphisms between groups of automorphisms |
conjAut_apply (f : Aut X) : α.conjAut f = α.symm ≪≫ f ≪≫ α := by cat_disch
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut_apply | null |
conjAut_hom (f : Aut X) : (α.conjAut f).hom = α.conj f.hom :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut_hom | null |
trans_conjAut {Z : C} (β : Y ≅ Z) (f : Aut X) :
(α ≪≫ β).conjAut f = β.conjAut (α.conjAut f) := by
simp only [conjAut_apply, Iso.trans_symm, Iso.trans_assoc]
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | trans_conjAut | null |
conjAut_mul (f g : Aut X) : α.conjAut (f * g) = α.conjAut f * α.conjAut g :=
map_mul α.conjAut f g
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut_mul | null |
conjAut_trans (f g : Aut X) : α.conjAut (f ≪≫ g) = α.conjAut f ≪≫ α.conjAut g :=
conjAut_mul α g f
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut_trans | null |
conjAut_pow (f : Aut X) (n : ℕ) : α.conjAut (f ^ n) = α.conjAut f ^ n :=
map_pow α.conjAut f n
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut_pow | null |
conjAut_zpow (f : Aut X) (n : ℤ) : α.conjAut (f ^ n) = α.conjAut f ^ n :=
map_zpow α.conjAut f n | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | conjAut_zpow | null |
map_conj {X Y : C} (α : X ≅ Y) (f : End X) :
F.map (α.conj f) = (F.mapIso α).conj (F.map f) :=
map_homCongr F α α f | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | map_conj | null |
map_conjAut (F : C ⥤ D) {X Y : C} (α : X ≅ Y) (f : Aut X) :
F.mapIso (α.conjAut f) = (F.mapIso α).conjAut (F.mapIso f) := by
ext; simp only [mapIso_hom, Iso.conjAut_hom, F.map_conj] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Units.Equiv",
"Mathlib.CategoryTheory.Endomorphism",
"Mathlib.CategoryTheory.HomCongr"
] | Mathlib/CategoryTheory/Conj.lean | map_conjAut | null |
ConnectedComponents (J : Type u₁) [Category.{v₁} J] : Type u₁ :=
Quotient (Zigzag.setoid J) | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents | This type indexes the connected components of the category `J`. |
Functor.mapConnectedComponents {K : Type u₂} [Category.{v₂} K] (F : J ⥤ K)
(x : ConnectedComponents J) : ConnectedComponents K :=
x |> Quotient.lift (Quotient.mk (Zigzag.setoid _) ∘ F.obj)
(fun _ _ ↦ Quot.sound ∘ zigzag_obj_of_zigzag F)
@[simp] | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | Functor.mapConnectedComponents | The map `ConnectedComponents J → ConnectedComponents K` induced by a functor `J ⥤ K`. |
Functor.mapConnectedComponents_mk {K : Type u₂} [Category.{v₂} K] (F : J ⥤ K) (j : J) :
F.mapConnectedComponents (Quotient.mk _ j) = Quotient.mk _ (F.obj j) := rfl | lemma | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | Functor.mapConnectedComponents_mk | null |
ConnectedComponents.functorToDiscrete (X : Type*)
(f : ConnectedComponents J → X) : J ⥤ Discrete X where
obj Y := Discrete.mk (f (Quotient.mk (Zigzag.setoid _) Y))
map g := Discrete.eqToHom (congrArg f (Quotient.sound (Zigzag.of_hom g))) | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.functorToDiscrete | Every function from connected components of a category gives a functor to discrete category |
ConnectedComponents.liftFunctor (J) [Category J] {X : Type*} (F : J ⥤ Discrete X) :
(ConnectedComponents J → X) :=
Quotient.lift (fun c => (F.obj c).as)
(fun _ _ h => eq_of_zigzag X (zigzag_obj_of_zigzag F h)) | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.liftFunctor | Every functor to a discrete category gives a function from connected components |
ConnectedComponents.typeToCatHomEquiv (J) [Category J] (X : Type*) :
(ConnectedComponents J → X) ≃ (J ⥤ Discrete X) where
toFun := ConnectedComponents.functorToDiscrete _
invFun := ConnectedComponents.liftFunctor _
left_inv f := funext fun x ↦ by
obtain ⟨x, h⟩ := Quotient.exists_rep x
rw [← h]
rfl
right_inv fctr :=
Functor.hext (fun _ ↦ rfl) (fun c d f ↦
have : Subsingleton (fctr.obj c ⟶ fctr.obj d) := Discrete.instSubsingletonDiscreteHom _ _
(Subsingleton.elim (fctr.map f) _).symm.heq) | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.typeToCatHomEquiv | Functions from connected components and functors to discrete category are in bijection |
ConnectedComponents.objectProperty (j : ConnectedComponents J) :
ObjectProperty J := fun k => Quotient.mk'' k = j | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.objectProperty | Given an index for a connected component, this is the property of the
objects which belong to this component. |
ConnectedComponents.Component (j : ConnectedComponents J) : Type u₁ :=
j.objectProperty.FullSubcategory | abbrev | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.Component | Given an index for a connected component, produce the actual component as a full subcategory. |
ConnectedComponents.ι (j : ConnectedComponents J) : j.Component ⥤ J := j.objectProperty.ι | abbrev | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.ι | The inclusion functor from a connected component to the whole category. |
ConnectedComponents.mk (j : J) : ConnectedComponents J :=
Quotient.mk'' j
@[deprecated (since := "2025-03-04")] alias Component := ConnectedComponents.Component
@[deprecated (since := "2025-03-04")] alias Component.ι := ConnectedComponents.ι | abbrev | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | ConnectedComponents.mk | The connected component of an object in a category. |
Decomposed (J : Type u₁) [Category.{v₁} J] :=
Σ j : ConnectedComponents J, j.Component | abbrev | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | Decomposed | Each connected component of the category is nonempty. -/
instance (j : ConnectedComponents J) : Nonempty j.Component := by
induction j using Quotient.inductionOn'
exact ⟨⟨_, rfl⟩⟩
instance (j : ConnectedComponents J) : Inhabited j.Component :=
Classical.inhabited_of_nonempty'
/-- Each connected component of the category is connected. -/
instance (j : ConnectedComponents J) : IsConnected j.Component := by
-- Show it's connected by constructing a zigzag (in `j.Component`) between any two objects
apply isConnected_of_zigzag
rintro ⟨j₁, hj₁⟩ ⟨j₂, rfl⟩
-- We know that the underlying objects j₁ j₂ have some zigzag between them in `J`
have h₁₂ : Zigzag j₁ j₂ := Quotient.exact' hj₁
-- Get an explicit zigzag as a list
rcases List.exists_isChain_cons_of_relationReflTransGen h₁₂ with ⟨l, hl₁, hl₂⟩
-- Everything which has a zigzag to j₂ can be lifted to the same component as `j₂`.
let f : ∀ x, Zigzag x j₂ → (ConnectedComponents.mk j₂).Component :=
fun x h => ⟨x, Quotient.sound' h⟩
-- Everything in our chosen zigzag from `j₁` to `j₂` has a zigzag to `j₂`.
have hf : ∀ a : J, a ∈ l → Zigzag a j₂ := by
intro i hi
apply hl₁.backwards_cons_induction (fun t => Zigzag t j₂) _ hl₂ _ _ _ (List.mem_of_mem_tail hi)
· intro j k
apply Relation.ReflTransGen.head
· apply Relation.ReflTransGen.refl
-- Now lift the zigzag from `j₁` to `j₂` in `J` to the same thing in `j.Component`.
refine ⟨l.pmap f hf, ?_, by grind⟩
refine @List.isChain_cons_pmap_of_isChain_cons _ _ Zag _ _ f
(fun x y _ _ h => ?_) _ _ h₁₂ hl₁ _
exact zag_of_zag_obj (ConnectedComponents.ι _) h
/-- The disjoint union of `J`s connected components, written explicitly as a sigma-type with the
category structure.
This category is equivalent to `J`. |
inclusion (j : ConnectedComponents J) : j.Component ⥤ Decomposed J :=
Sigma.incl _ | abbrev | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | inclusion | The inclusion of each component into the decomposed category. This is just `sigma.incl` but having
this abbreviation helps guide typeclass search to get the right category instance on `decomposed J`. |
@[simps!]
decomposedTo (J : Type u₁) [Category.{v₁} J] : Decomposed J ⥤ J :=
Sigma.desc ConnectedComponents.ι
@[simp] | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | decomposedTo | The forward direction of the equivalence between the decomposed category and the original. |
inclusion_comp_decomposedTo (j : ConnectedComponents J) :
inclusion j ⋙ decomposedTo J = ConnectedComponents.ι j :=
rfl | theorem | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | inclusion_comp_decomposedTo | null |
@[simps! functor]
decomposedEquiv : Decomposed J ≌ J :=
(decomposedTo J).asEquivalence | def | CategoryTheory | [
"Mathlib.Data.List.Chain",
"Mathlib.CategoryTheory.IsConnected",
"Mathlib.CategoryTheory.Sigma.Basic",
"Mathlib.CategoryTheory.ObjectProperty.FullSubcategory"
] | Mathlib/CategoryTheory/ConnectedComponents.lean | decomposedEquiv | This gives that any category is equivalent to a disjoint union of connected categories. |
Core (C : Type u₁) where
/-- The object of the base category underlying an object in `Core C`. -/
of : C
variable {C : Type u₁} [Category.{v₁} C] | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | Core | The core of a category C is the groupoid whose morphisms are all the
isomorphisms of C. |
@[ext]
CoreHom (X Y : Core C) where
/-- The isomorphism of objects of `C` underlying a morphism in `Core C`. -/
iso : X.of ≅ Y.of
@[simps!] | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | CoreHom | The hom-type between two objects of `Core C`.
It is defined as a one-field structure to prevent defeq abuses. |
coreCategory : Groupoid.{v₁} (Core C) where
Hom (X Y : Core C) := CoreHom X Y
id (X : Core C) := .mk <| Iso.refl X.of
comp f g := .mk <| Iso.trans f.iso g.iso
inv {_ _} f := .mk <| Iso.symm f.iso
@[simp] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreCategory | null |
coreCategory_comp_iso {x y z : Core C} (f : x ⟶ y) (g : y ⟶ z) :
(f ≫ g).iso = f.iso ≪≫ g.iso := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreCategory_comp_iso | null |
@[simps!]
inclusion : Core C ⥤ C where
obj := of
map f := f.iso.hom
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | inclusion | The core of a category is naturally included in the category. |
hom_ext {X Y : Core C} {f g : X ⟶ Y} (h : f.iso.hom = g.iso.hom) :
f = g := by
apply CoreHom.ext
exact Iso.ext h
variable (C) | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | hom_ext | null |
@[simps!]
functorToCore (F : G ⥤ C) : G ⥤ Core C where
obj X := .mk <| F.obj X
map f := .mk <| { hom := F.map f, inv := F.map (Groupoid.inv f) } | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | functorToCore | A functor from a groupoid to a category C factors through the core of C. |
@[simps!]
forgetFunctorToCore : (G ⥤ Core C) ⥤ G ⥤ C :=
(whiskeringRight _ _ _).obj (inclusion C) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | forgetFunctorToCore | We can functorially associate to any functor from a groupoid to the core of a category `C`,
a functor from the groupoid to `C`, simply by composing with the embedding `Core C ⥤ C`. |
@[simps!]
core (F : C ⥤ D) : Core C ⥤ Core D := Core.functorToCore (Core.inclusion _ ⋙ F)
variable (C) in | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | core | A functor `C ⥤ D` induces a functor `Core C ⥤ Core D`. |
@[simps!]
coreId : (𝟭 C).core ≅ 𝟭 (Core C) := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreId | The core of the identity functor is the identity functor on the cores. |
@[simps!]
coreComp {E : Type u₃} [Category.{v₃} E] (F : C ⥤ D) (G : D ⥤ E) :
(F ⋙ G).core ≅ F.core ⋙ G.core := Iso.refl _ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreComp | The core of the composition of F and G is the composition of the cores. |
@[simps!]
core {F G : C ⥤ D} (α : F ≅ G) : F.core ≅ G.core :=
NatIso.ofComponents
(fun x ↦ Groupoid.isoEquivHom _ _|>.symm <| .mk <| α.app x.of)
@[simp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | core | A natural isomorphism of functors induces a natural isomorphism between their cores. |
coreComp {F G H : C ⥤ D} (α : F ≅ G) (β : G ≅ H) : (α ≪≫ β).core = α.core ≪≫ β.core := rfl
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreComp | null |
coreId {F : C ⥤ D} : (Iso.refl F).core = Iso.refl F.core := rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreId | null |
coreWhiskerLeft {E : Type u₃} [Category.{v₃} E] (F : C ⥤ D) {G H : D ⥤ E} (η : G ≅ H) :
(isoWhiskerLeft F η).core =
F.coreComp G ≪≫ isoWhiskerLeft F.core η.core ≪≫ (F.coreComp H).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreWhiskerLeft | null |
coreWhiskerRight {E : Type u₃} [Category.{v₃} E] {F G : C ⥤ D} (η : F ≅ G) (H : D ⥤ E) :
(isoWhiskerRight η H ).core =
F.coreComp H ≪≫ isoWhiskerRight η.core H.core ≪≫ (G.coreComp H).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreWhiskerRight | null |
coreLeftUnitor {F : C ⥤ D} :
F.leftUnitor.core =
(𝟭 C).coreComp F ≪≫ isoWhiskerRight (Functor.coreId C) _ ≪≫ F.core.leftUnitor := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreLeftUnitor | null |
coreRightUnitor {F : C ⥤ D} :
F.rightUnitor.core =
(F).coreComp (𝟭 D) ≪≫ isoWhiskerLeft _ (Functor.coreId D) ≪≫ F.core.rightUnitor := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreRightUnitor | null |
coreAssociator {E : Type u₃} [Category.{v₃} E] {E' : Type u₄} [Category.{v₄} E']
(F : C ⥤ D) (G : D ⥤ E) (H : E ⥤ E') :
(Functor.associator F G H).core =
(F ⋙ G).coreComp H ≪≫ isoWhiskerRight (F.coreComp G) H.core ≪≫
Functor.associator F.core G.core H.core ≪≫ (isoWhiskerLeft F.core (G.coreComp H)).symm ≪≫
(F.coreComp (G ⋙ H)).symm := by
cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreAssociator | null |
@[simps!]
core (E : C ≌ D) : Core C ≌ Core D where
functor := E.functor.core
inverse := E.inverse.core
unitIso := E.unitIso.core
counitIso := E.counitIso.core | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | core | Equivalent categories have equivalent cores. |
@[simps!]
coreFunctor : Core (C ⥤ D) ⥤ Core C ⥤ Core D where
obj F := F.of.core
map η := η.iso.core.hom | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | coreFunctor | Taking the core of a functor is functorial if we discard non-invertible natural
transformations. |
ofEquivFunctor (m : Type u₁ → Type u₂) [EquivFunctor m] : Core (Type u₁) ⥤ Core (Type u₂) where
obj x := .mk <| m x.of
map f := .mk <| (EquivFunctor.mapEquiv m f.iso.toEquiv).toIso
map_id α := by ext x; exact congr_fun (EquivFunctor.map_refl' _) x
map_comp f g := by
ext
simp [EquivFunctor.map_trans', Function.comp] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Groupoid",
"Mathlib.CategoryTheory.Types.Basic",
"Mathlib.CategoryTheory.Whiskering",
"Mathlib.Control.EquivFunctor"
] | Mathlib/CategoryTheory/Core.lean | ofEquivFunctor | `ofEquivFunctor m` lifts a type-level `EquivFunctor`
to a categorical functor `Core (Type u₁) ⥤ Core (Type u₂)`. |
discreteCountable {α : Type*} [Countable α] : Countable (Discrete α) :=
Countable.of_equiv α discreteEquiv.symm | instance | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | discreteCountable | null |
CountableCategory (J : Type*) [Category J] : Prop where
countableObj : Countable J := by infer_instance
countableHom : ∀ j j' : J, Countable (j ⟶ j') := by infer_instance
attribute [instance] CountableCategory.countableObj CountableCategory.countableHom | class | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | CountableCategory | A category with countably many objects and morphisms. |
countableCategoryDiscreteOfCountable (J : Type*) [Countable J] :
CountableCategory (Discrete J) where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | countableCategoryDiscreteOfCountable | null |
ObjAsType : Type :=
InducedCategory α (equivShrink.{0} α).symm | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | ObjAsType | A countable category `α` is equivalent to a category with objects in `Type`. |
noncomputable objAsTypeEquiv : ObjAsType α ≌ α :=
(inducedFunctor (equivShrink.{0} α).symm).asEquivalence | def | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | objAsTypeEquiv | The constructed category is indeed equivalent to `α`. |
HomAsType := ShrinkHoms (ObjAsType α) | def | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | HomAsType | A countable category `α` is equivalent to a *small* category with objects in `Type`. |
noncomputable homAsTypeEquiv : HomAsType α ≌ α :=
(ShrinkHoms.equivalence _).symm.trans (objAsTypeEquiv _) | def | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | homAsTypeEquiv | The constructed category is indeed equivalent to `α`. |
countableCategoryOpposite {J : Type*} [Category J] [CountableCategory J] :
CountableCategory Jᵒᵖ where
countableObj := Countable.of_equiv _ equivToOpposite
countableHom j j' := Countable.of_equiv _ (opEquiv j j').symm
attribute [local instance] uliftCategory in | instance | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | countableCategoryOpposite | The opposite of a countable category is countable. |
countableCategoryUlift {J : Type v} [Category J] [CountableCategory J] :
CountableCategory.{max w v} (ULiftHom.{w, max w v} (ULift.{w, v} J)) where
countableObj := instCountableULift
countableHom := fun i j =>
have : Countable ((ULiftHom.objDown i).down ⟶ (ULiftHom.objDown j).down) := inferInstance
instCountableULift | instance | CategoryTheory | [
"Mathlib.CategoryTheory.EssentiallySmall",
"Mathlib.CategoryTheory.FinCategory.Basic",
"Mathlib.Data.Fintype.EquivFin",
"Mathlib.Data.Countable.Small"
] | Mathlib/CategoryTheory/Countable.lean | countableCategoryUlift | Applying `ULift` to morphisms and objects of a category preserves countability. |
DifferentialObject where
/-- The underlying object of a differential object. -/
obj : C
/-- The differential of a differential object. -/
d : obj ⟶ obj⟦(1 : S)⟧
/-- The differential `d` satisfies that `d² = 0`. -/
d_squared : d ≫ d⟦(1 : S)⟧' = 0 := by cat_disch
attribute [reassoc (attr := simp)] DifferentialObject.d_squared
variable {S C} | structure | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | DifferentialObject | A differential object in a category with zero morphisms and a shift is
an object `obj` equipped with
a morphism `d : obj ⟶ obj⟦1⟧`, such that `d^2 = 0`. |
@[ext]
Hom (X Y : DifferentialObject S C) where
/-- The morphism between underlying objects of the two differentiable objects. -/
f : X.obj ⟶ Y.obj
comm : X.d ≫ f⟦1⟧' = f ≫ Y.d := by cat_disch
attribute [reassoc (attr := simp)] Hom.comm | structure | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | Hom | A morphism of differential objects is a morphism commuting with the differentials. |
@[simps]
id (X : DifferentialObject S C) : Hom X X where
f := 𝟙 X.obj | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | id | The identity morphism of a differential object. |
@[simps]
comp {X Y Z : DifferentialObject S C} (f : Hom X Y) (g : Hom Y Z) : Hom X Z where
f := f.f ≫ g.f | def | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | comp | The composition of morphisms of differential objects. |
categoryOfDifferentialObjects : Category (DifferentialObject S C) where
Hom := Hom
id := Hom.id
comp f g := Hom.comp f g
@[ext] | instance | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | categoryOfDifferentialObjects | null |
ext {A B : DifferentialObject S C} {f g : A ⟶ B} (w : f.f = g.f := by cat_disch) : f = g :=
Hom.ext w
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | ext | null |
id_f (X : DifferentialObject S C) : (𝟙 X : X ⟶ X).f = 𝟙 X.obj := rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | id_f | null |
comp_f {X Y Z : DifferentialObject S C} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).f = f.f ≫ g.f :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | comp_f | null |
eqToHom_f {X Y : DifferentialObject S C} (h : X = Y) :
Hom.f (eqToHom h) = eqToHom (congr_arg _ h) := by
subst h
rw [eqToHom_refl, eqToHom_refl]
rfl
variable (S C) | theorem | CategoryTheory | [
"Mathlib.Algebra.Group.Basic",
"Mathlib.Data.Int.Cast.Defs",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.CategoryTheory.ConcreteCategory.Basic"
] | Mathlib/CategoryTheory/DifferentialObject.lean | eqToHom_f | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.