Loogle!
Result
Found 41 declarations mentioning PresheafOfModules.map.
- PresheafOfModules.map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (self : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) : self.obj X ⟶ (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (self.obj Y) - PresheafOfModules.restriction_app 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) {X Y : Cᵒᵖ} (f : X ⟶ Y) (M : PresheafOfModules R) : (PresheafOfModules.restriction R f).app M = M.map f - PresheafOfModules.map_id 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (self : PresheafOfModules R) (X : Cᵒᵖ) : self.map (CategoryTheory.CategoryStruct.id X) = (ModuleCat.restrictScalarsId' (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.id X))) ⋯).inv.app (self.obj X) - PresheafOfModules.Hom.naturality 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (self : M₁.Hom M₂) {X Y : Cᵒᵖ} (f : X ⟶ Y) : CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.app Y)) = CategoryTheory.CategoryStruct.comp (self.app X) (M₂.map f) - PresheafOfModules.Hom.mk 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X) (naturality : ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y)) = CategoryTheory.CategoryStruct.comp (app X) (M₂.map f) := by aesop_cat) : M₁.Hom M₂ - PresheafOfModules.Hom.mk.sizeOf_spec 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} [SizeOf C] (app : (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X) (naturality : ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y)) = CategoryTheory.CategoryStruct.comp (app X) (M₂.map f) := by aesop_cat) : sizeOf { app := app, naturality := naturality } = 1 - PresheafOfModules.isoMk 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) = CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f) := by aesop_cat) : M₁ ≅ M₂ - PresheafOfModules.isoMk_hom_app 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) = CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f) := by aesop_cat) (X : Cᵒᵖ) : (PresheafOfModules.isoMk app naturality).hom.app X = (app X).hom - PresheafOfModules.isoMk_inv_app 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X) (naturality : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y).hom) = CategoryTheory.CategoryStruct.comp (app X).hom (M₂.map f) := by aesop_cat) (X : Cᵒᵖ) : (PresheafOfModules.isoMk app naturality).inv.app X = (app X).inv - PresheafOfModules.Hom.naturality_assoc 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (self : M₁.Hom M₂) {X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : ModuleCat ↑(R.obj X)} (h : (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).obj (M₂.obj Y) ⟶ Z) : CategoryTheory.CategoryStruct.comp (M₁.map f) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.app Y)) h) = CategoryTheory.CategoryStruct.comp (self.app X) (CategoryTheory.CategoryStruct.comp (M₂.map f) h) - PresheafOfModules.sectionsMk 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : (X : Cᵒᵖ) → ↑(M.obj X)) (hs : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), (CategoryTheory.ConcreteCategory.hom (M.map f)) (s X) = s Y) : M.sections - PresheafOfModules.presheaf_map_apply_coe 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (x : ↑(M.obj X)) : (AddCommGrp.Hom.hom (M.presheaf.map f)) x = (CategoryTheory.ConcreteCategory.hom (M.map f)) x - PresheafOfModules.unit_map_one 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] (R : CategoryTheory.Functor Cᵒᵖ RingCat) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (CategoryTheory.ConcreteCategory.hom ((PresheafOfModules.unit R).map f)) 1 = 1 - PresheafOfModules.sectionsMk_coe 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : (X : Cᵒᵖ) → ↑(M.obj X)) (hs : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y), (CategoryTheory.ConcreteCategory.hom (M.map f)) (s X) = s Y) (X : Cᵒᵖ) : ↑(PresheafOfModules.sectionsMk s hs) X = s X - PresheafOfModules.forgetToPresheafModuleCatObjMap_apply 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (X : Cᵒᵖ) (hX : CategoryTheory.Limits.IsInitial X) (M : PresheafOfModules R) {Y Z : Cᵒᵖ} (f : Y ⟶ Z) (m : ↑(M.obj Y)) : (ModuleCat.Hom.hom (PresheafOfModules.forgetToPresheafModuleCatObjMap X hX M f)) m = (CategoryTheory.ConcreteCategory.hom (M.map f)) m - PresheafOfModules.sections_property 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M : PresheafOfModules R} (s : M.sections) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (CategoryTheory.ConcreteCategory.hom (M.map f)) (↑s X) = ↑s Y - PresheafOfModules.Hom.mk.injEq 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X) (naturality : ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app Y)) = CategoryTheory.CategoryStruct.comp (app X) (M₂.map f) := by aesop_cat) (app✝ : (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X) (naturality✝ : ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (M₁.map f) ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (app✝ Y)) = CategoryTheory.CategoryStruct.comp (app✝ X) (M₂.map f) := by aesop_cat) : ({ app := app, naturality := naturality } = { app := app✝, naturality := naturality✝ }) = (app = app✝) - PresheafOfModules.congr_map_apply 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) {X Y : Cᵒᵖ} {f g : X ⟶ Y} (h : f = g) (m : ↑(M.obj X)) : (CategoryTheory.ConcreteCategory.hom (M.map f)) m = (CategoryTheory.ConcreteCategory.hom (M.map g)) m - PresheafOfModules.map_comp 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (self : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) : self.map (CategoryTheory.CategoryStruct.comp f g) = CategoryTheory.CategoryStruct.comp (self.map f) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.map g)) ((ModuleCat.restrictScalarsComp' (RingCat.Hom.hom (R.map f)) (RingCat.Hom.hom (R.map g)) (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.comp f g))) ⋯).inv.app (self.obj Z))) - PresheafOfModules.map_comp_assoc 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (self : PresheafOfModules R) {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) {Z✝ : ModuleCat ↑(R.obj X)} (h : (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.comp f g)))).obj (self.obj Z) ⟶ Z✝) : CategoryTheory.CategoryStruct.comp (self.map (CategoryTheory.CategoryStruct.comp f g)) h = CategoryTheory.CategoryStruct.comp (self.map f) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map (self.map g)) (CategoryTheory.CategoryStruct.comp ((ModuleCat.restrictScalarsComp' (RingCat.Hom.hom (R.map f)) (RingCat.Hom.hom (R.map g)) (RingCat.Hom.hom (R.map (CategoryTheory.CategoryStruct.comp f g))) ⋯).inv.app (self.obj Z)) h)) - PresheafOfModules.ofPresheaf_map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : CategoryTheory.Functor Cᵒᵖ Ab) [(X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)] (map_smul : ∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)), (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (PresheafOfModules.ofPresheaf M map_smul).map f = ModuleCat.ofHom { toFun := fun x => (CategoryTheory.ConcreteCategory.hom (M.map f)) x, map_add' := ⋯, map_smul' := ⋯ } - PresheafOfModules.naturality_apply 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) {X Y : Cᵒᵖ} (g : X ⟶ Y) (x : ↑(M₁.obj X)) : (CategoryTheory.ConcreteCategory.hom (f.app Y)) ((CategoryTheory.ConcreteCategory.hom (M₁.map g)) x) = (CategoryTheory.ConcreteCategory.hom (M₂.map g)) ((CategoryTheory.ConcreteCategory.hom (f.app X)) x) - PresheafOfModules.map_smul 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)) : (CategoryTheory.ConcreteCategory.hom (M.map f)) (r • m) = (CategoryTheory.ConcreteCategory.hom (R.map f)) r • (CategoryTheory.ConcreteCategory.hom (M.map f)) m - PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_map 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : CategoryTheory.Functor Dᵒᵖ CommRingCat} (φ' : S' ⟶ R) {X✝ Y✝ : Dᵒᵖ} (f : X✝ ⟶ Y✝) : (PresheafOfModules.DifferentialsConstruction.relativeDifferentials' φ').map f = CommRingCat.KaehlerDifferential.map ⋯ - PresheafOfModules.Derivation'.mk 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ' : S' ⟶ R} (d : (X : Dᵒᵖ) → (M.obj X).Derivation (φ'.app X)) (d_map : ∀ ⦃X Y : Dᵒᵖ⦄ (f : X ⟶ Y) (x : ↑(R.obj X)), (d Y).d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) ((d X).d x)) : M.Derivation' φ' - PresheafOfModules.Derivation'.mk_app 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ' : S' ⟶ R} (d : (X : Dᵒᵖ) → (M.obj X).Derivation (φ'.app X)) (d_map : ∀ ⦃X Y : Dᵒᵖ⦄ (f : X ⟶ Y) (x : ↑(R.obj X)), (d Y).d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) ((d X).d x)) (X : Dᵒᵖ) : (PresheafOfModules.Derivation'.mk d d_map).app X = d X - PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_map_d 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S' R : CategoryTheory.Functor Dᵒᵖ CommRingCat} (φ' : S' ⟶ R) {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X)) : (ModuleCat.Hom.hom ((PresheafOfModules.DifferentialsConstruction.relativeDifferentials' φ').map f)) (CommRingCat.KaehlerDifferential.d x) = CommRingCat.KaehlerDifferential.d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) - PresheafOfModules.Derivation.d_map 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ : S ⟶ F.op.comp R} (self : M.Derivation φ) {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X)) : self.d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) (self.d x) - PresheafOfModules.Derivation.mk 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ : S ⟶ F.op.comp R} (d : {X : Dᵒᵖ} → ↑(R.obj X) →+ ↑(M.obj X)) (d_mul : ∀ {X : Dᵒᵖ} (a b : ↑(R.obj X)), d (a * b) = a • d b + b • d a := by aesop_cat) (d_map : ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X)), d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) (d x) := by aesop_cat) (d_app : ∀ {X : Cᵒᵖ} (a : ↑(S.obj X)), d ((CategoryTheory.ConcreteCategory.hom (φ.app X)) a) = 0 := by aesop_cat) : M.Derivation φ - PresheafOfModules.Derivation.mk.sizeOf_spec 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ : S ⟶ F.op.comp R} [SizeOf C] [SizeOf D] (d : {X : Dᵒᵖ} → ↑(R.obj X) →+ ↑(M.obj X)) (d_mul : ∀ {X : Dᵒᵖ} (a b : ↑(R.obj X)), d (a * b) = a • d b + b • d a := by aesop_cat) (d_map : ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X)), d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) (d x) := by aesop_cat) (d_app : ∀ {X : Cᵒᵖ} (a : ↑(S.obj X)), d ((CategoryTheory.ConcreteCategory.hom (φ.app X)) a) = 0 := by aesop_cat) : sizeOf { d := d, d_mul := d_mul, d_map := d_map, d_app := d_app } = 1 - PresheafOfModules.Derivation.mk.injEq 📋 Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ CommRingCat} {M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {φ : S ⟶ F.op.comp R} (d : {X : Dᵒᵖ} → ↑(R.obj X) →+ ↑(M.obj X)) (d_mul : ∀ {X : Dᵒᵖ} (a b : ↑(R.obj X)), d (a * b) = a • d b + b • d a := by aesop_cat) (d_map : ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X)), d ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) (d x) := by aesop_cat) (d_app : ∀ {X : Cᵒᵖ} (a : ↑(S.obj X)), d ((CategoryTheory.ConcreteCategory.hom (φ.app X)) a) = 0 := by aesop_cat) (d✝ : {X : Dᵒᵖ} → ↑(R.obj X) →+ ↑(M.obj X)) (d_mul✝ : ∀ {X : Dᵒᵖ} (a b : ↑(R.obj X)), d✝ (a * b) = a • d✝ b + b • d✝ a := by aesop_cat) (d_map✝ : ∀ {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : ↑(R.obj X)), d✝ ((CategoryTheory.ConcreteCategory.hom (R.map f)) x) = (CategoryTheory.ConcreteCategory.hom (M.map f)) (d✝ x) := by aesop_cat) (d_app✝ : ∀ {X : Cᵒᵖ} (a : ↑(S.obj X)), d✝ ((CategoryTheory.ConcreteCategory.hom (φ.app X)) a) = 0 := by aesop_cat) : ({ d := d, d_mul := d_mul, d_map := d_map, d_app := d_app } = { d := d✝, d_mul := d_mul✝, d_map := d_map✝, d_app := d_app✝ }) = (d = d✝) - PresheafOfModules.colimitPresheafOfModules_map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R)) [∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), CategoryTheory.Limits.PreservesColimit (F.comp (PresheafOfModules.evaluation R Y)) (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f)))] [∀ (X : Cᵒᵖ), CategoryTheory.Limits.HasColimit (F.comp (PresheafOfModules.evaluation R X))] {x✝ Y : Cᵒᵖ} (f : x✝ ⟶ Y) : (PresheafOfModules.colimitPresheafOfModules F).map f = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft F (PresheafOfModules.restriction R f))) (CategoryTheory.preservesColimitIso (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))) (F.comp (PresheafOfModules.evaluation R Y))).inv - PresheafOfModules.limitPresheafOfModules_map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Limits
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u₂} [CategoryTheory.Category.{v₂, u₂} J] (F : CategoryTheory.Functor J (PresheafOfModules R)) [∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F.comp (PresheafOfModules.evaluation R X)).comp (CategoryTheory.forget (ModuleCat ↑(R.obj X)))).sections] {x✝ Y : Cᵒᵖ} (f : x✝ ⟶ Y) : (PresheafOfModules.limitPresheafOfModules F).map f = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.limMap (CategoryTheory.whiskerLeft F (PresheafOfModules.restriction R f))) (CategoryTheory.preservesLimitIso (ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))) (F.comp (PresheafOfModules.evaluation R Y))).inv - PresheafOfModules.restrictScalarsObj_map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.ChangeOfRings
{C : Type u'} [CategoryTheory.Category.{v', u'} C] {R R' : CategoryTheory.Functor Cᵒᵖ RingCat} (M' : PresheafOfModules R') (α : R ⟶ R') {X Y : Cᵒᵖ} (f : X ⟶ Y) : (M'.restrictScalarsObj α).map f = ModuleCat.ofHom { toFun := ⇑(CategoryTheory.ConcreteCategory.hom (M'.map f)), map_add' := ⋯, map_smul' := ⋯ } - PresheafOfModules.freeObj_map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Free
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (F : CategoryTheory.Functor Cᵒᵖ (Type u)) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (PresheafOfModules.freeObj F).map f = ModuleCat.freeDesc fun x => ModuleCat.freeMk (F.map f x) - PresheafOfModules.presheaf.eq_1 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Free
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} (M : PresheafOfModules R) : M.presheaf = { obj := fun X => (CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X), map := fun {X Y} f => AddCommGrp.ofHom (AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map f)) ⋯), map_id := ⋯, map_comp := ⋯ } - PresheafOfModules.Monoidal.tensorObj_map_tmul 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal
{C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat} {M₁ M₂ : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} {X Y : Cᵒᵖ} (f : X ⟶ Y) (m₁ : ↑(M₁.obj X)) (m₂ : ↑(M₂.obj X)) : (ModuleCat.Hom.hom ((PresheafOfModules.Monoidal.tensorObj M₁ M₂).map f)) (m₁ ⊗ₜ[↑(R.obj X)] m₂) = (CategoryTheory.ConcreteCategory.hom (M₁.map f)) m₁ ⊗ₜ[↑(R.obj Y)] (CategoryTheory.ConcreteCategory.hom (M₂.map f)) m₂ - PresheafOfModules.pushforward₀_obj_map 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (F : CategoryTheory.Functor C D) (R : CategoryTheory.Functor Dᵒᵖ RingCat) (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) : (PresheafOfModules.pushforward₀_obj F R M).map f = M.map (F.op.map f) - PresheafOfModules.pushforward_obj_map_apply 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ RingCat} {S : CategoryTheory.Functor Cᵒᵖ RingCat} (φ : S ⟶ F.op.comp R) (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (m : ↑((ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app X))).obj (M.obj (Opposite.op (F.obj (Opposite.unop X)))))) : (ModuleCat.Hom.hom (((PresheafOfModules.pushforward φ).obj M).map f)) m = (CategoryTheory.ConcreteCategory.hom (M.map (F.map f.unop).op)) m - PresheafOfModules.pushforward_obj_map_apply' 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Pushforward
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ RingCat} {S : CategoryTheory.Functor Cᵒᵖ RingCat} (φ : S ⟶ F.op.comp R) (M : PresheafOfModules R) {X Y : Cᵒᵖ} (f : X ⟶ Y) (m : ↑((ModuleCat.restrictScalars (RingCat.Hom.hom (φ.app X))).obj (M.obj (Opposite.op (F.obj (Opposite.unop X)))))) : (ModuleCat.Hom.hom (((PresheafOfModules.pushforward φ).obj M).map f)) m = (CategoryTheory.ConcreteCategory.hom (M.map (F.map f.unop).op)) m - CategoryTheory.Presieve.FamilyOfElements.isCompatible_map_smul_aux 📋 Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify
{C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {R₀ R : CategoryTheory.Functor Cᵒᵖ RingCat} (α : R₀ ⟶ R) [CategoryTheory.Presheaf.IsLocallyInjective J α] {M₀ : PresheafOfModules R₀} {A : CategoryTheory.Functor Cᵒᵖ AddCommGrp} (φ : M₀.presheaf ⟶ A) [CategoryTheory.Presheaf.IsLocallyInjective J φ] (hA : CategoryTheory.Presheaf.IsSeparated J A) {X : C} (r : ↑(R.obj (Opposite.op X))) (m : ↑(A.obj (Opposite.op X))) {Y Z : C} (f : Y ⟶ X) (g : Z ⟶ Y) (r₀ : ↑(R₀.obj (Opposite.op Y))) (r₀' : ↑(R₀.obj (Opposite.op Z))) (m₀ : ↑(M₀.obj (Opposite.op Y))) (m₀' : ↑(M₀.obj (Opposite.op Z))) (hr₀ : (CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Y))) r₀ = (CategoryTheory.ConcreteCategory.hom (R.map f.op)) r) (hr₀' : (CategoryTheory.ConcreteCategory.hom (α.app (Opposite.op Z))) r₀' = (CategoryTheory.ConcreteCategory.hom (R.map (CategoryTheory.CategoryStruct.comp f.op g.op))) r) (hm₀ : (CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Y))) m₀ = (CategoryTheory.ConcreteCategory.hom (A.map f.op)) m) (hm₀' : (CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) m₀' = (CategoryTheory.ConcreteCategory.hom (A.map (CategoryTheory.CategoryStruct.comp f.op g.op))) m) : (CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) ((CategoryTheory.ConcreteCategory.hom (M₀.map g.op)) (r₀ • m₀)) = (CategoryTheory.ConcreteCategory.hom (φ.app (Opposite.op Z))) (r₀' • m₀')
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 findtsum_lt_tsum
even though the hypothesisf 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 40fea08