Loogle!

Result

Found 61 declarations mentioning CategoryTheory.GrothendieckTopology.OneHypercover.toPreOneHypercover.

CategoryTheory.GrothendieckTopology.OneHypercover.toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (self : J.OneHypercover S) : CategoryTheory.PreOneHypercover S
CategoryTheory.GrothendieckTopology.OneHypercover.trivial_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (S : C) : (CategoryTheory.GrothendieckTopology.OneHypercover.trivial J S).toPreOneHypercover = CategoryTheory.PreOneHypercover.trivial S
CategoryTheory.GrothendieckTopology.Cover.oneHypercover_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (S : J.Cover X) : S.oneHypercover.toPreOneHypercover = S.preOneHypercover
CategoryTheory.GrothendieckTopology.OneHypercover.toZeroHypercover_toPreZeroHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) : E.toZeroHypercover.toPreZeroHypercover = E.toPreZeroHypercover
CategoryTheory.GrothendieckTopology.OneHypercover.isoMk 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E F : J.OneHypercover S} (f : E.toPreOneHypercover ≅ F.toPreOneHypercover) : E ≅ F
CategoryTheory.Precoverage.ZeroHypercover.toOneHypercover_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C} (E : J.ZeroHypercover S) [E.HasPullbacks] : E.toOneHypercover.toPreOneHypercover = E.toPreOneHypercover
CategoryTheory.GrothendieckTopology.OneHypercover.mem₀ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (self : J.OneHypercover S) : self.sieve₀ ∈ J S
CategoryTheory.GrothendieckTopology.OneHypercover.id_s₀ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) (a : E.I₀) : (CategoryTheory.CategoryStruct.id E).s₀ a = a
CategoryTheory.GrothendieckTopology.OneHypercover.id_s₁ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) {i✝ j✝ : E.I₀} (a : E.I₁ i✝ j✝) : (CategoryTheory.CategoryStruct.id E).s₁ a = a
CategoryTheory.GrothendieckTopology.OneHypercover.isoMk_hom 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E F : J.OneHypercover S} (f : E.toPreOneHypercover ≅ F.toPreOneHypercover) : (CategoryTheory.GrothendieckTopology.OneHypercover.isoMk f).hom = f.hom
CategoryTheory.GrothendieckTopology.OneHypercover.isoMk_inv 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E F : J.OneHypercover S} (f : E.toPreOneHypercover ≅ F.toPreOneHypercover) : (CategoryTheory.GrothendieckTopology.OneHypercover.isoMk f).inv = f.inv
CategoryTheory.GrothendieckTopology.OneHypercover.isLimitMultifork 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) (F : CategoryTheory.Sheaf J A) : CategoryTheory.Limits.IsLimit (E.multifork F.obj)
CategoryTheory.GrothendieckTopology.OneHypercover.id_h₁ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) {i✝ j✝ : E.I₀} (x✝ : E.I₁ i✝ j✝) : (CategoryTheory.CategoryStruct.id E).h₁ x✝ = CategoryTheory.CategoryStruct.id (E.Y x✝)
CategoryTheory.GrothendieckTopology.OneHypercover.id_h₀ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) (x✝ : E.I₀) : (CategoryTheory.CategoryStruct.id E).h₀ x✝ = CategoryTheory.CategoryStruct.id (E.X x✝)
CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E : J.OneHypercover S} {F : CategoryTheory.Sheaf J A} (c : CategoryTheory.Limits.Multifork (E.multicospanIndex F.obj)) : c.pt ⟶ F.obj.obj (Opposite.op S)
CategoryTheory.GrothendieckTopology.OneHypercover.comp_s₀ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {X✝ Y✝ Z✝ : J.OneHypercover S} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) (a✝ : X✝.I₀) : (CategoryTheory.CategoryStruct.comp f g).s₀ a✝ = g.s₀ (f.s₀ a✝)
CategoryTheory.GrothendieckTopology.OneHypercover.mem₁ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (self : J.OneHypercover S) (i₁ i₂ : self.I₀) ⦃W : C⦄ (p₁ : W ⟶ self.X i₁) (p₂ : W ⟶ self.X i₂) (w : CategoryTheory.CategoryStruct.comp p₁ (self.f i₁) = CategoryTheory.CategoryStruct.comp p₂ (self.f i₂)) : self.sieve₁ p₁ p₂ ∈ J W
CategoryTheory.GrothendieckTopology.OneHypercover.mk'_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : CategoryTheory.PreOneHypercover S) [E.HasPullbacks] (mem₀ : E.sieve₀ ∈ J S) (mem₁' : ∀ (i₁ i₂ : E.I₀), E.sieve₁' i₁ i₂ ∈ J (CategoryTheory.Limits.pullback (E.f i₁) (E.f i₂))) : (CategoryTheory.GrothendieckTopology.OneHypercover.mk' E mem₀ mem₁').toPreOneHypercover = E
CategoryTheory.GrothendieckTopology.OneHypercover.inter 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} [CategoryTheory.Limits.HasPullbacks C] (E : J.OneHypercover S) (F : J.OneHypercover S) [∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] [∀ (i j : E.I₀) (k : E.I₁ i j) (a b : F.I₀) (l : F.I₁ a b), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (E.p₁ k) (E.f i)) (CategoryTheory.CategoryStruct.comp (F.p₁ l) (F.f a))] : J.OneHypercover S
CategoryTheory.GrothendieckTopology.OneHypercover.inter_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} [CategoryTheory.Limits.HasPullbacks C] (E : J.OneHypercover S) (F : J.OneHypercover S) [∀ (i : E.I₀) (j : F.I₀), CategoryTheory.Limits.HasPullback (E.f i) (F.f j)] [∀ (i j : E.I₀) (k : E.I₁ i j) (a b : F.I₀) (l : F.I₁ a b), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (E.p₁ k) (E.f i)) (CategoryTheory.CategoryStruct.comp (F.p₁ l) (F.f a))] : (E.inter F).toPreOneHypercover = E.inter F.toPreOneHypercover
CategoryTheory.GrothendieckTopology.OneHypercover.mem_sieve₁' 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} (E : J.OneHypercover S) (i₁ i₂ : E.I₀) [CategoryTheory.Limits.HasPullback (E.f i₁) (E.f i₂)] : E.sieve₁' i₁ i₂ ∈ J (CategoryTheory.Limits.pullback (E.f i₁) (E.f i₂))
CategoryTheory.GrothendieckTopology.OneHypercover.comp_s₁ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {X✝ Y✝ Z✝ : J.OneHypercover S} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) {i✝ j✝ : X✝.I₀} (a✝ : X✝.I₁ i✝ j✝) : (CategoryTheory.CategoryStruct.comp f g).s₁ a✝ = g.s₁ (f.s₁ a✝)
CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift_map 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E : J.OneHypercover S} {F : CategoryTheory.Sheaf J A} (c : CategoryTheory.Limits.Multifork (E.multicospanIndex F.obj)) (i₀ : E.I₀) : CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift c) (F.obj.map (E.f i₀).op) = c.ι i₀
CategoryTheory.GrothendieckTopology.OneHypercover.comp_h₀ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {X✝ Y✝ Z✝ : J.OneHypercover S} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) (i : X✝.I₀) : (CategoryTheory.CategoryStruct.comp f g).h₀ i = CategoryTheory.CategoryStruct.comp (f.h₀ i) (g.h₀ (f.s₀ i))
CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift_map_assoc 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {A : Type u_1} [CategoryTheory.Category.{v_1, u_1} A] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E : J.OneHypercover S} {F : CategoryTheory.Sheaf J A} (c : CategoryTheory.Limits.Multifork (E.multicospanIndex F.obj)) (i₀ : E.I₀) {Z : A} (h : F.obj.obj (Opposite.op (E.X i₀)) ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift c) (CategoryTheory.CategoryStruct.comp (F.obj.map (E.f i₀).op) h) = CategoryTheory.CategoryStruct.comp (c.ι i₀) h
CategoryTheory.GrothendieckTopology.OneHypercover.comp_h₁ 📋 Mathlib.CategoryTheory.Sites.Hypercover.One
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {X✝ Y✝ Z✝ : J.OneHypercover S} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) {i✝ j✝ : X✝.I₀} (i : X✝.I₁ i✝ j✝) : (CategoryTheory.CategoryStruct.comp f g).h₁ i = CategoryTheory.CategoryStruct.comp (f.h₁ i) (g.h₁ (f.s₁ i))
CategoryTheory.Presheaf.isSheaf_iff_of_isGeneratedByOneHypercovers 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u'} [CategoryTheory.Category.{v', u'} A] [J.IsGeneratedByOneHypercovers] (P : CategoryTheory.Functor Cᵒᵖ A) : CategoryTheory.Presheaf.IsSheaf J P ↔ ∀ ⦃X : C⦄ (E : J.OneHypercover X), Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.isSheaf_iff 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] (H : J.OneHypercoverFamily) (P : CategoryTheory.Functor Cᵒᵖ A) [H.IsGenerating] : CategoryTheory.Presheaf.IsSheaf J P ↔ ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.exists_oneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (H : J.OneHypercoverFamily) [H.IsGenerating] {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J X) : ∃ E, ∃ (_ : H E), E.sieve₀ ≤ S
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsGenerating.le 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} {inst✝ : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.GrothendieckTopology C} {H : J.OneHypercoverFamily} [self : H.IsGenerating] {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J X) : ∃ E, ∃ (_ : H E), E.sieve₀ ≤ S
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsGenerating.mk 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {H : J.OneHypercoverFamily} (le : ∀ {X : C}, ∀ S ∈ J X, ∃ E, ∃ (_ : H E), E.sieve₀ ≤ S) : H.IsGenerating
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.hom_ext 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] (H : J.OneHypercoverFamily) (P : CategoryTheory.Functor Cᵒᵖ A) (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) [H.IsGenerating] {X : C} (S : CategoryTheory.Sieve X) (hS : S ∈ J X) {T : A} {x y : T ⟶ P.obj (Opposite.op X)} (h : ∀ ⦃Y : C⦄ (f : Y ⟶ X), S.arrows f → CategoryTheory.CategoryStruct.comp x (P.map f.op) = CategoryTheory.CategoryStruct.comp y (P.map f.op)) : x = y
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.isLimit 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} {S : CategoryTheory.Sieve X} {E : J.OneHypercover X} (hE : H E) (le : E.sieve₀ ≤ S) [H.IsGenerating] : CategoryTheory.Limits.IsLimit (CategoryTheory.GrothendieckTopology.Cover.multifork ⟨S, ⋯⟩ P)
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} {S : CategoryTheory.Sieve X} {E : J.OneHypercover X} (hE : H E) (le : E.sieve₀ ≤ S) (F : CategoryTheory.Limits.Multifork (CategoryTheory.GrothendieckTopology.Cover.index ⟨S, ⋯⟩ P)) : F.pt ⟶ P.obj (Opposite.op X)
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.fac 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} {S : CategoryTheory.Sieve X} {E : J.OneHypercover X} (hE : H E) (le : E.sieve₀ ≤ S) (F : CategoryTheory.Limits.Multifork (CategoryTheory.GrothendieckTopology.Cover.index ⟨S, ⋯⟩ P)) [H.IsGenerating] {Y : C} (f : Y ⟶ X) (hf : S.arrows f) : CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift hP hE le F) (P.map f.op) = F.ι { Y := Y, f := f, hf := hf }
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.fac' 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} {S : CategoryTheory.Sieve X} {E : J.OneHypercover X} (hE : H E) (le : E.sieve₀ ≤ S) (F : CategoryTheory.Limits.Multifork (CategoryTheory.GrothendieckTopology.Cover.index ⟨S, ⋯⟩ P)) (i : E.I₀) : CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift hP hE le F) (P.map (E.f i).op) = F.ι { Y := E.X i, f := E.f i, hf := ⋯ }
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.fac'_assoc 📋 Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] {H : J.OneHypercoverFamily} {P : CategoryTheory.Functor Cᵒᵖ A} (hP : ∀ ⦃X : C⦄ (E : J.OneHypercover X), H E → Nonempty (CategoryTheory.Limits.IsLimit (E.multifork P))) {X : C} {S : CategoryTheory.Sieve X} {E : J.OneHypercover X} (hE : H E) (le : E.sieve₀ ≤ S) (F : CategoryTheory.Limits.Multifork (CategoryTheory.GrothendieckTopology.Cover.index ⟨S, ⋯⟩ P)) (i : E.I₀) {Z : A} (h : P.obj (Opposite.op (E.X i)) ⟶ Z) : CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift hP hE le F) (CategoryTheory.CategoryStruct.comp (P.map (E.f i).op) h) = CategoryTheory.CategoryStruct.comp (F.ι { Y := E.X i, f := E.f i, hf := ⋯ }) h
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.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.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
CategoryTheory.GrothendieckTopology.OneHypercover.isStronglySeparatedFor 📋 Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (hf : CategoryTheory.Presieve.IsSeparated J F) : E.IsStronglySeparatedFor F
CategoryTheory.GrothendieckTopology.OneHypercover.isStronglySheafFor 📋 Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (hf : CategoryTheory.Presieve.IsSheaf J F) : E.IsStronglySheafFor F
CategoryTheory.GrothendieckTopology.OneHypercover.isSheafFor_sieve_of_pullback 📋 Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} (E : J.OneHypercover X) {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (hF : CategoryTheory.Presieve.IsSheaf J F) {S : CategoryTheory.Sieve X} (h₁ : ∀ (i : E.I₀), CategoryTheory.Presieve.IsSheafFor F (CategoryTheory.Sieve.pullback (E.f i) S).arrows) (h₂ : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), CategoryTheory.Presieve.IsSeparatedFor F (CategoryTheory.Sieve.pullback (CategoryTheory.CategoryStruct.comp (E.p₁ k) (E.f i)) S).arrows) : CategoryTheory.Presieve.IsSheafFor F S.arrows
CategoryTheory.GrothendieckTopology.OneHypercover.isSheafFor_of_pullback 📋 Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes
{C : Type u_1} [CategoryTheory.Category.{v_1, u_1} C] {J : CategoryTheory.GrothendieckTopology C} {X : C} {E : J.OneHypercover X} {F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (hF : CategoryTheory.Presieve.IsSheaf J F) {R : CategoryTheory.Presieve X} (h₁ : ∀ (i : E.I₀), CategoryTheory.Presieve.IsSheafFor F (CategoryTheory.Sieve.pullback (E.f i) (CategoryTheory.Sieve.generate R)).arrows) (h₂ : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), CategoryTheory.Presieve.IsSeparatedFor F (CategoryTheory.Sieve.pullback (CategoryTheory.CategoryStruct.comp (E.p₁ k) (E.f i)) (CategoryTheory.Sieve.generate R)).arrows) : CategoryTheory.Presieve.IsSheafFor F R
AlgebraicGeometry.Scheme.affineOneHypercover_toPreOneHypercover_toPreZeroHypercover 📋 Mathlib.AlgebraicGeometry.Sites.BigZariski
(X : AlgebraicGeometry.Scheme) : X.affineOneHypercover.toPreZeroHypercover = X.affineCover.toPreZeroHypercover
AlgebraicGeometry.Scheme.GlueData.oneHypercover_I₀ 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) : D.oneHypercover.I₀ = D.J
AlgebraicGeometry.Scheme.GlueData.oneHypercover_I₁ 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) (x✝ x✝¹ : D.J) : D.oneHypercover.I₁ x✝ x✝¹ = PUnit.{u + 1}
AlgebraicGeometry.Scheme.GlueData.oneHypercover_X 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) (a✝ : D.J) : D.oneHypercover.X a✝ = D.U a✝
AlgebraicGeometry.Scheme.GlueData.oneHypercover_f 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) (i : D.J) : D.oneHypercover.f i = D.ι i
AlgebraicGeometry.Scheme.GlueData.oneHypercover_Y 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x✝ : PUnit.{u + 1}) : D.oneHypercover.Y x✝ = D.V (i₁, i₂)
AlgebraicGeometry.Scheme.GlueData.oneHypercover_p₁ 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x✝ : PUnit.{u + 1}) : D.oneHypercover.p₁ x✝ = D.f i₁ i₂
AlgebraicGeometry.Scheme.GlueData.oneHypercover_p₂ 📋 Mathlib.AlgebraicGeometry.GluingOneHypercover
(D : AlgebraicGeometry.Scheme.GlueData) (i₁ i₂ : D.J) (x✝ : PUnit.{u + 1}) : D.oneHypercover.p₂ x✝ = CategoryTheory.CategoryStruct.comp (D.t i₁ i₂) (D.f i₂ i₁)
CategoryTheory.Functor.OneHypercoverDenseData.toOneHypercover_toPreOneHypercover 📋 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} {J₀ : CategoryTheory.GrothendieckTopology C₀} {J : CategoryTheory.GrothendieckTopology C} [CategoryTheory.Functor.IsDenseSubsite J₀ J F] {X : C} (data : F.OneHypercoverDenseData J₀ J X) : data.toOneHypercover.toPreOneHypercover = data.toPreOneHypercover
CategoryTheory.Functor.OneHypercoverDenseData.isSheaf_iff 📋 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} {J₀ : CategoryTheory.GrothendieckTopology C₀} {J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [CategoryTheory.Category.{v', u'} A] [CategoryTheory.Functor.IsDenseSubsite J₀ J F] (data : (X : C) → F.OneHypercoverDenseData J₀ J X) (G : CategoryTheory.Functor Cᵒᵖ A) : CategoryTheory.Presheaf.IsSheaf J G ↔ CategoryTheory.Presheaf.IsSheaf J₀ (F.op.comp G) ∧ ∀ (X : C), Nonempty (CategoryTheory.Limits.IsLimit ((data X).toOneHypercover.multifork G))
CategoryTheory.GrothendieckTopology.OneHypercover.cylinder_toPreOneHypercover 📋 Mathlib.CategoryTheory.Sites.Hypercover.Homotopy
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E : J.OneHypercover S} {F : J.OneHypercover S} [CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F) : (CategoryTheory.GrothendieckTopology.OneHypercover.cylinder f g).toPreOneHypercover = CategoryTheory.PreOneHypercover.cylinder f g
CategoryTheory.GrothendieckTopology.OneHypercover.exists_nonempty_homotopy 📋 Mathlib.CategoryTheory.Sites.Hypercover.Homotopy
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {S : C} {E : J.OneHypercover S} {F : J.OneHypercover S} [CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F) : ∃ W h, Nonempty (CategoryTheory.PreOneHypercover.Homotopy (CategoryTheory.PreOneHypercover.Hom.comp h f) (CategoryTheory.PreOneHypercover.Hom.comp h g))
CategoryTheory.PreOneHypercover.Homotopy.map_eq_map 📋 Mathlib.CategoryTheory.Sites.Hypercover.Homotopy
{C : Type u} [CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {S : C} {E F : J.OneHypercover S} {f g : E ⟶ F} (H : CategoryTheory.PreOneHypercover.Homotopy f g) : (CategoryTheory.GrothendieckTopology.OneHypercover.toHOneHypercover J S).map f = (CategoryTheory.GrothendieckTopology.OneHypercover.toHOneHypercover J S).map g
CategoryTheory.GrothendieckTopology.OneHypercover.glueMorphisms 📋 Mathlib.CategoryTheory.Sites.Hypercover.Subcanonical
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} [J.Subcanonical] {S T : C} (E : J.OneHypercover S) (f : (i : E.I₀) → E.X i ⟶ T) (h : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), CategoryTheory.CategoryStruct.comp (E.p₁ k) (f i) = CategoryTheory.CategoryStruct.comp (E.p₂ k) (f j)) : S ⟶ T
CategoryTheory.GrothendieckTopology.OneHypercover.f_glueMorphisms 📋 Mathlib.CategoryTheory.Sites.Hypercover.Subcanonical
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} [J.Subcanonical] {S T : C} (E : J.OneHypercover S) (f : (i : E.I₀) → E.X i ⟶ T) (h : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), CategoryTheory.CategoryStruct.comp (E.p₁ k) (f i) = CategoryTheory.CategoryStruct.comp (E.p₂ k) (f j)) (i : E.I₀) : CategoryTheory.CategoryStruct.comp (E.f i) (E.glueMorphisms f h) = f i
CategoryTheory.GrothendieckTopology.OneHypercover.f_glueMorphisms_assoc 📋 Mathlib.CategoryTheory.Sites.Hypercover.Subcanonical
{C : Type u} [CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} [J.Subcanonical] {S T : C} (E : J.OneHypercover S) (f : (i : E.I₀) → E.X i ⟶ T) (h : ∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), CategoryTheory.CategoryStruct.comp (E.p₁ k) (f i) = CategoryTheory.CategoryStruct.comp (E.p₂ k) (f j)) (i : E.I₀) {Z : C} (h✝ : T ⟶ Z) : CategoryTheory.CategoryStruct.comp (E.f i) (CategoryTheory.CategoryStruct.comp (E.glueMorphisms f h) h✝) = CategoryTheory.CategoryStruct.comp (f i) h✝

About

Loogle searches Lean and Mathlib definitions and theorems.

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

Usage

Loogle finds definitions and lemmas in various ways:

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

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

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

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

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

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

Source code

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

This is Loogle revision 9f11169 serving mathlib revision ce5dd8c