Loogle!

Result

Found 13 declarations mentioning CategoryTheory.PreOneHypercover.map.

CategoryTheory.PreOneHypercover.map 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) : CategoryTheory.PreOneHypercover (F.obj X)
CategoryTheory.PreOneHypercover.map_I₀ 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) : (E.map F).I₀ = E.I₀
CategoryTheory.PreOneHypercover.map_I₁ 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (i₁ i₂ : E.I₀) : (E.map F).I₁ i₁ i₂ = E.I₁ i₁ i₂
CategoryTheory.PreOneHypercover.map_X 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (i : E.I₀) : (E.map F).X i = F.obj (E.X i)
CategoryTheory.PreOneHypercover.map_Y 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (x✝ x✝¹ : E.I₀) (j : E.I₁ x✝ x✝¹) : (E.map F).Y j = F.obj (E.Y j)
CategoryTheory.GrothendieckTopology.OneHypercover.map_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : CategoryTheory.GrothendieckTopology C} {X : C} (E : J.OneHypercover X) (F : CategoryTheory.Functor C D) (K : CategoryTheory.GrothendieckTopology D) [E.IsPreservedBy F K] : (E.map F K).toPreOneHypercover = E.map F
CategoryTheory.PreOneHypercover.map_f 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (i : E.I₀) : (E.map F).f i = F.map (E.f i)
CategoryTheory.PreOneHypercover.map_p₁ 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (x✝ x✝¹ : E.I₀) (j : E.I₁ x✝ x✝¹) : (E.map F).p₁ j = F.map (E.p₁ j)
CategoryTheory.PreOneHypercover.map_p₂ 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (x✝ x✝¹ : E.I₀) (j : E.I₁ x✝ x✝¹) : (E.map F).p₂ j = F.map (E.p₂ j)
CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.mem₀ 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} {inst✝ : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst✝¹ : CategoryTheory.Category.{v₂, u₂} D} {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : E.IsPreservedBy F K] : (E.map F).sieve₀ ∈ K (F.obj X)
CategoryTheory.PreOneHypercover.isLimitMapMultiforkEquiv 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) {A : Type u} [CategoryTheory.Category.{t, u} A] (P : CategoryTheory.Functor Dᵒᵖ A) : CategoryTheory.Limits.IsLimit ((E.map F).multifork P) ≃ CategoryTheory.Limits.IsLimit (E.multifork (F.op.comp P))
CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.mem₁ 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} {inst✝ : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst✝¹ : CategoryTheory.Category.{v₂, u₂} D} {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} [self : E.IsPreservedBy F K] (i₁ i₂ : E.I₀) ⦃W : D⦄ (p₁ : W ⟶ F.obj (E.X i₁)) (p₂ : W ⟶ F.obj (E.X i₂)) (w : CategoryTheory.CategoryStruct.comp p₁ (F.map (E.f i₁)) = CategoryTheory.CategoryStruct.comp p₂ (F.map (E.f i₂))) : (E.map F).sieve₁ p₁ p₂ ∈ K W
CategoryTheory.GrothendieckTopology.OneHypercover.IsPreservedBy.mk 📋 Mathlib.CategoryTheory.Sites.Continuous
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor C D} {K : CategoryTheory.GrothendieckTopology D} (mem₀ : (E.map F).sieve₀ ∈ K (F.obj X)) (mem₁ : ∀ (i₁ i₂ : E.I₀) ⦃W : D⦄ (p₁ : W ⟶ F.obj (E.X i₁)) (p₂ : W ⟶ F.obj (E.X i₂)), CategoryTheory.CategoryStruct.comp p₁ (F.map (E.f i₁)) = CategoryTheory.CategoryStruct.comp p₂ (F.map (E.f i₂)) → (E.map F).sieve₁ p₁ p₂ ∈ K W) : E.IsPreservedBy F K

About

Loogle searches Lean and Mathlib definitions and theorems.

You can use Loogle from within the Lean4 VSCode language extension using (by default) Ctrl-K Ctrl-S. You can also try the #loogle command from LeanSearchClient, the CLI version, the Loogle VS Code extension, the lean.nvim integration or the Zulip bot.

Usage

Loogle finds definitions and lemmas in various ways:

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

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

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

As before, if the pattern has parameters, they are matched against the hypotheses of the lemma in any order; for example,
🔍 |- _ < _ → tsum _ < tsum _
will find tsum_lt_tsum even though the hypothesis f i < g i is not the last.

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.

This is Loogle revision 19971e9 serving mathlib revision bce1d65