Loogle!

Result

Found 165 declarations mentioning CategoryTheory.Limits.MultispanShape.L.

CategoryTheory.Limits.MultispanShape.L 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(self : CategoryTheory.Limits.MultispanShape) : Type w
CategoryTheory.Limits.instUniqueLOfLinearOrderBool 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
: Unique (CategoryTheory.Limits.MultispanShape.ofLinearOrder Bool).L
CategoryTheory.Limits.MultispanShape.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(self : CategoryTheory.Limits.MultispanShape) : self.L → self.R
CategoryTheory.Limits.MultispanShape.snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(self : CategoryTheory.Limits.MultispanShape) : self.L → self.R
CategoryTheory.Limits.WalkingMultispan.left 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} : J.L → CategoryTheory.Limits.WalkingMultispan J
CategoryTheory.Limits.WalkingMultispan.instInhabitedOfL 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} [Inhabited J.L] : Inhabited (CategoryTheory.Limits.WalkingMultispan J)
CategoryTheory.Limits.MultispanShape.prod_L 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(ι : Type w) : (CategoryTheory.Limits.MultispanShape.prod ι).L = (ι × ι)
CategoryTheory.Limits.WalkingMultispan.equiv 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(J : CategoryTheory.Limits.MultispanShape) : CategoryTheory.Limits.WalkingMultispan J ≃ J.L ⊕ J.R
CategoryTheory.Limits.WalkingMultispan.instSmallOfLOfR 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} [Small.{t, w} J.L] [Small.{t, w'} J.R] : Small.{t, max w' w} (CategoryTheory.Limits.WalkingMultispan J)
CategoryTheory.Limits.MultispanIndex.left 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Limits.MultispanIndex J C) : J.L → C
CategoryTheory.Limits.WalkingMultispan.Hom.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} (a : J.L) : (CategoryTheory.Limits.WalkingMultispan.left a).Hom (CategoryTheory.Limits.WalkingMultispan.right (J.fst a))
CategoryTheory.Limits.WalkingMultispan.Hom.snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} (a : J.L) : (CategoryTheory.Limits.WalkingMultispan.left a).Hom (CategoryTheory.Limits.WalkingMultispan.right (J.snd a))
CategoryTheory.Limits.WalkingMultispan.arrowEquiv 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(J : CategoryTheory.Limits.MultispanShape) : CategoryTheory.Arrow (CategoryTheory.Limits.WalkingMultispan J) ≃ CategoryTheory.Limits.WalkingMultispan J ⊕ J.L ⊕ J.L
CategoryTheory.Limits.WalkingMultispan.instIsEmptyHomRightLeft 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} (a : J.R) (b : J.L) : IsEmpty (CategoryTheory.Limits.WalkingMultispan.right a ⟶ CategoryTheory.Limits.WalkingMultispan.left b)
CategoryTheory.Limits.WalkingMultispan.instSubsingletonHomLeft 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} (a b : J.L) : Subsingleton (CategoryTheory.Limits.WalkingMultispan.left a ⟶ CategoryTheory.Limits.WalkingMultispan.left b)
CategoryTheory.Limits.MultispanIndex.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Limits.MultispanIndex J C) (a : J.L) : self.left a ⟶ self.right (J.fst a)
CategoryTheory.Limits.MultispanIndex.snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Limits.MultispanIndex J C) (a : J.L) : self.left a ⟶ self.right (J.snd a)
CategoryTheory.Limits.MultispanIndex.multispan_obj_left 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) (a : J.L) : I.multispan.obj (CategoryTheory.Limits.WalkingMultispan.left a) = I.left a
CategoryTheory.Limits.MultispanIndex.parallelPairDiagram 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C
CategoryTheory.Limits.MultispanShape.ofLinearOrder_L 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(ι : Type w) [LinearOrder ι] : (CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).L = ↑{x | x.1 < x.2}
CategoryTheory.Limits.MultispanIndex.mk 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (left : J.L → C) (right : J.R → C) (fst : (a : J.L) → left a ⟶ right (J.fst a)) (snd : (a : J.L) → left a ⟶ right (J.snd a)) : CategoryTheory.Limits.MultispanIndex J C
CategoryTheory.Limits.MultispanIndex.parallelPairDiagramOfIsColimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C
CategoryTheory.Limits.Multicoequalizer.sigmaπ 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : ∐ I.right ⟶ CategoryTheory.Limits.multicoequalizer I
CategoryTheory.Limits.MultispanIndex.fstSigmaMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : ∐ I.left ⟶ ∐ I.right
CategoryTheory.Limits.MultispanIndex.sndSigmaMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : ∐ I.left ⟶ ∐ I.right
CategoryTheory.Limits.Multicoequalizer.instEpiSigmaπ 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : CategoryTheory.Epi (CategoryTheory.Limits.Multicoequalizer.sigmaπ I)
CategoryTheory.Limits.Multicoequalizer.instHasCoequalizerFstSigmaMapSndSigmaMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : CategoryTheory.Limits.HasCoequalizer I.fstSigmaMap I.sndSigmaMap
CategoryTheory.Limits.MultispanIndex.multispan_map_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) (a : J.L) : I.multispan.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst a) = I.fst a
CategoryTheory.Limits.MultispanIndex.multispan_map_snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) (a : J.L) : I.multispan.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd a) = I.snd a
CategoryTheory.Limits.MultispanIndex.toLinearOrder_left 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type w} (I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C) [LinearOrder ι] (j : (CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).L) : I.toLinearOrder.left j = I.left ↑j
CategoryTheory.Limits.Multicoequalizer.isoCoequalizer 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : CategoryTheory.Limits.multicoequalizer I ≅ CategoryTheory.Limits.coequalizer I.fstSigmaMap I.sndSigmaMap
CategoryTheory.Limits.MultispanIndex.fstSigmaMapOfIsColimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) : c.pt ⟶ d.pt
CategoryTheory.Limits.MultispanIndex.sndSigmaMapOfIsColimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) : c.pt ⟶ d.pt
CategoryTheory.Limits.Multicofork.ofπ 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) (P : C) (π : (b : J.R) → I.right b ⟶ P) (w : ∀ (a : J.L), CategoryTheory.CategoryStruct.comp (I.fst a) (π (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (π (J.snd a))) : CategoryTheory.Limits.Multicofork I
CategoryTheory.Limits.MultispanIndex.parallelPairDiagramOfIsColimit_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (x : CategoryTheory.Limits.WalkingParallelPair) : (I.parallelPairDiagramOfIsColimit d hc).obj x = CategoryTheory.Limits.parallelPair.parallelPairObj c.pt d.pt x
CategoryTheory.Limits.Multicoequalizer.ι_sigmaπ 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : J.R) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b) (CategoryTheory.Limits.Multicoequalizer.sigmaπ I) = CategoryTheory.Limits.Multicoequalizer.π I b
CategoryTheory.Limits.Multicofork.ofSigmaCofork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left} {hc : CategoryTheory.Limits.IsColimit c} {d : CategoryTheory.Limits.Cofan I.right} (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)) : CategoryTheory.Limits.Multicofork I
CategoryTheory.Limits.Multicoequalizer.condition 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] (a : J.L) : CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicoequalizer.π I (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.Limits.Multicoequalizer.π I (J.snd a))
CategoryTheory.Limits.Multicoequalizer.desc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] (W : C) (k : (b : J.R) → I.right b ⟶ W) (h : ∀ (a : J.L), CategoryTheory.CategoryStruct.comp (I.fst a) (k (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (k (J.snd a))) : CategoryTheory.Limits.multicoequalizer I ⟶ W
CategoryTheory.Limits.Multicofork.ofπ_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) (P : C) (π : (b : J.R) → I.right b ⟶ P) (w : ∀ (a : J.L), CategoryTheory.CategoryStruct.comp (I.fst a) (π (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (π (J.snd a))) : (CategoryTheory.Limits.Multicofork.ofπ I P π w).pt = P
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] : CategoryTheory.Limits.Multicofork I ≌ CategoryTheory.Limits.Cofork I.fstSigmaMap I.sndSigmaMap
CategoryTheory.Limits.Multicofork.toSigmaCofork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) (K : CategoryTheory.Limits.Multicofork I) : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)
CategoryTheory.Limits.Multicofork.condition 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) (a : J.L) : CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (J.snd a))
CategoryTheory.Limits.Multicofork.IsColimit.desc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {K : CategoryTheory.Limits.Multicofork I} (hK : CategoryTheory.Limits.IsColimit K) {T : C} (k : (a : J.R) → I.right a ⟶ T) (hk : ∀ (b : J.L), CategoryTheory.CategoryStruct.comp (I.fst b) (k (J.fst b)) = CategoryTheory.CategoryStruct.comp (I.snd b) (k (J.snd b))) : K.pt ⟶ T
CategoryTheory.Limits.Multicoequalizer.condition_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] (a : J.L) {Z : C} (h : CategoryTheory.Limits.multicoequalizer I ⟶ Z) : CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I (J.fst a)) h) = CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I (J.snd a)) h)
CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b) I.fstSigmaMap = CategoryTheory.CategoryStruct.comp (I.fst b) (CategoryTheory.Limits.Sigma.ι I.right (J.fst b))
CategoryTheory.Limits.MultispanIndex.ι_sndSigmaMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b) I.sndSigmaMap = CategoryTheory.CategoryStruct.comp (I.snd b) (CategoryTheory.Limits.Sigma.ι I.right (J.snd b))
CategoryTheory.Limits.Multicoequalizer.ι_sigmaπ_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : J.R) {Z : C} (h : CategoryTheory.Limits.multicoequalizer I ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right b) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.sigmaπ I) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b) h
CategoryTheory.Limits.Multicoequalizer.π_desc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] (W : C) (k : (b : J.R) → I.right b ⟶ W) (h : ∀ (a : J.L), CategoryTheory.CategoryStruct.comp (I.fst a) (k (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (k (J.snd a))) (b : J.R) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b) (CategoryTheory.Limits.Multicoequalizer.desc I W k h) = k b
CategoryTheory.Limits.Multicofork.toSigmaCofork_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) (K : CategoryTheory.Limits.Multicofork I) : (CategoryTheory.Limits.Multicofork.toSigmaCofork hc hd K).pt = K.pt
CategoryTheory.Limits.Multicofork.condition_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) (a : J.L) {Z : C} (h : K.pt ⟶ Z) : CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.CategoryStruct.comp (K.π (J.fst a)) h) = CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.CategoryStruct.comp (K.π (J.snd a)) h)
CategoryTheory.Limits.Multicofork.IsColimit.fac 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {K : CategoryTheory.Limits.Multicofork I} (hK : CategoryTheory.Limits.IsColimit K) {T : C} (k : (a : J.R) → I.right a ⟶ T) (hk : ∀ (b : J.L), CategoryTheory.CategoryStruct.comp (I.fst b) (k (J.fst b)) = CategoryTheory.CategoryStruct.comp (I.snd b) (k (J.snd b))) (a : J.R) : CategoryTheory.CategoryStruct.comp (K.π a) (CategoryTheory.Limits.Multicofork.IsColimit.desc hK k hk) = k a
CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} : CategoryTheory.Functor (CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)) (CategoryTheory.Limits.Multicofork I)
CategoryTheory.Limits.Multicofork.ofSigmaCofork_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left} {hc : CategoryTheory.Limits.IsColimit c} {d : CategoryTheory.Limits.Cofan I.right} (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)) : (CategoryTheory.Limits.Multicofork.ofSigmaCofork a).pt = a.pt
CategoryTheory.Limits.Multicofork.fst_app_right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) (a : J.L) : K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) = CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (J.fst a))
CategoryTheory.Limits.Multicofork.snd_app_right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) (a : J.L) : K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) = CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (J.snd a))
CategoryTheory.Limits.Multicoequalizer.π_desc_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasMulticoequalizer I] (W : C) (k : (b : J.R) → I.right b ⟶ W) (h : ∀ (a : J.L), CategoryTheory.CategoryStruct.comp (I.fst a) (k (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (k (J.snd a))) (b : J.R) {Z : C} (h✝ : W ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.π I b) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicoequalizer.desc I W k h) h✝) = CategoryTheory.CategoryStruct.comp (k b) h✝
CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) {Z : C} (h : ∐ I.right ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b) (CategoryTheory.CategoryStruct.comp I.fstSigmaMap h) = CategoryTheory.CategoryStruct.comp (I.fst b) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right (J.fst b)) h)
CategoryTheory.Limits.MultispanIndex.ι_sndSigmaMap_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) {Z : C} (h : ∐ I.right ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.left b) (CategoryTheory.CategoryStruct.comp I.sndSigmaMap h) = CategoryTheory.CategoryStruct.comp (I.snd b) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Sigma.ι I.right (J.snd b)) h)
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCoforkOfIsColimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : CategoryTheory.Limits.Multicofork I ≌ CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)
CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : CategoryTheory.Functor (CategoryTheory.Limits.Multicofork I) (CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc))
CategoryTheory.Limits.MultispanIndex.toLinearOrder_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type w} (I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C) [LinearOrder ι] (j : (CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).L) : I.toLinearOrder.fst j = I.fst ↑j
CategoryTheory.Limits.MultispanIndex.toLinearOrder_snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type w} (I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C) [LinearOrder ι] (j : (CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).L) : I.toLinearOrder.snd j = I.snd ↑j
CategoryTheory.Limits.MultispanIndex.inj_fstSigmaMapOfIsColimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (i : J.L) : CategoryTheory.CategoryStruct.comp (c.inj i) (I.fstSigmaMapOfIsColimit d hc) = CategoryTheory.CategoryStruct.comp (I.fst i) (d.inj (J.fst i))
CategoryTheory.Limits.MultispanIndex.inj_sndSigmaMapOfIsColimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (i : J.L) : CategoryTheory.CategoryStruct.comp (c.inj i) (I.sndSigmaMapOfIsColimit d hc) = CategoryTheory.CategoryStruct.comp (I.snd i) (d.inj (J.snd i))
CategoryTheory.Limits.Multicofork.IsColimit.fac_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {K : CategoryTheory.Limits.Multicofork I} (hK : CategoryTheory.Limits.IsColimit K) {T : C} (k : (a : J.R) → I.right a ⟶ T) (hk : ∀ (b : J.L), CategoryTheory.CategoryStruct.comp (I.fst b) (k (J.fst b)) = CategoryTheory.CategoryStruct.comp (I.snd b) (k (J.snd b))) (a : J.R) {Z : C} (h : T ⟶ Z) : CategoryTheory.CategoryStruct.comp (K.π a) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multicofork.IsColimit.desc hK k hk) h) = CategoryTheory.CategoryStruct.comp (k a) h
CategoryTheory.Limits.MultispanIndex.parallelPairDiagramOfIsColimit_map 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) {X✝ Y✝ : CategoryTheory.Limits.WalkingParallelPair} (h : X✝ ⟶ Y✝) : (I.parallelPairDiagramOfIsColimit d hc).map h = CategoryTheory.Limits.parallelPair.parallelPairHom (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc) h
CategoryTheory.Limits.MultispanIndex.inj_fstSigmaMapOfIsColimit_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (i : J.L) {Z : C} (h : d.pt ⟶ Z) : CategoryTheory.CategoryStruct.comp (c.inj i) (CategoryTheory.CategoryStruct.comp (I.fstSigmaMapOfIsColimit d hc) h) = CategoryTheory.CategoryStruct.comp (I.fst i) (CategoryTheory.CategoryStruct.comp (d.inj (J.fst i)) h)
CategoryTheory.Limits.MultispanIndex.inj_sndSigmaMapOfIsColimit_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (i : J.L) {Z : C} (h : d.pt ⟶ Z) : CategoryTheory.CategoryStruct.comp (c.inj i) (CategoryTheory.CategoryStruct.comp (I.sndSigmaMapOfIsColimit d hc) h) = CategoryTheory.CategoryStruct.comp (I.snd i) (CategoryTheory.CategoryStruct.comp (d.inj (J.snd i)) h)
CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)) : (I.ofSigmaCoforkFunctor hc).obj a = CategoryTheory.Limits.Multicofork.ofSigmaCofork a
CategoryTheory.Limits.Multicofork.toSigmaCofork_π 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : (CategoryTheory.Limits.Multicofork.toSigmaCofork hc hd K).π = CategoryTheory.Limits.Cofan.IsColimit.desc hd K.π
CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) (K : CategoryTheory.Limits.Multicofork I) : (I.toSigmaCoforkFunctor hc hd).obj K = CategoryTheory.Limits.Multicofork.toSigmaCofork hc hd K
CategoryTheory.Limits.Multicofork.sigma_condition 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : CategoryTheory.CategoryStruct.comp (I.fstSigmaMapOfIsColimit d hc) (CategoryTheory.Limits.Cofan.IsColimit.desc hd K.π) = CategoryTheory.CategoryStruct.comp (I.sndSigmaMapOfIsColimit d hc) (CategoryTheory.Limits.Cofan.IsColimit.desc hd K.π)
CategoryTheory.Limits.Multicofork.ofSigmaCofork_π 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)) (i : J.R) : (CategoryTheory.Limits.Multicofork.ofSigmaCofork a).π i = CategoryTheory.CategoryStruct.comp (d.inj i) a.π
CategoryTheory.Limits.Multicofork.snd_app_right_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) (a : J.L) {Z : C} (h : ((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingMultispan J)).obj K.pt).obj (CategoryTheory.Limits.WalkingMultispan.left a) ⟶ Z) : CategoryTheory.CategoryStruct.comp (K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a)) h = CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (I.snd a) (K.π (J.snd a))) h
CategoryTheory.Limits.Multicofork.ofπ_ι_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) (P : C) (π : (b : J.R) → I.right b ⟶ P) (w : ∀ (a : J.L), CategoryTheory.CategoryStruct.comp (I.fst a) (π (J.fst a)) = CategoryTheory.CategoryStruct.comp (I.snd a) (π (J.snd a))) (x : CategoryTheory.Limits.WalkingMultispan J) : (CategoryTheory.Limits.Multicofork.ofπ I P π w).ι.app x = match x with | CategoryTheory.Limits.WalkingMultispan.left a => CategoryTheory.CategoryStruct.comp (I.fst a) (π (J.fst a)) | CategoryTheory.Limits.WalkingMultispan.right a => π a
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCoforkOfIsColimit_inverse 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : (I.multicoforkEquivSigmaCoforkOfIsColimit hc hd).inverse = I.ofSigmaCoforkFunctor hc
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCoforkOfIsColimit_functor 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : (I.multicoforkEquivSigmaCoforkOfIsColimit hc hd).functor = I.toSigmaCoforkFunctor hc hd
CategoryTheory.Limits.Multicofork.sigma_condition_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) {Z : C} (h : K.pt ⟶ Z) : CategoryTheory.CategoryStruct.comp (I.fstSigmaMapOfIsColimit d hc) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.IsColimit.desc hd K.π) h) = CategoryTheory.CategoryStruct.comp (I.sndSigmaMapOfIsColimit d hc) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.IsColimit.desc hd K.π) h)
CategoryTheory.Limits.MultispanIndex.toSigmaCoforkFunctor_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) {K₁ K₂ : CategoryTheory.Limits.Multicofork I} (f : K₁ ⟶ K₂) : ((I.toSigmaCoforkFunctor hc hd).map f).hom = f.hom
CategoryTheory.Limits.WalkingMultispan.functorExt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMultispan J) C} (left : (i : J.L) → F.obj (CategoryTheory.Limits.WalkingMultispan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.left i)) (right : (i : J.R) → F.obj (CategoryTheory.Limits.WalkingMultispan.right i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.right i)) (wl : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst i)) (right (J.fst i)).hom = CategoryTheory.CategoryStruct.comp (left i).hom (G.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst i)) := by cat_disch) (wr : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd i)) (right (J.snd i)).hom = CategoryTheory.CategoryStruct.comp (left i).hom (G.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd i)) := by cat_disch) : F ≅ G
CategoryTheory.Limits.Multicofork.ofSigmaCofork_ι_app_left 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} {I : CategoryTheory.Limits.MultispanIndex J C} {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)) (i : J.L) : (CategoryTheory.Limits.Multicofork.ofSigmaCofork a).ι.app (CategoryTheory.Limits.WalkingMultispan.left i) = CategoryTheory.CategoryStruct.comp (c.inj i) (CategoryTheory.CategoryStruct.comp (I.fstSigmaMapOfIsColimit d hc) a.π)
CategoryTheory.Limits.WalkingMultispan.functorExt_hom_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMultispan J) C} (left : (i : J.L) → F.obj (CategoryTheory.Limits.WalkingMultispan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.left i)) (right : (i : J.R) → F.obj (CategoryTheory.Limits.WalkingMultispan.right i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.right i)) (wl : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst i)) (right (J.fst i)).hom = CategoryTheory.CategoryStruct.comp (left i).hom (G.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst i)) := by cat_disch) (wr : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd i)) (right (J.snd i)).hom = CategoryTheory.CategoryStruct.comp (left i).hom (G.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd i)) := by cat_disch) (X : CategoryTheory.Limits.WalkingMultispan J) : (CategoryTheory.Limits.WalkingMultispan.functorExt left right wl wr).hom.app X = (match X with | CategoryTheory.Limits.WalkingMultispan.left i => left i | CategoryTheory.Limits.WalkingMultispan.right i => right i).hom
CategoryTheory.Limits.WalkingMultispan.functorExt_inv_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{J : CategoryTheory.Limits.MultispanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMultispan J) C} (left : (i : J.L) → F.obj (CategoryTheory.Limits.WalkingMultispan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.left i)) (right : (i : J.R) → F.obj (CategoryTheory.Limits.WalkingMultispan.right i) ≅ G.obj (CategoryTheory.Limits.WalkingMultispan.right i)) (wl : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst i)) (right (J.fst i)).hom = CategoryTheory.CategoryStruct.comp (left i).hom (G.map (CategoryTheory.Limits.WalkingMultispan.Hom.fst i)) := by cat_disch) (wr : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd i)) (right (J.snd i)).hom = CategoryTheory.CategoryStruct.comp (left i).hom (G.map (CategoryTheory.Limits.WalkingMultispan.Hom.snd i)) := by cat_disch) (X : CategoryTheory.Limits.WalkingMultispan J) : (CategoryTheory.Limits.WalkingMultispan.functorExt left right wl wr).inv.app X = (match X with | CategoryTheory.Limits.WalkingMultispan.left i => left i | CategoryTheory.Limits.WalkingMultispan.right i => right i).inv
CategoryTheory.Limits.MultispanIndex.ofSigmaCoforkFunctor_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} {K₁ K₂ : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit d hc) (I.sndSigmaMapOfIsColimit d hc)} (f : K₁ ⟶ K₂) : ((I.ofSigmaCoforkFunctor hc).map f).hom = f.hom
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_functor_obj_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (K : CategoryTheory.Limits.Multicofork I) : (I.multicoforkEquivSigmaCofork.functor.obj K).pt = K.pt
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_inverse_obj_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left))) (I.sndSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left)))) : (I.multicoforkEquivSigmaCofork.inverse.obj a).pt = a.pt
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_functor_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multicofork I} (f : K₁ ⟶ K₂) : (I.multicoforkEquivSigmaCofork.functor.map f).hom = f.hom
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCoforkOfIsColimit_unitIso 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : (I.multicoforkEquivSigmaCoforkOfIsColimit hc hd).unitIso = CategoryTheory.NatIso.ofComponents (fun K => CategoryTheory.Limits.Cocone.ext (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Multicofork I)).obj K).pt) ⋯) ⋯
CategoryTheory.Limits.WalkingMultispan.inclusionOfLinearOrder_map 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
(ι : Type w) [LinearOrder ι] {x y : CategoryTheory.Limits.WalkingMultispan (CategoryTheory.Limits.MultispanShape.ofLinearOrder ι)} (f : x ⟶ y) : (CategoryTheory.Limits.WalkingMultispan.inclusionOfLinearOrder ι).map f = match x, y, f with | x, .(x), CategoryTheory.Limits.WalkingMultispan.Hom.id .(x) => CategoryTheory.CategoryStruct.id (match x with | CategoryTheory.Limits.WalkingMultispan.left a => CategoryTheory.Limits.WalkingMultispan.left ↑a | CategoryTheory.Limits.WalkingMultispan.right b => CategoryTheory.Limits.WalkingMultispan.right b) | .(CategoryTheory.Limits.WalkingMultispan.left b), .(CategoryTheory.Limits.WalkingMultispan.right ((CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).fst b)), CategoryTheory.Limits.WalkingMultispan.Hom.fst b => CategoryTheory.Limits.WalkingMultispan.Hom.fst ↑b | .(CategoryTheory.Limits.WalkingMultispan.left b), .(CategoryTheory.Limits.WalkingMultispan.right ((CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).snd b)), CategoryTheory.Limits.WalkingMultispan.Hom.snd b => CategoryTheory.Limits.WalkingMultispan.Hom.snd ↑b
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_functor_obj_ι_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (K : CategoryTheory.Limits.Multicofork I) (X : CategoryTheory.Limits.WalkingParallelPair) : (I.multicoforkEquivSigmaCofork.functor.obj K).ι.app X = CategoryTheory.Limits.WalkingParallelPair.rec (CategoryTheory.CategoryStruct.comp (I.sndSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left))) (CategoryTheory.Limits.Cofan.IsColimit.desc (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.right)) K.π)) (CategoryTheory.Limits.Cofan.IsColimit.desc (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.right)) K.π) X
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_inverse_obj_ι_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (a : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left))) (I.sndSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left)))) (x : CategoryTheory.Limits.WalkingMultispan J) : (I.multicoforkEquivSigmaCofork.inverse.obj a).ι.app x = match x with | CategoryTheory.Limits.WalkingMultispan.left a_1 => CategoryTheory.CategoryStruct.comp (I.fst a_1) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (J.fst a_1)) a.π) | CategoryTheory.Limits.WalkingMultispan.right a_1 => CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cofan.inj (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) a_1) a.π
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_inverse_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] {K₁ K₂ : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left))) (I.sndSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left)))} (f : K₁ ⟶ K₂) : (I.multicoforkEquivSigmaCofork.inverse.map f).hom = f.hom
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_unitIso_hom_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (X : CategoryTheory.Limits.Multicofork I) : (I.multicoforkEquivSigmaCofork.unitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_unitIso_inv_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (X : CategoryTheory.Limits.Multicofork I) : (I.multicoforkEquivSigmaCofork.unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCoforkOfIsColimit_counitIso 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan I.right} (hd : CategoryTheory.Limits.IsColimit d) : (I.multicoforkEquivSigmaCoforkOfIsColimit hc hd).counitIso = CategoryTheory.NatIso.ofComponents (fun K => CategoryTheory.Limits.Cofork.ext (CategoryTheory.Iso.refl (((I.ofSigmaCoforkFunctor hc).comp (I.toSigmaCoforkFunctor hc hd)).obj K).pt) ⋯) ⋯
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_counitIso_hom_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (X : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left))) (I.sndSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left)))) : (I.multicoforkEquivSigmaCofork.counitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt
CategoryTheory.Limits.MultispanIndex.multicoforkEquivSigmaCofork_counitIso_inv_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape} (I : CategoryTheory.Limits.MultispanIndex J C) [CategoryTheory.Limits.HasCoproduct I.left] [CategoryTheory.Limits.HasCoproduct I.right] (X : CategoryTheory.Limits.Cofork (I.fstSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left))) (I.sndSigmaMapOfIsColimit (CategoryTheory.Limits.colimit.cocone (CategoryTheory.Discrete.functor I.right)) (CategoryTheory.Limits.colimit.isColimit (CategoryTheory.Discrete.functor I.left)))) : (I.multicoforkEquivSigmaCofork.counitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt
CategoryTheory.Limits.WalkingMultispan.instFintype 📋 Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer
{J : CategoryTheory.Limits.MultispanShape} [Fintype J.L] [Fintype J.R] : Fintype (CategoryTheory.Limits.WalkingMultispan J)
CategoryTheory.Limits.WalkingMultispan.instFinCategoryOfLOfDecidableEqR 📋 Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer
{J : CategoryTheory.Limits.MultispanShape} [Fintype J.L] [Fintype J.R] [DecidableEq J.L] [DecidableEq J.R] : CategoryTheory.FinCategory (CategoryTheory.Limits.WalkingMultispan J)
CategoryTheory.GlueData.diagram_left 📋 Mathlib.CategoryTheory.GlueData
{C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) : D.diagram.left = D.V
CategoryTheory.GlueData.types_ι_jointly_surjective 📋 Mathlib.CategoryTheory.GlueData
(D : CategoryTheory.GlueData (Type v)) (x : D.glued) : ∃ i y, (CategoryTheory.ConcreteCategory.hom (D.ι i)) y = x
CategoryTheory.GlueData.types_π_surjective 📋 Mathlib.CategoryTheory.GlueData
(D : CategoryTheory.GlueData (Type u_1)) : Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom D.π)
TopCat.GlueData.fromOpenSubsetsGlue 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) : (TopCat.GlueData.ofOpenSubsets U).glued ⟶ TopCat.of α
TopCat.GlueData.ι_mono 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i : D.J) : CategoryTheory.Mono (D.ι i)
TopCat.GlueData.openCoverGlueHomeo 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) (h : ⋃ i, ↑(U i) = Set.univ) : ↑(TopCat.GlueData.ofOpenSubsets U).glued ≃ₜ α
TopCat.GlueData.ι_fromOpenSubsetsGlue 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) (i : J) : CategoryTheory.CategoryStruct.comp ((TopCat.GlueData.ofOpenSubsets U).ι i) (TopCat.GlueData.fromOpenSubsetsGlue U) = (U i).inclusion'
TopCat.GlueData.ι_injective 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i : D.J) : Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i))
TopCat.GlueData.ι_isOpenEmbedding 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i : D.J) : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i))
TopCat.GlueData.ι_jointly_surjective 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (x : ↑D.glued) : ∃ i y, (CategoryTheory.ConcreteCategory.hom (D.ι i)) y = x
TopCat.GlueData.open_image_open 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i : D.J) (U : TopologicalSpace.Opens ↑(D.U i)) : IsOpen (⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) '' ↑U)
TopCat.GlueData.fromOpenSubsetsGlue_injective 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) : Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (TopCat.GlueData.fromOpenSubsetsGlue U))
TopCat.GlueData.range_fromOpenSubsetsGlue 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) : Set.range ⇑(CategoryTheory.ConcreteCategory.hom (TopCat.GlueData.fromOpenSubsetsGlue U)) = ⋃ i, ↑(U i)
TopCat.GlueData.isOpen_iff 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (U : Set ↑D.glued) : IsOpen U ↔ ∀ (i : D.J), IsOpen (⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) ⁻¹' U)
TopCat.GlueData.π_surjective 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) : Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom D.π)
TopCat.GlueData.fromOpenSubsetsGlue_isOpenEmbedding 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (TopCat.GlueData.fromOpenSubsetsGlue U))
TopCat.GlueData.fromOpenSubsetsGlue_isOpenMap 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) : IsOpenMap ⇑(CategoryTheory.ConcreteCategory.hom (TopCat.GlueData.fromOpenSubsetsGlue U))
TopCat.GlueData.ι_eq_iff_rel 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i j : D.J) (x : ↑(D.U i)) (y : ↑(D.U j)) : (CategoryTheory.ConcreteCategory.hom (D.ι i)) x = (CategoryTheory.ConcreteCategory.hom (D.ι j)) y ↔ D.Rel ⟨i, x⟩ ⟨j, y⟩
TopCat.GlueData.preimage_range 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i j : D.J) : ⇑(CategoryTheory.ConcreteCategory.hom (D.ι j)) ⁻¹' Set.range ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) = Set.range ⇑(CategoryTheory.ConcreteCategory.hom (D.f j i))
TopCat.GlueData.preimage_image_eq_image 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i j : D.J) (U : Set ↑(D.U i)) : ⇑(CategoryTheory.ConcreteCategory.hom (D.ι j)) ⁻¹' ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) '' U = ⇑(CategoryTheory.ConcreteCategory.hom (D.f j i)) '' ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))) ⁻¹' U
TopCat.GlueData.preimage_image_eq_image' 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i j : D.J) (U : Set ↑(D.U i)) : ⇑(CategoryTheory.ConcreteCategory.hom (D.ι j)) ⁻¹' ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) '' U = ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp (D.t i j) (D.f j i))) '' ⇑(CategoryTheory.ConcreteCategory.hom (D.f i j)) ⁻¹' U
TopCat.GlueData.ι_fromOpenSubsetsGlue_apply 📋 Mathlib.Topology.Gluing
{α : Type u} [TopologicalSpace α] {J : Type u} (U : J → TopologicalSpace.Opens α) (i : J) (x : ↑((TopCat.GlueData.ofOpenSubsets U).U i)) : (CategoryTheory.ConcreteCategory.hom (TopCat.GlueData.fromOpenSubsetsGlue U)) ((CategoryTheory.ConcreteCategory.hom ((TopCat.GlueData.ofOpenSubsets U).ι i)) x) = (CategoryTheory.ConcreteCategory.hom (U i).inclusion') x
TopCat.GlueData.image_inter 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) (i j : D.J) : Set.range ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) ∩ Set.range ⇑(CategoryTheory.ConcreteCategory.hom (D.ι j)) = Set.range ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp (D.f i j) (D.ι i)))
TopCat.GlueData.eqvGen_of_π_eq 📋 Mathlib.Topology.Gluing
(D : TopCat.GlueData) {x y : ↑(∐ D.U)} (h : (CategoryTheory.ConcreteCategory.hom D.π) x = (CategoryTheory.ConcreteCategory.hom D.π) y) : Relation.EqvGen (Function.Coequalizer.Rel ⇑(CategoryTheory.ConcreteCategory.hom D.diagram.fstSigmaMap) ⇑(CategoryTheory.ConcreteCategory.hom D.diagram.sndSigmaMap)) x y
AlgebraicGeometry.LocallyRingedSpace.GlueData.isoSheafedSpace 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
(D : AlgebraicGeometry.LocallyRingedSpace.GlueData) : D.glued.toSheafedSpace ≅ D.toSheafedSpaceGlueData.glued
AlgebraicGeometry.SheafedSpace.GlueData.ιIsOpenImmersion 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.SheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i : D.J) : AlgebraicGeometry.SheafedSpace.IsOpenImmersion (D.ι i)
AlgebraicGeometry.SheafedSpace.GlueData.isoPresheafedSpace 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.SheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] : D.glued.toPresheafedSpace ≅ D.toPresheafedSpaceGlueData.glued
AlgebraicGeometry.PresheafedSpace.GlueData.ιIsOpenImmersion 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i : D.J) : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion (D.ι i)
AlgebraicGeometry.SheafedSpace.GlueData.vPullbackConeIsLimit 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.SheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j : D.J) : CategoryTheory.Limits.IsLimit (D.vPullbackCone i j)
AlgebraicGeometry.LocallyRingedSpace.GlueData.ι_isoSheafedSpace_inv 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
(D : AlgebraicGeometry.LocallyRingedSpace.GlueData) (i : D.J) : CategoryTheory.CategoryStruct.comp (D.toSheafedSpaceGlueData.ι i) D.isoSheafedSpace.inv = AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom (D.ι i)
AlgebraicGeometry.PresheafedSpace.GlueData.vPullbackConeIsLimit 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j : D.J) : CategoryTheory.Limits.IsLimit (D.vPullbackCone i j)
AlgebraicGeometry.LocallyRingedSpace.GlueData.ι_isoSheafedSpace_inv_assoc 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
(D : AlgebraicGeometry.LocallyRingedSpace.GlueData) (i : D.J) {Z : AlgebraicGeometry.SheafedSpace CommRingCat} (h : D.glued.toSheafedSpace ⟶ Z) : CategoryTheory.CategoryStruct.comp ((D.mapGlueData AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace).ι i) (CategoryTheory.CategoryStruct.comp D.isoSheafedSpace.inv h) = CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.Hom.toShHom (D.ι i)) h
AlgebraicGeometry.SheafedSpace.GlueData.ι_jointly_surjective 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.SheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (x : ↑↑D.glued.toPresheafedSpace) : ∃ i y, (CategoryTheory.ConcreteCategory.hom (D.ι i).hom.base) y = x
AlgebraicGeometry.SheafedSpace.GlueData.ι_isoPresheafedSpace_inv 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.SheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i : D.J) : CategoryTheory.CategoryStruct.comp (D.toPresheafedSpaceGlueData.ι i) D.isoPresheafedSpace.inv = (D.ι i).hom
AlgebraicGeometry.PresheafedSpace.GlueData.ι_isOpenEmbedding 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i : D.J) : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i).base)
AlgebraicGeometry.PresheafedSpace.GlueData.ι_jointly_surjective 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (x : ↑↑D.glued) : ∃ i y, (CategoryTheory.ConcreteCategory.hom (D.ι i).base) y = x
AlgebraicGeometry.PresheafedSpace.GlueData.opensImagePreimageMap 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j : D.J) (U : TopologicalSpace.Opens ↑↑(D.U i)) : (D.U i).presheaf.obj (Opposite.op U) ⟶ (D.U j).presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U)))
AlgebraicGeometry.PresheafedSpace.GlueData.ι_image_preimage_eq 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j : D.J) (U : TopologicalSpace.Opens ↑↑(D.U i)) : (TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U) = (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor (D.f j i)).obj ((TopologicalSpace.Opens.map (D.t j i).base).obj ((TopologicalSpace.Opens.map (D.f i j).base).obj U))
AlgebraicGeometry.PresheafedSpace.GlueData.opensImagePreimageMap_app' 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j k : D.J) (U : TopologicalSpace.Opens ↑↑(D.U i)) : ∃ (eq : Opposite.op ((AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.opensFunctor (CategoryTheory.Limits.pullback.snd (D.f j i) (D.f j k))).obj (Opposite.unop (Opposite.op ((TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).base).1 (Opposite.unop (Opposite.op U)))))) = (TopologicalSpace.Opens.map (D.f j k).base).op.obj (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U)))), CategoryTheory.CategoryStruct.comp (D.opensImagePreimageMap i j U) ((D.f j k).c.app (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U)))) = CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).c.app (Opposite.op U)) (CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f j i) (D.f j k)) (Opposite.unop (Opposite.op ((TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).base).1 (Opposite.unop (Opposite.op U)))))) ((D.V (j, k)).presheaf.map (CategoryTheory.eqToHom eq)))
AlgebraicGeometry.PresheafedSpace.GlueData.opensImagePreimageMap_app 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j k : D.J) (U : TopologicalSpace.Opens ↑↑(D.U i)) : CategoryTheory.CategoryStruct.comp (D.opensImagePreimageMap i j U) ((D.f j k).c.app (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U)))) = CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).c.app (Opposite.op U)) (CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f j i) (D.f j k)) (Opposite.unop (Opposite.op ((TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).base).1 (Opposite.unop (Opposite.op U)))))) ((D.V (j, k)).presheaf.map (CategoryTheory.eqToHom ⋯)))
AlgebraicGeometry.PresheafedSpace.GlueData.opensImagePreimageMap_app_assoc 📋 Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing
{C : Type u} [CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C) [CategoryTheory.Limits.HasLimits C] (i j k : D.J) (U : TopologicalSpace.Opens ↑↑(D.U i)) {X' : C} (f' : ((TopCat.Presheaf.pushforward C (D.f j k).base).obj (D.V (j, k)).presheaf).obj (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U))) ⟶ X') : CategoryTheory.CategoryStruct.comp (D.opensImagePreimageMap i j U) (CategoryTheory.CategoryStruct.comp ((D.f j k).c.app (Opposite.op ((TopologicalSpace.Opens.map (D.ι j).base).obj (⋯.functor.obj U)))) f') = CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).c.app (Opposite.op U)) (CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp (CategoryTheory.Limits.pullback.snd (D.f j i) (D.f j k)) (Opposite.unop (Opposite.op ((TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst (D.f j i) (D.f j k)) (CategoryTheory.CategoryStruct.comp (D.t j i) (D.f i j))).base).1 (Opposite.unop (Opposite.op U)))))) (CategoryTheory.CategoryStruct.comp ((D.V (j, k)).presheaf.map (CategoryTheory.eqToHom ⋯)) f'))
AlgebraicGeometry.Scheme.GlueData.isoCarrier 📋 Mathlib.AlgebraicGeometry.Gluing
(D : AlgebraicGeometry.Scheme.GlueData) : ↑D.glued.toPresheafedSpace ≅ D.toLocallyRingedSpaceGlueData.toSheafedSpaceGlueData.toPresheafedSpaceGlueData.toTopGlueData.glued
AlgebraicGeometry.Scheme.GlueData.ι_isoCarrier_inv 📋 Mathlib.AlgebraicGeometry.Gluing
(D : AlgebraicGeometry.Scheme.GlueData) (i : D.J) : CategoryTheory.CategoryStruct.comp (D.toLocallyRingedSpaceGlueData.toSheafedSpaceGlueData.toPresheafedSpaceGlueData.toTopGlueData.ι i) D.isoCarrier.inv = (D.ι i).base
CategoryTheory.Limits.MultispanIndex.map_left 📋 Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer
{C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape} (d : CategoryTheory.Limits.MultispanIndex J C) (F : CategoryTheory.Functor C D) (i : J.L) : (d.map F).left i = F.obj (d.left i)
CategoryTheory.Limits.MultispanIndex.map_fst 📋 Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer
{C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape} (d : CategoryTheory.Limits.MultispanIndex J C) (F : CategoryTheory.Functor C D) (i : J.L) : (d.map F).fst i = F.map (d.fst i)
CategoryTheory.Limits.MultispanIndex.map_snd 📋 Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer
{C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape} (d : CategoryTheory.Limits.MultispanIndex J C) (F : CategoryTheory.Functor C D) (i : J.L) : (d.map F).snd i = F.map (d.snd i)
CategoryTheory.Limits.MultispanIndex.multispanMapIso_hom_app 📋 Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer
{C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape} (d : CategoryTheory.Limits.MultispanIndex J C) (F : CategoryTheory.Functor C D) (X : CategoryTheory.Limits.WalkingMultispan J) : (d.multispanMapIso F).hom.app X = (match X with | CategoryTheory.Limits.WalkingMultispan.left a => CategoryTheory.Iso.refl (F.obj (d.left a)) | CategoryTheory.Limits.WalkingMultispan.right a => CategoryTheory.Iso.refl (F.obj (d.right a))).hom
CategoryTheory.Limits.MultispanIndex.multispanMapIso_inv_app 📋 Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer
{C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape} (d : CategoryTheory.Limits.MultispanIndex J C) (F : CategoryTheory.Functor C D) (X : CategoryTheory.Limits.WalkingMultispan J) : (d.multispanMapIso F).inv.app X = (match X with | CategoryTheory.Limits.WalkingMultispan.left a => CategoryTheory.Iso.refl (F.obj (d.left a)) | CategoryTheory.Limits.WalkingMultispan.right a => CategoryTheory.Iso.refl (F.obj (d.right a))).inv
CategoryTheory.Limits.Multicofork.map_ι_app 📋 Mathlib.CategoryTheory.Limits.Preserves.Shapes.Multiequalizer
{C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.Limits.MultispanShape} {d : CategoryTheory.Limits.MultispanIndex J C} (c : CategoryTheory.Limits.Multicofork d) (F : CategoryTheory.Functor C D) (x : CategoryTheory.Limits.WalkingMultispan J) : (c.map F).ι.app x = match x with | CategoryTheory.Limits.WalkingMultispan.left a => CategoryTheory.CategoryStruct.comp (F.map (d.fst a)) (F.map (c.π (J.fst a))) | CategoryTheory.Limits.WalkingMultispan.right a => F.map (c.π a)
CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork 📋 Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.Limits.MultispanShape} [Unique J.L] {I : CategoryTheory.Limits.MultispanIndex J C} (h : {J.fst default, J.snd default} = Set.univ) (h' : J.fst default ≠ J.snd default) (s : CategoryTheory.Limits.PushoutCocone (I.fst default) (I.snd default)) : CategoryTheory.Limits.Multicofork I
CategoryTheory.Limits.Multicofork.IsColimit.isPushout 📋 Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.Limits.MultispanShape} [Unique J.L] {I : CategoryTheory.Limits.MultispanIndex J C} (c : CategoryTheory.Limits.Multicofork I) (h : {J.fst default, J.snd default} = Set.univ) (h' : J.fst default ≠ J.snd default) (hc : CategoryTheory.Limits.IsColimit c) : CategoryTheory.IsPushout (I.fst default) (I.snd default) (c.π (J.fst default)) (c.π (J.snd default))
CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork_π_eq_inl 📋 Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.Limits.MultispanShape} [Unique J.L] {I : CategoryTheory.Limits.MultispanIndex J C} (h : {J.fst default, J.snd default} = Set.univ) (h' : J.fst default ≠ J.snd default) (s : CategoryTheory.Limits.PushoutCocone (I.fst default) (I.snd default)) : (CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork h h' s).π (J.fst default) = s.inl
CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork_π_eq_inr 📋 Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.Limits.MultispanShape} [Unique J.L] {I : CategoryTheory.Limits.MultispanIndex J C} (h : {J.fst default, J.snd default} = Set.univ) (h' : J.fst default ≠ J.snd default) (s : CategoryTheory.Limits.PushoutCocone (I.fst default) (I.snd default)) : (CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork h h' s).π (J.snd default) = s.inr
CompleteLattice.MulticoequalizerDiagram.multispanIndex_left 📋 Mathlib.Order.CompleteLattice.MulticoequalizerDiagram
{T : Type u} [CompleteLattice T] {ι : Type u_1} {x : T} {u : ι → T} {v : ι → ι → T} (d : CompleteLattice.MulticoequalizerDiagram x u v) (x✝ : (CategoryTheory.Limits.MultispanShape.prod ι).L) : d.multispanIndex.left x✝ = match x✝ with | (i, j) => v i j
CompleteLattice.MulticoequalizerDiagram.multispanIndex_fst 📋 Mathlib.Order.CompleteLattice.MulticoequalizerDiagram
{T : Type u} [CompleteLattice T] {ι : Type u_1} {x : T} {u : ι → T} {v : ι → ι → T} (d : CompleteLattice.MulticoequalizerDiagram x u v) (x✝ : (CategoryTheory.Limits.MultispanShape.prod ι).L) : d.multispanIndex.fst x✝ = CategoryTheory.homOfLE ⋯
CompleteLattice.MulticoequalizerDiagram.multispanIndex_snd 📋 Mathlib.Order.CompleteLattice.MulticoequalizerDiagram
{T : Type u} [CompleteLattice T] {ι : Type u_1} {x : T} {u : ι → T} {v : ι → ι → T} (d : CompleteLattice.MulticoequalizerDiagram x u v) (x✝ : (CategoryTheory.Limits.MultispanShape.prod ι).L) : d.multispanIndex.snd x✝ = CategoryTheory.homOfLE ⋯
CategoryTheory.Limits.multispanShapeCoend_L 📋 Mathlib.CategoryTheory.Limits.Shapes.End
(J : Type u) [CategoryTheory.Category.{v, u} J] : (CategoryTheory.Limits.multispanShapeCoend J).L = CategoryTheory.Arrow J
CategoryTheory.Limits.multispanIndexCoend_left 📋 Mathlib.CategoryTheory.Limits.Shapes.End
{J : Type u} [CategoryTheory.Category.{v, u} J] {C : Type u'} [CategoryTheory.Category.{v', u'} C] (F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)) (f : (CategoryTheory.Limits.multispanShapeCoend J).L) : (CategoryTheory.Limits.multispanIndexCoend F).left f = (F.obj (Opposite.op (CategoryTheory.Arrow.right f))).obj (CategoryTheory.Arrow.left f)
CategoryTheory.Limits.multispanIndexCoend_snd 📋 Mathlib.CategoryTheory.Limits.Shapes.End
{J : Type u} [CategoryTheory.Category.{v, u} J] {C : Type u'} [CategoryTheory.Category.{v', u'} C] (F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)) (f : (CategoryTheory.Limits.multispanShapeCoend J).L) : (CategoryTheory.Limits.multispanIndexCoend F).snd f = (F.obj (Opposite.op (CategoryTheory.Arrow.right f))).map (CategoryTheory.Arrow.hom f)
CategoryTheory.Limits.multispanIndexCoend_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.End
{J : Type u} [CategoryTheory.Category.{v, u} J] {C : Type u'} [CategoryTheory.Category.{v', u'} C] (F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)) (f : (CategoryTheory.Limits.multispanShapeCoend J).L) : (CategoryTheory.Limits.multispanIndexCoend F).fst f = (F.map (CategoryTheory.Arrow.hom f).op).app (CategoryTheory.Arrow.left f)
CategoryTheory.OrthogonalReflection.instSmallLMultispanShape 📋 Mathlib.CategoryTheory.Presentable.OrthogonalReflection
{C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C) [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁] [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] [CategoryTheory.Limits.HasPushouts C] [CategoryTheory.MorphismProperty.IsSmall.{w, v, u} W] [CategoryTheory.LocallySmall.{w, v, u} C] : Small.{w, max u v} (CategoryTheory.OrthogonalReflection.D₂.multispanShape W Z).L
CategoryTheory.OrthogonalReflection.D₂.multispanShape_L 📋 Mathlib.CategoryTheory.Presentable.OrthogonalReflection
{C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C) [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁] [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] [CategoryTheory.Limits.HasPushouts C] : (CategoryTheory.OrthogonalReflection.D₂.multispanShape W Z).L = CategoryTheory.OrthogonalReflection.D₂ W Z
CategoryTheory.OrthogonalReflection.D₂.multispanIndex_left 📋 Mathlib.CategoryTheory.Presentable.OrthogonalReflection
{C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C) [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁] [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] [CategoryTheory.Limits.HasPushouts C] (d : (CategoryTheory.OrthogonalReflection.D₂.multispanShape W Z).L) : (CategoryTheory.OrthogonalReflection.D₂.multispanIndex W Z).left d = (↑d.fst).right
CategoryTheory.OrthogonalReflection.D₂.multispanIndex_fst 📋 Mathlib.CategoryTheory.Presentable.OrthogonalReflection
{C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C) [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁] [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] [CategoryTheory.Limits.HasPushouts C] (d : (CategoryTheory.OrthogonalReflection.D₂.multispanShape W Z).L) : (CategoryTheory.OrthogonalReflection.D₂.multispanIndex W Z).fst d = (↑d.snd).1
CategoryTheory.OrthogonalReflection.D₂.multispanIndex_snd 📋 Mathlib.CategoryTheory.Presentable.OrthogonalReflection
{C : Type u} [CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (Z : C) [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁] [CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] [CategoryTheory.Limits.HasPushouts C] (d : (CategoryTheory.OrthogonalReflection.D₂.multispanShape W Z).L) : (CategoryTheory.OrthogonalReflection.D₂.multispanIndex W Z).snd d = (↑d.snd).2

About

Loogle searches Lean and Mathlib definitions and theorems.

You can use Loogle from within the Lean4 VSCode language extension using the Loogle command from the command palette. You can also try the #loogle command from LeanSearchClient, the CLI version, the Loogle VS Code extension, the lean.nvim integration or the Zulip bot.

Usage

Loogle finds definitions and lemmas in various ways:

By constant:
🔍 Real.sin
finds all lemmas whose statement somehow mentions the sine function.
By lemma name substring:
🔍 "differ"
finds all lemmas that have "differ" somewhere in their lemma name.
By subexpression:
🔍 _ * (_ ^ _)
finds all lemmas whose statements somewhere include a product where the second argument is raised to some power.

The pattern can also be non-linear, as in
🔍 Real.sqrt ?a * Real.sqrt ?a

If the pattern has parameters, they are matched in any order. Both of these will find List.map:
🔍 (?a -> ?b) -> List ?a -> List ?b
🔍 List ?a -> (?a -> ?b) -> List ?b
By main conclusion:
🔍 |- tsum _ = _ * tsum _
finds all lemmas where the conclusion (the subexpression to the right of all → and ∀) has the given shape.

As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍 |- _ < _ → tsum _ < tsum _
will find tsum_lt_tsum even though the hypothesis f i < g i is not the last.
You can filter for definitions vs theorems: Using ⊢ (_ : Type _) finds all definitions which provide data while ⊢ (_ : Prop) finds all theorems (and definitions of proofs).

If you pass more than one such search filter, separated by commas Loogle will return lemmas which match all of them. The search
🔍 Real.sin, "two", tsum, _ * _, _ ^ _, |- _ < _ → _
would find all lemmas which mention the constants Real.sin and tsum, have "two" as a substring of the lemma name, include a product and a power somewhere in the type, and have a hypothesis of the form _ < _ (if there were any such lemmas). Metavariables (?a) are assigned independently in each filter.

The #lucky button will directly send you to the documentation of the first hit.

Source code

You can find the source code for this service at https://github.com/nomeata/loogle. The https://loogle.lean-lang.org/ service is provided by the Lean FRO. Please review the Lean FRO Terms of Use and Privacy Policy.

This is Loogle revision 9f11169 serving mathlib revision ce5dd8c