Loogle!

Result

Found 36 declarations mentioning CategoryTheory.Limits.MulticospanIndex.fst.

• 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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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)

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