Loogle!

Result

Found 44 declarations mentioning CategoryTheory.Limits.MultispanShape.fst.

• CategoryTheory.Limits.MultispanShape.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (self : CategoryTheory.Limits.MultispanShape) : self.L → self.R
• 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.MultispanShape.prod_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (ι : Type w) (self : ι × ι) : (CategoryTheory.Limits.MultispanShape.prod ι).fst self = self.1
• 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.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.SymmStruct.fst_eq_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} (self : I.SymmStruct) (i : ι) : I.fst (i, i) = I.snd (i, i)
• 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.MultispanShape.ofLinearOrder_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (ι : Type w) [LinearOrder ι] (x : ↑{x | x.1 < x.2}) : (CategoryTheory.Limits.MultispanShape.ofLinearOrder ι).fst x = (↑x).1
• 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.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.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.MultispanIndex.SymmStruct.iso_hom_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} (self : I.SymmStruct) (i j : ι) : CategoryTheory.CategoryStruct.comp (self.iso i j).hom (I.fst (j, i)) = I.snd (i, j)
• 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.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.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.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.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.SymmStruct.iso_hom_fst_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type w} {I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C} (self : I.SymmStruct) (i j : ι) {Z : C} (h : I.right ((CategoryTheory.Limits.MultispanShape.prod ι).fst (j, i)) ⟶ Z) : CategoryTheory.CategoryStruct.comp (self.iso i j).hom (CategoryTheory.CategoryStruct.comp (I.fst (j, i)) h) = CategoryTheory.CategoryStruct.comp (I.snd (i, j)) h
• 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.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.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.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.SymmStruct.mk 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {ι : Type w} {I : CategoryTheory.Limits.MultispanIndex (CategoryTheory.Limits.MultispanShape.prod ι) C} (iso : (i j : ι) → I.left (i, j) ≅ I.left (j, i)) (iso_hom_fst : ∀ (i j : ι), CategoryTheory.CategoryStruct.comp (iso i j).hom (I.fst (j, i)) = I.snd (i, j)) (iso_hom_snd : ∀ (i j : ι), CategoryTheory.CategoryStruct.comp (iso i j).hom (I.snd (j, i)) = I.fst (i, j)) (fst_eq_snd : ∀ (i : ι), I.fst (i, i) = I.snd (i, i)) : I.SymmStruct
• 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.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.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.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.GlueData.diagram_fst 📋 Mathlib.CategoryTheory.GlueData
  {C : Type u₁} [CategoryTheory.Category.{v, u₁} C] (D : CategoryTheory.GlueData C) (i j : D.J) : D.diagram.fst (i, j) = D.f i j
• 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.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_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 ⋯
• CategoryTheory.Limits.multispanShapeCoend_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.End
  (J : Type u) [CategoryTheory.Category.{v, u} J] (f : CategoryTheory.Arrow J) : (CategoryTheory.Limits.multispanShapeCoend J).fst f = f.left
• CategoryTheory.OrthogonalReflection.D₂.multispanShape_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] (x✝ : CategoryTheory.OrthogonalReflection.D₂ W Z) : (CategoryTheory.OrthogonalReflection.D₂.multispanShape W Z).fst x✝ = ()

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:

1. By constant:
   🔍 Real.sin
   finds all lemmas whose statement somehow mentions the sine function.

2. By lemma name substring:
   🔍 "differ"
   finds all lemmas that have "differ" somewhere in their lemma name.

3. 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

4. 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.

5. 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