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 ⌀ |
|---|---|---|---|---|---|---|
@[simps]
unop {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y} {sq : CommSq f i p g}
(l : LiftStruct sq) : LiftStruct sq.unop where
l := l.l.unop
fac_left := by rw [← unop_comp, l.fac_right]
fac_right := by rw [← unop_comp, l.fac_left] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | unop | A `LiftStruct` for a commutative square in the opposite category
gives a `LiftStruct` for the corresponding square in the original category. |
@[simps]
opEquiv (sq : CommSq f i p g) : LiftStruct sq ≃ LiftStruct sq.op where
toFun := op
invFun := unop
left_inv := by cat_disch
right_inv := by cat_disch | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | opEquiv | Equivalences of `LiftStruct` for a square and the corresponding square
in the opposite category. |
unopEquiv {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y}
(sq : CommSq f i p g) : LiftStruct sq ≃ LiftStruct sq.unop where
toFun := unop
invFun := op
left_inv := by cat_disch
right_inv := by cat_disch | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | unopEquiv | Equivalences of `LiftStruct` for a square in the opposite category and
the corresponding square in the original category. |
subsingleton_liftStruct_of_epi (sq : CommSq f i p g) [Epi i] :
Subsingleton (LiftStruct sq) :=
⟨fun l₁ l₂ => by
ext
rw [← cancel_epi i]
simp only [LiftStruct.fac_left]⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | subsingleton_liftStruct_of_epi | null |
subsingleton_liftStruct_of_mono (sq : CommSq f i p g) [Mono p] :
Subsingleton (LiftStruct sq) :=
⟨fun l₁ l₂ => by
ext
rw [← cancel_mono p]
simp only [LiftStruct.fac_right]⟩
variable (sq : CommSq f i p g) | instance | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | subsingleton_liftStruct_of_mono | null |
HasLift : Prop where
/-- Square has a `LiftStruct`. -/
exists_lift : Nonempty sq.LiftStruct | class | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | HasLift | The assertion that a square has a `LiftStruct`. |
mk' (l : sq.LiftStruct) : HasLift sq :=
⟨Nonempty.intro l⟩ | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | mk' | null |
iff : HasLift sq ↔ Nonempty sq.LiftStruct := by
constructor
exacts [fun h => h.exists_lift, fun h => mk h] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | iff | null |
iff_op : HasLift sq ↔ HasLift sq.op := by
rw [iff, iff]
exact Nonempty.congr (LiftStruct.opEquiv sq).toFun (LiftStruct.opEquiv sq).invFun | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | iff_op | null |
iff_unop {A B X Y : Cᵒᵖ} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y} {g : B ⟶ Y}
(sq : CommSq f i p g) : HasLift sq ↔ HasLift sq.unop := by
rw [iff, iff]
exact Nonempty.congr (LiftStruct.unopEquiv sq).toFun (LiftStruct.unopEquiv sq).invFun | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | iff_unop | null |
noncomputable lift [hsq : HasLift sq] : B ⟶ X :=
hsq.exists_lift.some.l
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | lift | A choice of a diagonal morphism that is part of a `LiftStruct` when
the square has a lift. |
fac_left [hsq : HasLift sq] : i ≫ sq.lift = f :=
hsq.exists_lift.some.fac_left
@[reassoc (attr := simp)] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | fac_left | null |
fac_right [hsq : HasLift sq] : sq.lift ≫ p = g :=
hsq.exists_lift.some.fac_right | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Comma.Arrow"
] | Mathlib/CategoryTheory/CommSq.lean | fac_right | null |
ComposableArrows (n : ℕ) := Fin (n + 1) ⥤ C | abbrev | 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 | ComposableArrows | `ComposableArrows C n` is the type of functors `Fin (n + 1) ⥤ C`. |
@[simp]
obj' (i : ℕ) (hi : i ≤ n := by valid) : C := F.obj ⟨i, by cutsat⟩ | abbrev | 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 | obj' | A wrapper for `omega` which prefaces it with some quick and useful attempts -/
macro "valid" : tactic =>
`(tactic| first | assumption | apply zero_le | apply le_rfl | transitivity <;> assumption | omega)
/-- The `i`th object (with `i : ℕ` such that `i ≤ n`) of `F : ComposableArrows C n`. |
@[simp]
map' (i j : ℕ) (hij : i ≤ j := by valid) (hjn : j ≤ n := by valid) :
F.obj ⟨i, by cutsat⟩ ⟶ F.obj ⟨j, by cutsat⟩ :=
F.map (homOfLE (by simp only [Fin.mk_le_mk]; valid)) | abbrev | 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' | The map `F.obj' i ⟶ F.obj' j` when `F : ComposableArrows C n`, and `i` and `j`
are natural numbers such that `i ≤ j ≤ n`. |
map'_self (i : ℕ) (hi : i ≤ n := by valid) : F.map' i i = 𝟙 _ := F.map_id _ | 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'_self | null |
map'_comp (i j k : ℕ) (hij : i ≤ j := by valid)
(hjk : j ≤ k := by valid) (hk : k ≤ n := by valid) :
F.map' i k = F.map' i j ≫ F.map' j k :=
F.map_comp _ _ | 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'_comp | null |
left := obj' F 0 | abbrev | 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 | left | The leftmost object of `F : ComposableArrows C n`. |
right := obj' F n | abbrev | 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 | right | The rightmost object of `F : ComposableArrows C n`. |
hom : F.left ⟶ F.right := map' F 0 n
variable {F G} | abbrev | 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 | The canonical map `F.left ⟶ F.right` for `F : ComposableArrows C n`. |
@[simp]
app' (φ : F ⟶ G) (i : ℕ) (hi : i ≤ n := by valid) :
F.obj' i ⟶ G.obj' i := φ.app _
@[reassoc] | abbrev | 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 | app' | The map `F.obj' i ⟶ G.obj' i` induced on `i`th objects by a morphism `F ⟶ G`
in `ComposableArrows C n` when `i` is a natural number such that `i ≤ n`. |
naturality' (φ : F ⟶ G) (i j : ℕ) (hij : i ≤ j := by valid)
(hj : j ≤ n := by valid) :
F.map' i j ≫ app' φ j = app' φ i ≫ G.map' i j :=
φ.naturality _ | 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 | naturality' | null |
@[simps!]
mk₀ (X : C) : ComposableArrows C 0 := (Functor.const (Fin 1)).obj X | 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 | mk₀ | Constructor for `ComposableArrows C 0`. |
@[simp]
obj : Fin 2 → C
| ⟨0, _⟩ => X₀
| ⟨1, _⟩ => X₁
variable {X₀ X₁}
variable (f : X₀ ⟶ X₁) | 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 | obj | The map which sends `0 : Fin 2` to `X₀` and `1` to `X₁`. |
@[simp]
map : ∀ (i j : Fin 2) (_ : i ≤ j), obj X₀ X₁ i ⟶ obj X₀ X₁ j
| ⟨0, _⟩, ⟨0, _⟩, _ => 𝟙 _
| ⟨0, _⟩, ⟨1, _⟩, _ => f
| ⟨1, _⟩, ⟨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 | map | The obvious map `obj X₀ X₁ i ⟶ obj X₀ X₁ j` whenever `i j : Fin 2` satisfy `i ≤ j`. |
map_id (i : Fin 2) : map f i i (by simp) = 𝟙 _ :=
match i with
| 0 => rfl
| 1 => 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 | map_id | null |
map_comp {i j k : Fin 2} (hij : i ≤ j) (hjk : j ≤ k) :
map f i k (hij.trans hjk) = map f i j hij ≫ map f j k hjk := by
obtain rfl | rfl : i = j ∨ j = k := by cutsat
· rw [map_id, id_comp]
· rw [map_id, comp_id] | 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_comp | null |
@[simps]
mk₁ {X₀ X₁ : C} (f : X₀ ⟶ X₁) : ComposableArrows C 1 where
obj := Mk₁.obj X₀ X₁
map g := Mk₁.map f _ _ (leOfHom g)
map_id := Mk₁.map_id f
map_comp g g' := Mk₁.map_comp f (leOfHom g) (leOfHom g') | 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 | mk₁ | Constructor for `ComposableArrows C 1`. |
@[simps]
homMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ⟶ G.obj i)
(w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) ≫ app _ = app _ ≫ G.map' i (i + 1)) :
F ⟶ G where
app := app
naturality := by
suffices ∀ (k i j : ℕ) (hj : i + k = j) (hj' : j ≤ n),
F.map' i j ≫ app _ = app _ ≫ G.map' i j by
rintro ⟨i, hi⟩ ⟨j, hj⟩ hij
have hij' := leOfHom hij
simp only [Fin.mk_le_mk] at hij'
obtain ⟨k, hk⟩ := Nat.le.dest hij'
exact this k i j hk (by valid)
intro k
induction k with intro i j hj hj'
| zero =>
simp only [add_zero] at hj
obtain rfl := hj
rw [F.map'_self i, G.map'_self i, id_comp, comp_id]
| succ k hk =>
rw [← add_assoc] at hj
subst hj
rw [F.map'_comp i (i + k) (i + k + 1), G.map'_comp i (i + k) (i + k + 1), assoc,
w (i + k) (by valid), reassoc_of% (hk i (i + k) rfl (by valid))] | 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 `F ⟶ G` in `ComposableArrows C n` which takes as inputs
a family of morphisms `F.obj i ⟶ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. |
@[simps]
isoMk {F G : ComposableArrows C n} (app : ∀ i, F.obj i ≅ G.obj i)
(w : ∀ (i : ℕ) (hi : i < n),
F.map' i (i + 1) ≫ (app _).hom = (app _).hom ≫ G.map' i (i + 1)) :
F ≅ G where
hom := homMk (fun i => (app i).hom) w
inv := homMk (fun i => (app i).inv) (fun i hi => by
dsimp only
rw [← cancel_epi ((app _).hom), ← reassoc_of% (w i hi), Iso.hom_inv_id, comp_id,
Iso.hom_inv_id_assoc]) | 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 `F ≅ G` in `ComposableArrows C n` which takes as inputs
a family of isomorphisms `F.obj i ≅ G.obj i` and the naturality condition only for the
maps in `Fin (n + 1)` given by inequalities of the form `i ≤ i + 1`. |
ext {F G : ComposableArrows C n} (h : ∀ i, F.obj i = G.obj i)
(w : ∀ (i : ℕ) (hi : i < n), F.map' i (i + 1) =
eqToHom (h _) ≫ G.map' i (i + 1) ≫ eqToHom (h _).symm) : F = G :=
Functor.ext_of_iso
(isoMk (fun i => eqToIso (h i)) (fun i hi => by simp [w i hi])) 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 | ext | null |
@[simps!]
homMk₀ {F G : ComposableArrows C 0} (f : F.obj' 0 ⟶ G.obj' 0) : F ⟶ G :=
homMk (fun i => match i with
| ⟨0, _⟩ => f) (fun i hi => by simp at hi)
@[ext] | 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 0`. |
hom_ext₀ {F G : ComposableArrows C 0} {φ φ' : F ⟶ G}
(h : app' φ 0 = app' φ' 0) :
φ = φ' := by
ext i
fin_cases i
exact 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 0} (e : F.obj' 0 ≅ G.obj' 0) : F ≅ G where
hom := homMk₀ e.hom
inv := homMk₀ e.inv | 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 0`. |
ext₀ {F G : ComposableArrows C 0} (h : F.obj' 0 = G.obj 0) : F = G :=
ext (fun i => match i with
| ⟨0, _⟩ => h) (fun i hi => by simp at 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 | ext₀ | null |
mk₀_surjective (F : ComposableArrows C 0) : ∃ (X : C), F = mk₀ X :=
⟨F.obj' 0, ext₀ 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 | mk₀_surjective | null |
@[simps!]
homMk₁ {F G : ComposableArrows C 1}
(left : F.obj' 0 ⟶ G.obj' 0) (right : F.obj' 1 ⟶ G.obj' 1)
(w : F.map' 0 1 ≫ right = left ≫ G.map' 0 1 := by cat_disch) :
F ⟶ G :=
homMk (fun i => match i with
| ⟨0, _⟩ => left
| ⟨1, _⟩ => right) (by
intro i hi
obtain rfl : i = 0 := by simpa using hi
exact w)
@[ext] | 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 1`. |
hom_ext₁ {F G : ComposableArrows C 1} {φ φ' : F ⟶ G}
(h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) :
φ = φ' := by
ext i
match i with
| 0 => exact h₀
| 1 => exact 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 1}
(left : F.obj' 0 ≅ G.obj' 0) (right : F.obj' 1 ≅ G.obj' 1)
(w : F.map' 0 1 ≫ right.hom = left.hom ≫ G.map' 0 1 := by cat_disch) :
F ≅ G where
hom := homMk₁ left.hom right.hom w
inv := homMk₁ left.inv right.inv (by
rw [← cancel_mono right.hom, assoc, assoc, w, right.inv_hom_id, left.inv_hom_id_assoc]
apply comp_id) | 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 1`. |
map'_eq_hom₁ (F : ComposableArrows C 1) : F.map' 0 1 = F.hom := 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 | map'_eq_hom₁ | null |
ext₁ {F G : ComposableArrows C 1}
(left : F.left = G.left) (right : F.right = G.right)
(w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom right.symm) : F = G :=
Functor.ext_of_iso (isoMk₁ (eqToIso left) (eqToIso right) (by simp [map'_eq_hom₁, w]))
(fun i => by fin_cases i <;> assumption)
(fun i => by fin_cases 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 | ext₁ | null |
mk₁_surjective (X : ComposableArrows C 1) : ∃ (X₀ X₁ : C) (f : X₀ ⟶ X₁), X = mk₁ f :=
⟨_, _, X.map' 0 1, ext₁ rfl rfl (by simp)⟩
variable (F) | 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 |
obj : Fin (n + 1 + 1) → C
| ⟨0, _⟩ => X
| ⟨i + 1, hi⟩ => F.obj' i
@[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 | obj | The map `Fin (n + 1 + 1) → C` which "shifts" `F.obj'` to the right and inserts `X` in
the zeroth position. |
obj_zero : obj F X 0 = X := 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 | obj_zero | null |
obj_one : obj F X 1 = F.obj' 0 := 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 | obj_one | null |
obj_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) : obj F X ⟨i + 1, hi⟩ = F.obj' i := rfl
variable {X} (f : X ⟶ F.left) | 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 | obj_succ | null |
map : ∀ (i j : Fin (n + 1 + 1)) (_ : i ≤ j), obj F X i ⟶ obj F X j
| ⟨0, _⟩, ⟨0, _⟩, _ => 𝟙 X
| ⟨0, _⟩, ⟨1, _⟩, _ => f
| ⟨0, _⟩, ⟨j + 2, hj⟩, _ => f ≫ F.map' 0 (j + 1)
| ⟨i + 1, hi⟩, ⟨j + 1, hj⟩, hij => F.map' i j (by simpa using hij)
@[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 | map | Auxiliary definition for the action on maps of the functor `F.precomp f`.
It sends `0 ≤ 1` to `f` and `i + 1 ≤ j + 1` to `F.map' i j`. |
map_zero_zero : map F f 0 0 (by simp) = 𝟙 X := 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 | map_zero_zero | null |
map_one_one : map F f 1 1 (by simp) = F.map (𝟙 _) := 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 | map_one_one | null |
map_zero_one : map F f 0 1 (by simp) = f := 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 | map_zero_one | null |
map_zero_one' : map F f 0 ⟨0 + 1, by simp⟩ (by simp) = f := 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 | map_zero_one' | null |
map_zero_succ_succ (j : ℕ) (hj : j + 2 < n + 1 + 1) :
map F f 0 ⟨j + 2, hj⟩ (by simp) = f ≫ F.map' 0 (j+1) := 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 | map_zero_succ_succ | null |
map_succ_succ (i j : ℕ) (hi : i + 1 < n + 1 + 1) (hj : j + 1 < n + 1 + 1)
(hij : i + 1 ≤ j + 1) :
map F f ⟨i + 1, hi⟩ ⟨j + 1, hj⟩ hij = F.map' i j := 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 | map_succ_succ | null |
map_one_succ (j : ℕ) (hj : j + 1 < n + 1 + 1) :
map F f 1 ⟨j + 1, hj⟩ (by simp [Fin.le_def]) = F.map' 0 j := 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 | map_one_succ | null |
map_id (i : Fin (n + 1 + 1)) : map F f i i (by simp) = 𝟙 _ := by
obtain ⟨_ | _, hi⟩ := i <;> 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 | map_id | null |
map_comp {i j k : Fin (n + 1 + 1)} (hij : i ≤ j) (hjk : j ≤ k) :
map F f i k (hij.trans hjk) = map F f i j hij ≫ map F f j k hjk := by
obtain ⟨i, hi⟩ := i
obtain ⟨j, hj⟩ := j
obtain ⟨k, hk⟩ := k
cases i
· obtain _ | _ | j := j
· dsimp
rw [id_comp]
· obtain _ | _ | k := k
· simp at hjk
· simp
· rfl
· obtain _ | _ | k := k
· simp [Fin.ext_iff] at hjk
· simp [Fin.le_def] at hjk
· dsimp
rw [assoc, ← F.map_comp, homOfLE_comp]
· obtain _ | j := j
· simp [Fin.ext_iff] at hij
· obtain _ | k := k
· simp [Fin.ext_iff] at hjk
· dsimp
rw [← F.map_comp, homOfLE_comp] | 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_comp | null |
@[simps]
precomp {X : C} (f : X ⟶ F.left) : ComposableArrows C (n + 1) where
obj := Precomp.obj F X
map g := Precomp.map F f _ _ (leOfHom g)
map_id := Precomp.map_id F f
map_comp g g' := Precomp.map_comp F f (leOfHom g) (leOfHom g') | 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 | precomp | "Precomposition" of `F : ComposableArrows C n` by a morphism `f : X ⟶ F.left`. |
@[simp]
mk₂ {X₀ X₁ X₂ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) : ComposableArrows C 2 :=
(mk₁ g).precomp f | 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 | mk₂ | Constructor for `ComposableArrows C 2`. |
@[simp]
mk₃ {X₀ X₁ X₂ X₃ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) (h : X₂ ⟶ X₃) : ComposableArrows C 3 :=
(mk₂ g h).precomp f | 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 | mk₃ | Constructor for `ComposableArrows C 3`. |
@[simp]
mk₄ {X₀ X₁ X₂ X₃ X₄ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) (h : X₂ ⟶ X₃) (i : X₃ ⟶ X₄) :
ComposableArrows C 4 :=
(mk₃ g h i).precomp f | 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 | mk₄ | Constructor for `ComposableArrows C 4`. |
@[simp]
mk₅ {X₀ X₁ X₂ X₃ X₄ X₅ : C} (f : X₀ ⟶ X₁) (g : X₁ ⟶ X₂) (h : X₂ ⟶ X₃)
(i : X₃ ⟶ X₄) (j : X₄ ⟶ X₅) :
ComposableArrows C 5 :=
(mk₄ g h i j).precomp f | 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 | mk₅ | Constructor for `ComposableArrows C 5`. |
@[simps!]
whiskerLeft (F : ComposableArrows C m) (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
ComposableArrows C n := Φ ⋙ F | 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 | whiskerLeft | The map `ComposableArrows C m → ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. |
@[simps!]
whiskerLeftFunctor (Φ : Fin (n + 1) ⥤ Fin (m + 1)) :
ComposableArrows C m ⥤ ComposableArrows C n where
obj F := F.whiskerLeft Φ
map f := Functor.whiskerLeft Φ f | 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 | whiskerLeftFunctor | The functor `ComposableArrows C m ⥤ ComposableArrows C n` obtained by precomposition with
a functor `Fin (n + 1) ⥤ Fin (m + 1)`. |
@[simps]
_root_.Fin.succFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) where
obj i := i.succ
map {_ _} hij := homOfLE (Fin.succ_le_succ_iff.2 (leOfHom hij)) | 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 | _root_.Fin.succFunctor | The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.succ`. |
@[simps!]
δ₀Functor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n :=
whiskerLeftFunctor (Fin.succFunctor (n + 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 | δ₀Functor | The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the first arrow. |
δ₀ (F : ComposableArrows C (n + 1)) := δ₀Functor.obj F
@[simp] | abbrev | 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 | δ₀ | The `ComposableArrows C n` obtained by forgetting the first arrow. |
precomp_δ₀ {X : C} (f : X ⟶ F.left) : (F.precomp f).δ₀ = F := 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 | precomp_δ₀ | null |
@[simps]
_root_.Fin.castSuccFunctor (n : ℕ) : Fin n ⥤ Fin (n + 1) where
obj i := i.castSucc
map hij := hij | 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 | _root_.Fin.castSuccFunctor | The functor `Fin n ⥤ Fin (n + 1)` which sends `i` to `i.castSucc`. |
@[simps!]
δlastFunctor : ComposableArrows C (n + 1) ⥤ ComposableArrows C n :=
whiskerLeftFunctor (Fin.castSuccFunctor (n + 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 | δlastFunctor | The functor `ComposableArrows C (n + 1) ⥤ ComposableArrows C n` which forgets
the last arrow. |
δlast (F : ComposableArrows C (n + 1)) := δlastFunctor.obj F | abbrev | 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 | δlast | The `ComposableArrows C n` obtained by forgetting the first arrow. |
homMkSucc (α : F.obj' 0 ⟶ G.obj' 0) (β : F.δ₀ ⟶ G.δ₀)
(w : F.map' 0 1 ≫ app' β 0 = α ≫ G.map' 0 1) : F ⟶ G :=
homMk
(fun i => match i with
| ⟨0, _⟩ => α
| ⟨i + 1, hi⟩ => app' β i)
(fun i hi => by
obtain _ | i := i
· exact w
· exact naturality' β i (i + 1))
variable (α : F.obj' 0 ⟶ G.obj' 0) (β : F.δ₀ ⟶ G.δ₀)
(w : F.map' 0 1 ≫ app' β 0 = α ≫ G.map' 0 1)
@[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 | homMkSucc | Inductive construction of morphisms in `ComposableArrows C (n + 1)`: in order to construct
a morphism `F ⟶ G`, it suffices to provide `α : F.obj' 0 ⟶ G.obj' 0` and `β : F.δ₀ ⟶ G.δ₀`
such that `F.map' 0 1 ≫ app' β 0 = α ≫ G.map' 0 1`. |
homMkSucc_app_zero : (homMkSucc α β w).app 0 = α := 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 | homMkSucc_app_zero | null |
homMkSucc_app_succ (i : ℕ) (hi : i + 1 < n + 1 + 1) :
(homMkSucc α β w).app ⟨i + 1, hi⟩ = app' β 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 | homMkSucc_app_succ | null |
hom_ext_succ {F G : ComposableArrows C (n + 1)} {f g : F ⟶ G}
(h₀ : app' f 0 = app' g 0) (h₁ : δ₀Functor.map f = δ₀Functor.map g) : f = g := by
ext ⟨i, hi⟩
obtain _ | i := i
· exact h₀
· exact congr_app 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 | hom_ext_succ | null |
@[simps]
isoMkSucc {F G : ComposableArrows C (n + 1)} (α : F.obj' 0 ≅ G.obj' 0)
(β : F.δ₀ ≅ G.δ₀) (w : F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1) : F ≅ G where
hom := homMkSucc α.hom β.hom w
inv := homMkSucc α.inv β.inv (by
rw [← cancel_epi α.hom, ← reassoc_of% w, α.hom_inv_id_assoc, β.hom_inv_id_app]
dsimp
rw [comp_id])
hom_inv_id := by
apply hom_ext_succ
· simp
· ext ⟨i, hi⟩
simp
inv_hom_id := by
apply hom_ext_succ
· simp
· ext ⟨i, hi⟩
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 | isoMkSucc | Inductive construction of isomorphisms in `ComposableArrows C (n + 1)`: in order to
construct an isomorphism `F ≅ G`, it suffices to provide `α : F.obj' 0 ≅ G.obj' 0` and
`β : F.δ₀ ≅ G.δ₀` such that `F.map' 0 1 ≫ app' β.hom 0 = α.hom ≫ G.map' 0 1`. |
ext_succ {F G : ComposableArrows C (n + 1)} (h₀ : F.obj' 0 = G.obj' 0)
(h : F.δ₀ = G.δ₀) (w : F.map' 0 1 = eqToHom h₀ ≫ G.map' 0 1 ≫
eqToHom (Functor.congr_obj h.symm 0)) : F = G := by
have : ∀ i, F.obj i = G.obj i := by
intro ⟨i, hi⟩
rcases i with - | i
· exact h₀
· exact Functor.congr_obj h ⟨i, by valid⟩
exact Functor.ext_of_iso (isoMkSucc (eqToIso h₀) (eqToIso h) (by
rw [w]
dsimp [app']
rw [eqToHom_app, assoc, assoc, eqToHom_trans, eqToHom_refl, comp_id])) this
(by rintro ⟨_ | _, hi⟩ <;> 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 | ext_succ | null |
precomp_surjective (F : ComposableArrows C (n + 1)) :
∃ (F₀ : ComposableArrows C n) (X₀ : C) (f₀ : X₀ ⟶ F₀.left), F = F₀.precomp f₀ :=
⟨F.δ₀, _, F.map' 0 1, ext_succ rfl (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 | precomp_surjective | null |
homMk₂ : f ⟶ g := homMkSucc app₀ (homMk₁ app₁ app₂ 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 2`. |
homMk₂_app_zero : (homMk₂ app₀ app₁ app₂ 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₂ 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₂ w₀ w₁).app ⟨2, 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_two | null |
@[ext]
hom_ext₂ {f g : ComposableArrows C 2} {φ φ' : f ⟶ g}
(h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2) :
φ = φ' :=
hom_ext_succ h₀ (hom_ext₁ 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 2}
(app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
(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) : f ≅ g where
hom := homMk₂ app₀.hom app₁.hom app₂.hom w₀ w₁
inv := homMk₂ app₀.inv app₁.inv app₂.inv
(by rw [← cancel_epi app₀.hom, ← reassoc_of% w₀, app₁.hom_inv_id,
comp_id, app₀.hom_inv_id_assoc])
(by rw [← cancel_epi app₁.hom, ← reassoc_of% w₁, app₂.hom_inv_id,
comp_id, app₁.hom_inv_id_assoc]) | 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 2`. |
ext₂ {f g : ComposableArrows C 2}
(h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
(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) : f = g :=
ext_succ h₀ (ext₁ h₁ h₂ 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 2) :
∃ (X₀ X₁ X₂ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂), X = mk₂ f₀ f₁ :=
⟨_, _, _, X.map' 0 1, X.map' 1 2, ext₂ rfl rfl rfl (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₃ 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 3`. |
homMk₃_app_zero : (homMk₃ app₀ app₁ app₂ app₃ 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₃ 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₃ 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₃ w₀ w₁ w₂).app ⟨3, 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_three | null |
@[ext]
hom_ext₃ {f g : ComposableArrows C 3} {φ φ' : f ⟶ g}
(h₀ : app' φ 0 = app' φ' 0) (h₁ : app' φ 1 = app' φ' 1) (h₂ : app' φ 2 = app' φ' 2)
(h₃ : app' φ 3 = app' φ' 3) :
φ = φ' :=
hom_ext_succ h₀ (hom_ext₂ 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 3}
(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)
(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) : f ≅ g where
hom := homMk₃ app₀.hom app₁.hom app₂.hom app₃.hom w₀ w₁ w₂
inv := homMk₃ app₀.inv app₁.inv app₂.inv app₃.inv
(by rw [← cancel_epi app₀.hom, ← reassoc_of% w₀, app₁.hom_inv_id,
comp_id, app₀.hom_inv_id_assoc])
(by rw [← cancel_epi app₁.hom, ← reassoc_of% w₁, app₂.hom_inv_id,
comp_id, app₁.hom_inv_id_assoc])
(by rw [← cancel_epi app₂.hom, ← reassoc_of% w₂, app₃.hom_inv_id,
comp_id, app₂.hom_inv_id_assoc]) | 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 3`. |
ext₃ {f g : ComposableArrows C 3}
(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)
(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) : f = g :=
ext_succ h₀ (ext₂ h₁ h₂ h₃ 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 3) :
∃ (X₀ X₁ X₂ X₃ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃), X = mk₃ f₀ f₁ f₂ :=
⟨_, _, _, _, X.map' 0 1, X.map' 1 2, X.map' 2 3,
ext₃ rfl rfl rfl rfl (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₄ 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 4`. |
homMk₄_app_zero : (homMk₄ app₀ app₁ app₂ app₃ app₄ 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₄ 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₄ 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₄ 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.