Loogle!

Result

Found 133 declarations mentioning CategoryTheory.Limits.MulticospanShape.R.

• CategoryTheory.Limits.MulticospanShape.R 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (self : CategoryTheory.Limits.MulticospanShape) : Type w'
• CategoryTheory.Limits.MulticospanShape.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (self : CategoryTheory.Limits.MulticospanShape) : self.R → self.L
• CategoryTheory.Limits.MulticospanShape.snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (self : CategoryTheory.Limits.MulticospanShape) : self.R → self.L
• CategoryTheory.Limits.WalkingMulticospan.right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} : J.R → CategoryTheory.Limits.WalkingMulticospan J
• CategoryTheory.Limits.MulticospanShape.prod_R 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  (ι : Type w) : (CategoryTheory.Limits.MulticospanShape.prod ι).R = (ι × ι)
• CategoryTheory.Limits.MulticospanIndex.right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Limits.MulticospanIndex J C) : J.R → C
• CategoryTheory.Limits.WalkingMulticospan.Hom.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} (b : J.R) : (CategoryTheory.Limits.WalkingMulticospan.left (J.fst b)).Hom (CategoryTheory.Limits.WalkingMulticospan.right b)
• CategoryTheory.Limits.WalkingMulticospan.Hom.snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} (b : J.R) : (CategoryTheory.Limits.WalkingMulticospan.left (J.snd b)).Hom (CategoryTheory.Limits.WalkingMulticospan.right b)
• CategoryTheory.Limits.MulticospanIndex.fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Limits.MulticospanIndex J C) (b : J.R) : self.left (J.fst b) ⟶ self.right b
• CategoryTheory.Limits.MulticospanIndex.snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (self : CategoryTheory.Limits.MulticospanIndex J C) (b : J.R) : self.left (J.snd b) ⟶ self.right b
• CategoryTheory.Limits.MulticospanIndex.multicospan_obj_right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (b : J.R) : I.multicospan.obj (CategoryTheory.Limits.WalkingMulticospan.right b) = I.right b
• CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C
• CategoryTheory.Limits.MulticospanIndex.ofParallelHoms_right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape) {X Y : C} (f g : X ⟶ Y) (x✝ : J.R) : (CategoryTheory.Limits.MulticospanIndex.ofParallelHoms J f g).right x✝ = Y
• CategoryTheory.Limits.MulticospanIndex.mk 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u} [CategoryTheory.Category.{v, u} C] (left : J.L → C) (right : J.R → C) (fst : (b : J.R) → left (J.fst b) ⟶ right b) (snd : (b : J.R) → left (J.snd b) ⟶ right b) : CategoryTheory.Limits.MulticospanIndex J C
• CategoryTheory.Limits.MulticospanIndex.ofParallelHoms_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape) {X Y : C} (f g : X ⟶ Y) (x✝ : J.R) : (CategoryTheory.Limits.MulticospanIndex.ofParallelHoms J f g).fst x✝ = f
• CategoryTheory.Limits.MulticospanIndex.ofParallelHoms_snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape) {X Y : C} (f g : X ⟶ Y) (x✝ : J.R) : (CategoryTheory.Limits.MulticospanIndex.ofParallelHoms J f g).snd x✝ = g
• CategoryTheory.Limits.MulticospanIndex.parallelPairDiagramOfIsLimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : CategoryTheory.Functor CategoryTheory.Limits.WalkingParallelPair C
• CategoryTheory.Limits.MulticospanIndex.fstPiMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : ∏ᶜ I.left ⟶ ∏ᶜ I.right
• CategoryTheory.Limits.MulticospanIndex.sndPiMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : ∏ᶜ I.left ⟶ ∏ᶜ I.right
• CategoryTheory.Limits.Multiequalizer.ιPi 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : CategoryTheory.Limits.multiequalizer I ⟶ ∏ᶜ I.left
• CategoryTheory.Limits.Multiequalizer.instMonoιPi 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : CategoryTheory.Mono (CategoryTheory.Limits.Multiequalizer.ιPi I)
• CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (x : CategoryTheory.Limits.WalkingParallelPair) : I.parallelPairDiagram.obj x = CategoryTheory.Limits.parallelPair.parallelPairObj (∏ᶜ I.left) (∏ᶜ I.right) x
• CategoryTheory.Limits.Multiequalizer.instHasEqualizerFstPiMapSndPiMap 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : CategoryTheory.Limits.HasEqualizer I.fstPiMap I.sndPiMap
• CategoryTheory.Limits.MulticospanIndex.multicospan_map_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (a : J.R) : I.multicospan.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst a) = I.fst a
• CategoryTheory.Limits.MulticospanIndex.multicospan_map_snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (a : J.R) : I.multicospan.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd a) = I.snd a
• CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape) [Unique J.L] [Unique J.R] {X Y : C} (f g : X ⟶ Y) : CategoryTheory.Limits.Multifork (CategoryTheory.Limits.MulticospanIndex.ofParallelHoms J f g) ≌ CategoryTheory.Limits.Fork f g
• CategoryTheory.Limits.Multiequalizer.isoEqualizer 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : CategoryTheory.Limits.multiequalizer I ≅ CategoryTheory.Limits.equalizer I.fstPiMap I.sndPiMap
• CategoryTheory.Limits.MulticospanIndex.fstPiMapOfIsLimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : c.pt ⟶ d.pt
• CategoryTheory.Limits.MulticospanIndex.sndPiMapOfIsLimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : c.pt ⟶ d.pt
• CategoryTheory.Limits.Multifork.ofι 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (P : C) (ι : (a : J.L) → P ⟶ I.left a) (w : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (ι (J.snd b)) (I.snd b)) : CategoryTheory.Limits.Multifork I
• CategoryTheory.Limits.MulticospanIndex.parallelPairDiagramOfIsLimit_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (x : CategoryTheory.Limits.WalkingParallelPair) : (I.parallelPairDiagramOfIsLimit c hd).obj x = CategoryTheory.Limits.parallelPair.parallelPairObj c.pt d.pt x
• CategoryTheory.Limits.Multiequalizer.ιPi_π 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (a : J.L) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ιPi I) (CategoryTheory.Limits.Pi.π I.left a) = CategoryTheory.Limits.Multiequalizer.ι I a
• CategoryTheory.Limits.Multifork.ofPiFork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} {hd : CategoryTheory.Limits.IsLimit d} (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)) : CategoryTheory.Limits.Multifork I
• CategoryTheory.Limits.Multiequalizer.condition 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] (b : J.R) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (J.snd b)) (I.snd b)
• CategoryTheory.Limits.Multiequalizer.lift 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] (W : C) (k : (a : J.L) → W ⟶ I.left a) (h : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b)) : W ⟶ CategoryTheory.Limits.multiequalizer I
• CategoryTheory.Limits.Multifork.ofι_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (P : C) (ι : (a : J.L) → P ⟶ I.left a) (w : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (ι (J.snd b)) (I.snd b)) : (CategoryTheory.Limits.Multifork.ofι I P ι w).pt = P
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] : CategoryTheory.Limits.Multifork I ≌ CategoryTheory.Limits.Fork I.fstPiMap I.sndPiMap
• CategoryTheory.Limits.Multifork.toPiFork 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (K : CategoryTheory.Limits.Multifork I) : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)
• CategoryTheory.Limits.Multifork.condition 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) (b : J.R) : CategoryTheory.CategoryStruct.comp (K.ι (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (K.ι (J.snd b)) (I.snd b)
• CategoryTheory.Limits.Multifork.IsLimit.lift 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {K : CategoryTheory.Limits.Multifork I} (hK : CategoryTheory.Limits.IsLimit K) {T : C} (k : (a : J.L) → T ⟶ I.left a) (hk : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b)) : T ⟶ K.pt
• CategoryTheory.Limits.MulticospanIndex.parallelPairDiagram_map 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] {X✝ Y✝ : CategoryTheory.Limits.WalkingParallelPair} (h : X✝ ⟶ Y✝) : I.parallelPairDiagram.map h = CategoryTheory.Limits.parallelPair.parallelPairHom I.fstPiMap I.sndPiMap h
• CategoryTheory.Limits.Multifork.ι_ofι 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (P : C) (ι : (a : J.L) → P ⟶ I.left a) (w : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (ι (J.snd b)) (I.snd b)) (i : J.L) : (CategoryTheory.Limits.Multifork.ofι I P ι w).ι i = ι i
• CategoryTheory.Limits.MulticospanIndex.fstPiMap_π 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (b : J.R) : CategoryTheory.CategoryStruct.comp I.fstPiMap (CategoryTheory.Limits.Pi.π I.right b) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (J.fst b)) (I.fst b)
• CategoryTheory.Limits.MulticospanIndex.sndPiMap_π 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (b : J.R) : CategoryTheory.CategoryStruct.comp I.sndPiMap (CategoryTheory.Limits.Pi.π I.right b) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (J.snd b)) (I.snd b)
• CategoryTheory.Limits.Multiequalizer.condition_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] (b : J.R) {Z : C} (h : I.right b ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (J.fst b)) (CategoryTheory.CategoryStruct.comp (I.fst b) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I (J.snd b)) (CategoryTheory.CategoryStruct.comp (I.snd b) h)
• CategoryTheory.Limits.Multiequalizer.ιPi_π_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (a : J.L) {Z : C} (h : I.left a ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ιPi I) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left a) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I a) h
• CategoryTheory.Limits.Multiequalizer.lift_ι 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] (W : C) (k : (a : J.L) → W ⟶ I.left a) (h : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b)) (a : J.L) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.lift I W k h) (CategoryTheory.Limits.Multiequalizer.ι I a) = k a
• CategoryTheory.Limits.Multifork.toPiFork_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (K : CategoryTheory.Limits.Multifork I) : (CategoryTheory.Limits.Multifork.toPiFork hc hd K).pt = K.pt
• CategoryTheory.Limits.Multifork.condition_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) (b : J.R) {Z : C} (h : I.right b ⟶ Z) : CategoryTheory.CategoryStruct.comp (K.ι (J.fst b)) (CategoryTheory.CategoryStruct.comp (I.fst b) h) = CategoryTheory.CategoryStruct.comp (K.ι (J.snd b)) (CategoryTheory.CategoryStruct.comp (I.snd b) h)
• CategoryTheory.Limits.Multifork.IsLimit.fac 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {K : CategoryTheory.Limits.Multifork I} (hK : CategoryTheory.Limits.IsLimit K) {T : C} (k : (a : J.L) → T ⟶ I.left a) (hk : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b)) (a : J.L) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.IsLimit.lift hK k hk) (K.ι a) = k a
• CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : CategoryTheory.Functor (CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)) (CategoryTheory.Limits.Multifork I)
• CategoryTheory.Limits.Multifork.ofPiFork_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} {hd : CategoryTheory.Limits.IsLimit d} (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)) : (CategoryTheory.Limits.Multifork.ofPiFork a).pt = a.pt
• CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_fst 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) (b : J.R) : K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) = CategoryTheory.CategoryStruct.comp (K.ι (J.fst b)) (I.fst b)
• CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_snd 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) (b : J.R) : K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b) = CategoryTheory.CategoryStruct.comp (K.ι (J.snd b)) (I.snd b)
• CategoryTheory.Limits.Multiequalizer.lift_ι_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] (W : C) (k : (a : J.L) → W ⟶ I.left a) (h : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b)) (a : J.L) {Z : C} (h✝ : I.left a ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.lift I W k h) (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I a) h✝) = CategoryTheory.CategoryStruct.comp (k a) h✝
• CategoryTheory.Limits.MulticospanIndex.fstPiMap_π_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (b : J.R) {Z : C} (h : I.right b ⟶ Z) : CategoryTheory.CategoryStruct.comp I.fstPiMap (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.right b) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (J.fst b)) (CategoryTheory.CategoryStruct.comp (I.fst b) h)
• CategoryTheory.Limits.MulticospanIndex.sndPiMap_π_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (b : J.R) {Z : C} (h : I.right b ⟶ Z) : CategoryTheory.CategoryStruct.comp I.sndPiMap (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.right b) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.π I.left (J.snd b)) (CategoryTheory.CategoryStruct.comp (I.snd b) h)
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiForkOfIsLimit 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : CategoryTheory.Limits.Multifork I ≌ CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)
• CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : CategoryTheory.Functor (CategoryTheory.Limits.Multifork I) (CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd))
• CategoryTheory.Limits.MulticospanIndex.fstPiMapOfIsLimit_proj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (i : J.R) : CategoryTheory.CategoryStruct.comp (I.fstPiMapOfIsLimit c hd) (d.proj i) = CategoryTheory.CategoryStruct.comp (c.proj (J.fst i)) (I.fst i)
• CategoryTheory.Limits.MulticospanIndex.sndPiMapOfIsLimit_proj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (i : J.R) : CategoryTheory.CategoryStruct.comp (I.sndPiMapOfIsLimit c hd) (d.proj i) = CategoryTheory.CategoryStruct.comp (c.proj (J.snd i)) (I.snd i)
• CategoryTheory.Limits.Multifork.IsLimit.fac_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {K : CategoryTheory.Limits.Multifork I} (hK : CategoryTheory.Limits.IsLimit K) {T : C} (k : (a : J.L) → T ⟶ I.left a) (hk : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b)) (a : J.L) {Z : C} (h : I.left a ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multifork.IsLimit.lift hK k hk) (CategoryTheory.CategoryStruct.comp (K.ι a) h) = CategoryTheory.CategoryStruct.comp (k a) h
• CategoryTheory.Limits.MulticospanIndex.parallelPairDiagramOfIsLimit_map 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) {X✝ Y✝ : CategoryTheory.Limits.WalkingParallelPair} (h : X✝ ⟶ Y✝) : (I.parallelPairDiagramOfIsLimit c hd).map h = CategoryTheory.Limits.parallelPair.parallelPairHom (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd) h
• CategoryTheory.Limits.MulticospanIndex.fstPiMapOfIsLimit_proj_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (i : J.R) {Z : C} (h : I.right i ⟶ Z) : CategoryTheory.CategoryStruct.comp (I.fstPiMapOfIsLimit c hd) (CategoryTheory.CategoryStruct.comp (d.proj i) h) = CategoryTheory.CategoryStruct.comp (c.proj (J.fst i)) (CategoryTheory.CategoryStruct.comp (I.fst i) h)
• CategoryTheory.Limits.MulticospanIndex.sndPiMapOfIsLimit_proj_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (c : CategoryTheory.Limits.Fan I.left) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (i : J.R) {Z : C} (h : I.right i ⟶ Z) : CategoryTheory.CategoryStruct.comp (I.sndPiMapOfIsLimit c hd) (CategoryTheory.CategoryStruct.comp (d.proj i) h) = CategoryTheory.CategoryStruct.comp (c.proj (J.snd i)) (CategoryTheory.CategoryStruct.comp (I.snd i) h)
• CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)) : (I.ofPiForkFunctor hd).obj a = CategoryTheory.Limits.Multifork.ofPiFork a
• CategoryTheory.Limits.Multifork.toPiFork_π_app_zero 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : (CategoryTheory.Limits.Multifork.toPiFork hc hd K).ι = CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι
• CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_obj 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (K : CategoryTheory.Limits.Multifork I) : (I.toPiForkFunctor hc hd).obj K = CategoryTheory.Limits.Multifork.toPiFork hc hd K
• CategoryTheory.Limits.Multifork.pi_condition 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι) (I.fstPiMapOfIsLimit c hd) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι) (I.sndPiMapOfIsLimit c hd)
• CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork_functor_obj_ι 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape) [Unique J.L] [Unique J.R] {X Y : C} (f g : X ⟶ Y) (c : CategoryTheory.Limits.Multifork (CategoryTheory.Limits.MulticospanIndex.ofParallelHoms J f g)) : ((CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork J f g).functor.obj c).ι = c.ι default
• CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork_inverse_obj_ι 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape) [Unique J.L] [Unique J.R] {X Y : C} (f g : X ⟶ Y) (c : CategoryTheory.Limits.Fork f g) (a : J.L) : ((CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork J f g).inverse.obj c).ι a = c.ι
• CategoryTheory.Limits.Multifork.ofPiFork_ι 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)) (i : J.L) : (CategoryTheory.Limits.Multifork.ofPiFork a).ι i = CategoryTheory.CategoryStruct.comp a.ι (c.proj i)
• CategoryTheory.Limits.Multifork.app_right_eq_ι_comp_snd_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) (b : J.R) {Z : C} (h : I.multicospan.obj (CategoryTheory.Limits.WalkingMulticospan.right b) ⟶ Z) : CategoryTheory.CategoryStruct.comp (K.π.app (CategoryTheory.Limits.WalkingMulticospan.right b)) h = CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (K.ι (J.snd b)) (I.snd b)) h
• CategoryTheory.Limits.Multifork.ofι_π_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) (P : C) (ι : (a : J.L) → P ⟶ I.left a) (w : ∀ (b : J.R), CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b) = CategoryTheory.CategoryStruct.comp (ι (J.snd b)) (I.snd b)) (x : CategoryTheory.Limits.WalkingMulticospan J) : (CategoryTheory.Limits.Multifork.ofι I P ι w).π.app x = match x with | CategoryTheory.Limits.WalkingMulticospan.left a => ι a | CategoryTheory.Limits.WalkingMulticospan.right b => CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b)
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiForkOfIsLimit_inverse 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : (I.multiforkEquivPiForkOfIsLimit hc hd).inverse = I.ofPiForkFunctor hd
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiForkOfIsLimit_functor 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : (I.multiforkEquivPiForkOfIsLimit hc hd).functor = I.toPiForkFunctor hc hd
• CategoryTheory.Limits.Multifork.pi_condition_assoc 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) {Z : C} (h : d.pt ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι) (CategoryTheory.CategoryStruct.comp (I.fstPiMapOfIsLimit c hd) h) = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι) (CategoryTheory.CategoryStruct.comp (I.sndPiMapOfIsLimit c hd) h)
• CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) {K₁ K₂ : CategoryTheory.Limits.Multifork I} (f : K₁ ⟶ K₂) : ((I.toPiForkFunctor hc hd).map f).hom = f.hom
• CategoryTheory.Limits.Multifork.ofPiFork_π_app_right 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)) (i : J.R) : (CategoryTheory.Limits.Multifork.ofPiFork a).π.app (CategoryTheory.Limits.WalkingMulticospan.right i) = CategoryTheory.CategoryStruct.comp a.ι (CategoryTheory.CategoryStruct.comp (I.fstPiMapOfIsLimit c hd) (d.proj i))
• CategoryTheory.Limits.WalkingMulticospan.functor_ext 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C} (left : ∀ (i : J.L), F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) = G.obj (CategoryTheory.Limits.WalkingMulticospan.left i)) (right : ∀ (i : J.R), F.obj (CategoryTheory.Limits.WalkingMulticospan.right i) = G.obj (CategoryTheory.Limits.WalkingMulticospan.right i)) (wl : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) (CategoryTheory.eqToHom ⋯) = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i))) (wr : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) (CategoryTheory.eqToHom ⋯) = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i))) : F = G
• CategoryTheory.Limits.WalkingMulticospan.functorExt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C} (left : (i : J.L) → F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMulticospan.left i)) (right : (i : J.R) → F.obj (CategoryTheory.Limits.WalkingMulticospan.right i) ≅ G.obj (CategoryTheory.Limits.WalkingMulticospan.right i)) (wl : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) (right i).hom = CategoryTheory.CategoryStruct.comp (left (J.fst i)).hom (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) := by cat_disch) (wr : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) (right i).hom = CategoryTheory.CategoryStruct.comp (left (J.snd i)).hom (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) := by cat_disch) : F ≅ G
• CategoryTheory.Limits.Multifork.isLimitEquivOfIsos 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I I' : CategoryTheory.Limits.MulticospanIndex J C} (c : CategoryTheory.Limits.Multifork I) (c' : CategoryTheory.Limits.Multifork I') (e : c.pt ≅ c'.pt) (el : (i : J.L) → I.left i ≅ I'.left i) (er : (i : J.R) → I.right i ≅ I'.right i) (hl : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (I.fst i) (er i).hom = CategoryTheory.CategoryStruct.comp (el (J.fst i)).hom (I'.fst i) := by cat_disch) (hr : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (I.snd i) (er i).hom = CategoryTheory.CategoryStruct.comp (el (J.snd i)).hom (I'.snd i) := by cat_disch) (he : ∀ (i : J.L), CategoryTheory.CategoryStruct.comp e.hom (c'.ι i) = CategoryTheory.CategoryStruct.comp (c.ι i) (el i).hom := by cat_disch) : CategoryTheory.Limits.IsLimit c ≃ CategoryTheory.Limits.IsLimit c'
• CategoryTheory.Limits.Multifork.toPiFork_π_app_one 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J C} (K : CategoryTheory.Limits.Multifork I) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : (CategoryTheory.Limits.Multifork.toPiFork hc hd K).π.app CategoryTheory.Limits.WalkingParallelPair.one = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift hc K.ι) (I.fstPiMapOfIsLimit c hd)
• CategoryTheory.Limits.WalkingMulticospan.functorExt_hom_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C} (left : (i : J.L) → F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMulticospan.left i)) (right : (i : J.R) → F.obj (CategoryTheory.Limits.WalkingMulticospan.right i) ≅ G.obj (CategoryTheory.Limits.WalkingMulticospan.right i)) (wl : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) (right i).hom = CategoryTheory.CategoryStruct.comp (left (J.fst i)).hom (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) := by cat_disch) (wr : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) (right i).hom = CategoryTheory.CategoryStruct.comp (left (J.snd i)).hom (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) := by cat_disch) (X : CategoryTheory.Limits.WalkingMulticospan J) : (CategoryTheory.Limits.WalkingMulticospan.functorExt left right wl wr).hom.app X = (match X with | CategoryTheory.Limits.WalkingMulticospan.left i => left i | CategoryTheory.Limits.WalkingMulticospan.right i => right i).hom
• CategoryTheory.Limits.WalkingMulticospan.functorExt_inv_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C} (left : (i : J.L) → F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) ≅ G.obj (CategoryTheory.Limits.WalkingMulticospan.left i)) (right : (i : J.R) → F.obj (CategoryTheory.Limits.WalkingMulticospan.right i) ≅ G.obj (CategoryTheory.Limits.WalkingMulticospan.right i)) (wl : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) (right i).hom = CategoryTheory.CategoryStruct.comp (left (J.fst i)).hom (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.fst i)) := by cat_disch) (wr : ∀ (i : J.R), CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) (right i).hom = CategoryTheory.CategoryStruct.comp (left (J.snd i)).hom (G.map (CategoryTheory.Limits.WalkingMulticospan.Hom.snd i)) := by cat_disch) (X : CategoryTheory.Limits.WalkingMulticospan J) : (CategoryTheory.Limits.WalkingMulticospan.functorExt left right wl wr).inv.app X = (match X with | CategoryTheory.Limits.WalkingMulticospan.left i => left i | CategoryTheory.Limits.WalkingMulticospan.right i => right i).inv
• CategoryTheory.Limits.MulticospanIndex.ofPiForkFunctor_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) {K₁ K₂ : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit c hd) (I.sndPiMapOfIsLimit c hd)} (f : K₁ ⟶ K₂) : ((I.ofPiForkFunctor hd).map f).hom = f.hom
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor_obj_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (K : CategoryTheory.Limits.Multifork I) : (I.multiforkEquivPiFork.functor.obj K).pt = K.pt
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_obj_pt 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right))) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))) : (I.multiforkEquivPiFork.inverse.obj a).pt = a.pt
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multifork I} (f : K₁ ⟶ K₂) : (I.multiforkEquivPiFork.functor.map f).hom = f.hom
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiForkOfIsLimit_unitIso 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : (I.multiforkEquivPiForkOfIsLimit hc hd).unitIso = CategoryTheory.NatIso.ofComponents (fun K => CategoryTheory.Limits.Cone.ext (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Multifork I)).obj K).pt) ⋯) ⋯
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor_obj_π_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (K : CategoryTheory.Limits.Multifork I) (X : CategoryTheory.Limits.WalkingParallelPair) : (I.multiforkEquivPiFork.functor.obj K).π.app X = CategoryTheory.Limits.WalkingParallelPair.rec (motive := fun t => X = t → (K.pt ⟶ (CategoryTheory.Limits.parallelPair (I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right))) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))).obj X)) (fun h => ⋯ ▸ CategoryTheory.Limits.Fan.IsLimit.lift (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.left)) K.ι) (fun h => ⋯ ▸ CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.IsLimit.lift (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.left)) K.ι) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))) X ⋯
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_obj_π_app 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (a : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right))) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))) (x✝ : CategoryTheory.Limits.WalkingMulticospan J) : (I.multiforkEquivPiFork.inverse.obj a).π.app x✝ = match x✝ with | CategoryTheory.Limits.WalkingMulticospan.left a_1 => CategoryTheory.CategoryStruct.comp a.ι (CategoryTheory.Limits.Fan.proj (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) a_1) | CategoryTheory.Limits.WalkingMulticospan.right a_1 => CategoryTheory.CategoryStruct.comp a.ι (CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fan.proj (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (J.fst a_1)) (I.fst a_1))
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_inverse_map_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right))) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))} (f : K₁ ⟶ K₂) : (I.multiforkEquivPiFork.inverse.map f).hom = f.hom
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_unitIso_hom_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (X : CategoryTheory.Limits.Multifork I) : (I.multiforkEquivPiFork.unitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_unitIso_inv_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (X : CategoryTheory.Limits.Multifork I) : (I.multiforkEquivPiFork.unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiForkOfIsLimit_counitIso 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left} (hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d) : (I.multiforkEquivPiForkOfIsLimit hc hd).counitIso = CategoryTheory.NatIso.ofComponents (fun K => CategoryTheory.Limits.Fork.ext (CategoryTheory.Iso.refl (((I.ofPiForkFunctor hd).comp (I.toPiForkFunctor hc hd)).obj K).pt) ⋯) ⋯
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_counitIso_hom_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (X : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right))) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))) : (I.multiforkEquivPiFork.counitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt
• CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_counitIso_inv_app_hom 📋 Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer
  {C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasProduct I.left] [CategoryTheory.Limits.HasProduct I.right] (X : CategoryTheory.Limits.Fork (I.fstPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right))) (I.sndPiMapOfIsLimit (CategoryTheory.Limits.limit.cone (CategoryTheory.Discrete.functor I.left)) (CategoryTheory.Limits.limit.isLimit (CategoryTheory.Discrete.functor I.right)))) : (I.multiforkEquivPiFork.counitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt
• CategoryTheory.Limits.Concrete.multiequalizerEquiv 📋 Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory
  {C : Type u} [CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type s} [(X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [CategoryTheory.ConcreteCategory C FC] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.PreservesLimit I.multicospan (CategoryTheory.forget C)] : CategoryTheory.ToType (CategoryTheory.Limits.multiequalizer I) ≃ { x // ∀ (i : J.R), (CategoryTheory.ConcreteCategory.hom (I.fst i)) (x (J.fst i)) = (CategoryTheory.ConcreteCategory.hom (I.snd i)) (x (J.snd i)) }
• CategoryTheory.Limits.Concrete.multiequalizerEquivAux 📋 Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory
  {C : Type u} [CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type s} [(X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [CategoryTheory.ConcreteCategory C FC] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) : ↑(I.multicospan.comp (CategoryTheory.forget C)).sections ≃ { x // ∀ (i : J.R), (CategoryTheory.ConcreteCategory.hom (I.fst i)) (x (J.fst i)) = (CategoryTheory.ConcreteCategory.hom (I.snd i)) (x (J.snd i)) }
• CategoryTheory.Limits.Concrete.multiequalizerEquiv_apply 📋 Mathlib.CategoryTheory.Limits.Shapes.ConcreteCategory
  {C : Type u} [CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type s} [(X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [CategoryTheory.ConcreteCategory C FC] {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J C) [CategoryTheory.Limits.HasMultiequalizer I] [CategoryTheory.Limits.PreservesLimit I.multicospan (CategoryTheory.forget C)] (x : CategoryTheory.ToType (CategoryTheory.Limits.multiequalizer I)) (i : J.L) : ↑((CategoryTheory.Limits.Concrete.multiequalizerEquiv I) x) i = (CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.Multiequalizer.ι I i)) x
• CategoryTheory.GrothendieckTopology.Cover.shape_R 📋 Mathlib.CategoryTheory.Sites.Grothendieck
  {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} (S : J.Cover X) : S.shape.R = S.Relation
• CategoryTheory.GrothendieckTopology.Cover.index_right 📋 Mathlib.CategoryTheory.Sites.Grothendieck
  {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.shape.R) : (S.index P).right I = P.obj (Opposite.op I.r.Z)
• CategoryTheory.GrothendieckTopology.Cover.index_fst 📋 Mathlib.CategoryTheory.Sites.Grothendieck
  {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.shape.R) : (S.index P).fst I = P.map I.r.g₁.op
• CategoryTheory.GrothendieckTopology.Cover.index_snd 📋 Mathlib.CategoryTheory.Sites.Grothendieck
  {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C} {D : Type u₁} [CategoryTheory.Category.{v₁, u₁} D] (S : J.Cover X) (P : CategoryTheory.Functor Cᵒᵖ D) (I : S.shape.R) : (S.index P).snd I = P.map I.r.g₂.op
• CategoryTheory.GrothendieckTopology.diagramNatTrans_app 📋 Mathlib.CategoryTheory.Sites.Plus
  {C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w} [CategoryTheory.Category.{w', w} D] [∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)] {P Q : CategoryTheory.Functor Cᵒᵖ D} (η : P ⟶ Q) (X : C) (W : (J.Cover X)ᵒᵖ) : (J.diagramNatTrans η X).app W = CategoryTheory.Limits.Multiequalizer.lift ((Opposite.unop W).index Q) ((J.diagram P X).obj W) (fun x => CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι ((Opposite.unop W).index P) x) (η.app (Opposite.op x.Y))) ⋯
• CategoryTheory.PreOneHypercover.multicospanShape_R 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) : E.multicospanShape.R = E.I₁'
• CategoryTheory.PreOneHypercover.instUniqueRMulticospanShapeSigmaOfIsColimit 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) {c : CategoryTheory.Limits.Cofan E.X} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan E.Y'} (hd : CategoryTheory.Limits.IsColimit d) : Unique (E.sigmaOfIsColimit hc hd).multicospanShape.R
• CategoryTheory.PreOneHypercover.Hom.mapMulticospan_obj 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S} {F : CategoryTheory.PreOneHypercover S} (f : E.Hom F) (x✝ : CategoryTheory.Limits.WalkingMulticospan E.multicospanShape) : f.mapMulticospan.obj x✝ = match x✝ with | CategoryTheory.Limits.WalkingMulticospan.left i => CategoryTheory.Limits.WalkingMulticospan.left (f.s₀ i) | CategoryTheory.Limits.WalkingMulticospan.right i => CategoryTheory.Limits.WalkingMulticospan.right (f.s₁' i)
• CategoryTheory.PreOneHypercover.multicospanIndex_right 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.multicospanShape.R) : (E.multicospanIndex F).right j = F.obj (Opposite.op (E.Y j.snd))
• CategoryTheory.PreOneHypercover.Hom.mapMulticospan_map 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S} {F : CategoryTheory.PreOneHypercover S} (f : E.Hom F) {X✝ Y✝ : CategoryTheory.Limits.WalkingMulticospan E.multicospanShape} (x✝ : X✝ ⟶ Y✝) : f.mapMulticospan.map x✝ = match X✝, Y✝, x✝ with | x, .(x), CategoryTheory.Limits.WalkingMulticospan.Hom.id .(x) => CategoryTheory.Limits.WalkingMulticospan.Hom.id (match x with | CategoryTheory.Limits.WalkingMulticospan.left i => CategoryTheory.Limits.WalkingMulticospan.left (f.s₀ i) | CategoryTheory.Limits.WalkingMulticospan.right i => CategoryTheory.Limits.WalkingMulticospan.right (f.s₁' i)) | .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.fst i)), .(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.fst i => CategoryTheory.Limits.WalkingMulticospan.Hom.fst (f.s₁' i) | .(CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.snd i)), .(CategoryTheory.Limits.WalkingMulticospan.right i), CategoryTheory.Limits.WalkingMulticospan.Hom.snd i => CategoryTheory.Limits.WalkingMulticospan.Hom.snd (f.s₁' i)
• CategoryTheory.PreOneHypercover.multicospanIndex_fst 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.multicospanShape.R) : (E.multicospanIndex F).fst j = F.map (E.p₁ j.snd).op
• CategoryTheory.PreOneHypercover.multicospanIndex_snd 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
  {C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {S : C} (E : CategoryTheory.PreOneHypercover S) (F : CategoryTheory.Functor Cᵒᵖ A) (j : E.multicospanShape.R) : (E.multicospanIndex F).snd j = F.map (E.p₂ j.snd).op
• CategoryTheory.Limits.WalkingMulticospan.instFintype 📋 Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} [Fintype J.L] [Fintype J.R] : Fintype (CategoryTheory.Limits.WalkingMulticospan J)
• CategoryTheory.Limits.WalkingMulticospan.instFinCategoryOfLOfDecidableEqR 📋 Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} [Fintype J.L] [Fintype J.R] [DecidableEq J.L] [DecidableEq J.R] : CategoryTheory.FinCategory (CategoryTheory.Limits.WalkingMulticospan J)
• CategoryTheory.Limits.MulticospanIndex.sections.property 📋 Mathlib.CategoryTheory.Limits.Types.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J (Type u)} (self : I.sections) (r : J.R) : (CategoryTheory.ConcreteCategory.hom (I.fst r)) (self.val (J.fst r)) = (CategoryTheory.ConcreteCategory.hom (I.snd r)) (self.val (J.snd r))
• CategoryTheory.Limits.MulticospanIndex.sections.mk 📋 Mathlib.CategoryTheory.Limits.Types.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J (Type u)} (val : (i : J.L) → I.left i) (property : ∀ (r : J.R), (CategoryTheory.ConcreteCategory.hom (I.fst r)) (val (J.fst r)) = (CategoryTheory.ConcreteCategory.hom (I.snd r)) (val (J.snd r))) : I.sections
• CategoryTheory.Limits.MulticospanIndex.sectionsEquiv_apply_coe 📋 Mathlib.CategoryTheory.Limits.Types.Multiequalizer
  {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u)) (s : I.sections) (i : CategoryTheory.Limits.WalkingMulticospan J) : ↑(I.sectionsEquiv s) i = match i with | CategoryTheory.Limits.WalkingMulticospan.left i => s.val i | CategoryTheory.Limits.WalkingMulticospan.right j => (CategoryTheory.ConcreteCategory.hom (I.fst j)) (s.val (J.fst j))
• CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape_R 📋 Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense
  {C₀ : Type u₀} {C : Type u} [CategoryTheory.Category.{v₀, u₀} C₀] [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X) : data.multicospanShape.R = data.I₁'
• CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex_right 📋 Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense
  {C₀ : Type u₀} {C : Type u} [CategoryTheory.Category.{v₀, u₀} C₀] [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C₀ C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {X : C} (data : F.PreOneHypercoverDenseData X) (P : CategoryTheory.Functor C₀ᵒᵖ A) (j : data.multicospanShape.R) : (data.multicospanIndex P).right j = P.obj (Opposite.op (data.Y j.snd))
• CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanMap_app 📋 Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense
  {C₀ : Type u₀} {C : Type u} [CategoryTheory.Category.{v₀, u₀} C₀] [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C₀ C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {X : C} (data : F.PreOneHypercoverDenseData X) {P Q : CategoryTheory.Functor C₀ᵒᵖ A} (f : P ⟶ Q) (x : CategoryTheory.Limits.WalkingMulticospan data.multicospanShape) : (data.multicospanMap f).app x = match x with | CategoryTheory.Limits.WalkingMulticospan.left i => f.app (Opposite.op (data.X i)) | CategoryTheory.Limits.WalkingMulticospan.right j => f.app (Opposite.op (data.Y j.snd))
• CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex_fst 📋 Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense
  {C₀ : Type u₀} {C : Type u} [CategoryTheory.Category.{v₀, u₀} C₀] [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C₀ C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {X : C} (data : F.PreOneHypercoverDenseData X) (P : CategoryTheory.Functor C₀ᵒᵖ A) (j : data.multicospanShape.R) : (data.multicospanIndex P).fst j = P.map (data.p₁ j.snd).op
• CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex_snd 📋 Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense
  {C₀ : Type u₀} {C : Type u} [CategoryTheory.Category.{v₀, u₀} C₀] [CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C₀ C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {X : C} (data : F.PreOneHypercoverDenseData X) (P : CategoryTheory.Functor C₀ᵒᵖ A) (j : data.multicospanShape.R) : (data.multicospanIndex P).snd j = P.map (data.p₂ j.snd).op
• CategoryTheory.Limits.MulticospanIndex.map_right 📋 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.MulticospanShape} (d : CategoryTheory.Limits.MulticospanIndex J C) (F : CategoryTheory.Functor C D) (i : J.R) : (d.map F).right i = F.obj (d.right i)
• CategoryTheory.Limits.MulticospanIndex.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.MulticospanShape} (d : CategoryTheory.Limits.MulticospanIndex J C) (F : CategoryTheory.Functor C D) (i : J.R) : (d.map F).fst i = F.map (d.fst i)
• CategoryTheory.Limits.MulticospanIndex.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.MulticospanShape} (d : CategoryTheory.Limits.MulticospanIndex J C) (F : CategoryTheory.Functor C D) (i : J.R) : (d.map F).snd i = F.map (d.snd i)
• CategoryTheory.Limits.MulticospanIndex.multicospanMapIso_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.MulticospanShape} (d : CategoryTheory.Limits.MulticospanIndex J C) (F : CategoryTheory.Functor C D) (X : CategoryTheory.Limits.WalkingMulticospan J) : (d.multicospanMapIso F).hom.app X = (match X with | CategoryTheory.Limits.WalkingMulticospan.left a => CategoryTheory.Iso.refl (F.obj (d.left a)) | CategoryTheory.Limits.WalkingMulticospan.right a => CategoryTheory.Iso.refl (F.obj (d.right a))).hom
• CategoryTheory.Limits.MulticospanIndex.multicospanMapIso_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.MulticospanShape} (d : CategoryTheory.Limits.MulticospanIndex J C) (F : CategoryTheory.Functor C D) (X : CategoryTheory.Limits.WalkingMulticospan J) : (d.multicospanMapIso F).inv.app X = (match X with | CategoryTheory.Limits.WalkingMulticospan.left a => CategoryTheory.Iso.refl (F.obj (d.left a)) | CategoryTheory.Limits.WalkingMulticospan.right a => CategoryTheory.Iso.refl (F.obj (d.right a))).inv
• CategoryTheory.Limits.Multifork.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.MulticospanShape} {d : CategoryTheory.Limits.MulticospanIndex J C} (c : CategoryTheory.Limits.Multifork d) (F : CategoryTheory.Functor C D) (x : CategoryTheory.Limits.WalkingMulticospan J) : (c.map F).π.app x = match x with | CategoryTheory.Limits.WalkingMulticospan.left a => F.map (c.ι a) | CategoryTheory.Limits.WalkingMulticospan.right b => CategoryTheory.CategoryStruct.comp (F.map (c.ι (J.fst b))) (F.map (d.fst b))
• CategoryTheory.Limits.multicospanShapeEnd_R 📋 Mathlib.CategoryTheory.Limits.Shapes.End
  (J : Type u) [CategoryTheory.Category.{v, u} J] : (CategoryTheory.Limits.multicospanShapeEnd J).R = CategoryTheory.Arrow J
• CategoryTheory.Limits.multicospanIndexEnd_right 📋 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.multicospanShapeEnd J).R) : (CategoryTheory.Limits.multicospanIndexEnd F).right f = (F.obj (Opposite.op (CategoryTheory.Arrow.left f))).obj (CategoryTheory.Arrow.right f)
• CategoryTheory.Limits.multicospanIndexEnd_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.multicospanShapeEnd J).R) : (CategoryTheory.Limits.multicospanIndexEnd F).fst f = (F.obj (Opposite.op (CategoryTheory.Arrow.left f))).map (CategoryTheory.Arrow.hom f)
• CategoryTheory.Limits.multicospanIndexEnd_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.multicospanShapeEnd J).R) : (CategoryTheory.Limits.multicospanIndexEnd F).snd f = (F.map (CategoryTheory.Arrow.hom f).op).app (CategoryTheory.Arrow.right f)

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