fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
glued : C :=
multicoequalizer D.diagram | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | glued | The glued object given a family of gluing data. |
ι (i : D.J) : D.U i ⟶ D.glued :=
Multicoequalizer.π D.diagram i
@[elementwise (attr := simp)] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | ι | The map `D.U i ⟶ D.glued` for each `i`. |
glue_condition (i j : D.J) : D.t i j ≫ D.f j i ≫ D.ι j = D.f i j ≫ D.ι i :=
(Category.assoc _ _ _).symm.trans (Multicoequalizer.condition D.diagram ⟨i, j⟩).symm | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | glue_condition | null |
vPullbackCone (i j : D.J) : PullbackCone (D.ι i) (D.ι j) :=
PullbackCone.mk (D.f i j) (D.t i j ≫ D.f j i) (by simp)
variable [HasColimits C] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | vPullbackCone | The pullback cone spanned by `V i j ⟶ U i` and `V i j ⟶ U j`.
This will often be a pullback diagram. |
π : D.sigmaOpens ⟶ D.glued :=
Multicoequalizer.sigmaπ D.diagram | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | π | The projection `∐ D.U ⟶ D.glued` given by the colimit. |
π_epi : Epi D.π := by
unfold π
infer_instance | instance | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | π_epi | null |
types_π_surjective (D : GlueData Type*) : Function.Surjective D.π :=
(epi_iff_surjective _).mp inferInstance | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | types_π_surjective | null |
types_ι_jointly_surjective (D : GlueData (Type v)) (x : D.glued) :
∃ (i : _) (y : D.U i), D.ι i y = x := by
delta CategoryTheory.GlueData.ι
simp_rw [← Multicoequalizer.ι_sigmaπ D.diagram]
rcases D.types_π_surjective x with ⟨x', rfl⟩
rw [← show (colimit.isoColimitCocone (Types.coproductColimitCocone.{v, v} _... | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | types_ι_jointly_surjective | null |
@[simps]
mapGlueData : GlueData C' where
J := D.J
U i := F.obj (D.U i)
V i := F.obj (D.V i)
f i j := F.map (D.f i j)
f_mono _ _ := preserves_mono_of_preservesLimit _ _
f_id _ := inferInstance
t i j := F.map (D.t i j)
t_id i := by
simp
t' i j k :=
(PreservesPullback.iso F (D.f i j) (D.f i k)).i... | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | mapGlueData | A functor that preserves the pullbacks of `f i j` and `f i k` can map a family of glue data. |
diagramIso : D.diagram.multispan ⋙ F ≅ (D.mapGlueData F).diagram.multispan :=
NatIso.ofComponents
(fun x =>
match x with
| WalkingMultispan.left _ => Iso.refl _
| WalkingMultispan.right _ => Iso.refl _)
(by
rintro (⟨_, _⟩ | _) _ (_ | _ | _)
· erw [Category.comp_id, Category.id_co... | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso | The diagram of the image of a `GlueData` under a functor `F` is naturally isomorphic to the
original diagram of the `GlueData` via `F`. |
diagramIso_app_left (i : D.J × D.J) :
(D.diagramIso F).app (WalkingMultispan.left i) = Iso.refl _ :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso_app_left | null |
diagramIso_app_right (i : D.J) :
(D.diagramIso F).app (WalkingMultispan.right i) = Iso.refl _ :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso_app_right | null |
diagramIso_hom_app_left (i : D.J × D.J) :
(D.diagramIso F).hom.app (WalkingMultispan.left i) = 𝟙 _ :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso_hom_app_left | null |
diagramIso_hom_app_right (i : D.J) :
(D.diagramIso F).hom.app (WalkingMultispan.right i) = 𝟙 _ :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso_hom_app_right | null |
diagramIso_inv_app_left (i : D.J × D.J) :
(D.diagramIso F).inv.app (WalkingMultispan.left i) = 𝟙 _ :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso_inv_app_left | null |
diagramIso_inv_app_right (i : D.J) :
(D.diagramIso F).inv.app (WalkingMultispan.right i) = 𝟙 _ :=
rfl | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | diagramIso_inv_app_right | null |
hasColimit_multispan_comp : HasColimit (D.diagram.multispan ⋙ F) :=
⟨⟨⟨_, isColimitOfPreserves _ (colimit.isColimit _)⟩⟩⟩
attribute [local instance] hasColimit_multispan_comp
variable [∀ i j k, PreservesLimit (cospan (D.f i j) (D.f i k)) F] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | hasColimit_multispan_comp | null |
hasColimit_mapGlueData_diagram : HasMulticoequalizer (D.mapGlueData F).diagram :=
hasColimit_of_iso (D.diagramIso F).symm
attribute [local instance] hasColimit_mapGlueData_diagram | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | hasColimit_mapGlueData_diagram | null |
gluedIso : F.obj D.glued ≅ (D.mapGlueData F).glued :=
haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
preservesColimitIso F D.diagram.multispan ≪≫ Limits.HasColimit.isoOfNatIso (D.diagramIso F)
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | gluedIso | If `F` preserves the gluing, we obtain an iso between the glued objects. |
ι_gluedIso_hom (i : D.J) : F.map (D.ι i) ≫ (D.gluedIso F).hom = (D.mapGlueData F).ι i := by
haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
erw [ι_preservesColimitIso_hom_assoc]
rw [HasColimit.isoOfNatIso_ι_hom]
erw [Category.id_comp]
rfl
@[reassoc (attr := simp)] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | ι_gluedIso_hom | null |
ι_gluedIso_inv (i : D.J) : (D.mapGlueData F).ι i ≫ (D.gluedIso F).inv = F.map (D.ι i) := by
rw [Iso.comp_inv_eq, ι_gluedIso_hom] | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | ι_gluedIso_inv | null |
vPullbackConeIsLimitOfMap (i j : D.J) [ReflectsLimit (cospan (D.ι i) (D.ι j)) F]
(hc : IsLimit ((D.mapGlueData F).vPullbackCone i j)) : IsLimit (D.vPullbackCone i j) := by
apply isLimitOfReflects F
apply (isLimitMapConePullbackConeEquiv _ _).symm _
let e : cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅
cospan... | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | vPullbackConeIsLimitOfMap | If `F` preserves the gluing, and reflects the pullback of `U i ⟶ glued` and `U j ⟶ glued`,
then `F` reflects the fact that `V_pullback_cone` is a pullback. |
ι_jointly_surjective (F : C ⥤ Type v) [PreservesColimit D.diagram.multispan F]
[∀ i j k : D.J, PreservesLimit (cospan (D.f i j) (D.f i k)) F] (x : F.obj D.glued) :
∃ (i : _) (y : F.obj (D.U i)), F.map (D.ι i) y = x := by
let e := D.gluedIso F
obtain ⟨i, y, eq⟩ := (D.mapGlueData F).types_ι_jointly_surjective... | theorem | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | ι_jointly_surjective | If there is a forgetful functor into `Type` that preserves enough (co)limits, then `D.ι` will
be jointly surjective. |
GlueData' where
/-- Indexing type of a glue data. -/
J : Type v
/-- Objects of a glue data to be glued. -/
U : J → C
/-- Objects representing the intersections. -/
V : ∀ (i j : J), i ≠ j → C
/-- The inclusion maps of the intersection into the object. -/
f : ∀ i j h, V i j h ⟶ U i
f_mono : ∀ i j h, Mon... | structure | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | GlueData' | This is a variant of `GlueData` that only requires conditions on `V (i, j)` when `i ≠ j`.
See `GlueData.ofGlueData'` |
GlueData'.f' (D : GlueData' C) (i j : D.J) :
(if h : i = j then D.U i else D.V i j h) ⟶ D.U i :=
if h : i = j then eqToHom (dif_pos h) else eqToHom (dif_neg h) ≫ D.f i j h | abbrev | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | GlueData'.f' | (Implementation detail) the constructed `GlueData.f` from a `GlueData'`. |
GlueData'.t'' (D : GlueData' C) (i j k : D.J) :
pullback (D.f' i j) (D.f' i k) ⟶ pullback (D.f' j k) (D.f' j i) :=
if hij : i = j then
(pullbackSymmetry _ _).hom ≫
pullback.map _ _ _ _ (eqToHom (by aesop)) (eqToHom (by aesop)) (eqToHom (by aesop))
(by aesop) (by aesop)
else if hik : i = k then... | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | GlueData'.t'' | (Implementation detail) the constructed `GlueData.t'` from a `GlueData'`. |
GlueData.ofGlueData' (D : GlueData' C) : GlueData C where
J := D.J
U := D.U
V ij := if h : ij.1 = ij.2 then D.U ij.1 else D.V ij.1 ij.2 h
f i j := D.f' i j
f_id i := by simp only [↓reduceDIte, GlueData'.f']; infer_instance
t i j := if h : i = j then eqToHom (by simp [h]) else
eqToHom (dif_neg h) ≫ D.t i... | def | CategoryTheory | [
"Mathlib.Tactic.CategoryTheory.Elementwise",
"Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer",
"Mathlib.CategoryTheory.Limits.Constructions.EpiMono",
"Mathlib.CategoryTheory.Limits.Preserves.Limits",
"Mathlib.CategoryTheory.Limits.Types.Shapes"
] | Mathlib/CategoryTheory/GlueData.lean | GlueData.ofGlueData' | The constructed `GlueData` of a `GlueData'`, where `GlueData'` is a variant of `GlueData` that only
requires conditions on `V (i, j)` when `i ≠ j`. |
GradedObject (β : Type w) (C : Type u) : Type max w u :=
β → C | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | GradedObject | A type synonym for `β → C`, used for `β`-graded objects in a category `C`. |
inhabitedGradedObject (β : Type w) (C : Type u) [Inhabited C] :
Inhabited (GradedObject β C) :=
⟨fun _ => Inhabited.default⟩ | instance | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | inhabitedGradedObject | null |
@[nolint unusedArguments]
GradedObjectWithShift {β : Type w} [AddCommGroup β] (_ : β) (C : Type u) : Type max w u :=
GradedObject β C | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | GradedObjectWithShift | A type synonym for `β → C`, used for `β`-graded objects in a category `C`
with a shift functor given by translation by `s`. |
@[simps!]
categoryOfGradedObjects (β : Type w) : Category.{max w v} (GradedObject β C) :=
CategoryTheory.pi fun _ => C
@[ext] | instance | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | categoryOfGradedObjects | null |
hom_ext {β : Type*} {X Y : GradedObject β C} (f g : X ⟶ Y) (h : ∀ x, f x = g x) : f = g := by
funext
apply h | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hom_ext | null |
@[simps]
eval {β : Type w} (b : β) : GradedObject β C ⥤ C where
obj X := X b
map f := f b | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | eval | The projection of a graded object to its `i`-th component. |
@[simps]
isoMk (e : ∀ i, X i ≅ Y i) : X ≅ Y where
hom i := (e i).hom
inv i := (e i).inv
variable {X Y} | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | isoMk | Constructor for isomorphisms in `GradedObject` |
isIso_of_isIso_apply (f : X ⟶ Y) [hf : ∀ i, IsIso (f i)] :
IsIso f := by
change IsIso (isoMk X Y (fun i => asIso (f i))).hom
infer_instance | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | isIso_of_isIso_apply | null |
isIso_apply_of_isIso (f : X ⟶ Y) [IsIso f] (i : β) : IsIso (f i) := by
change IsIso ((eval i).map f)
infer_instance | instance | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | isIso_apply_of_isIso | null |
@[reassoc (attr := simp)]
hom_inv_id_eval (e : X ≅ Y) (j : J) :
e.hom j ≫ e.inv j = 𝟙 _ := by
rw [← GradedObject.categoryOfGradedObjects_comp, e.hom_inv_id,
GradedObject.categoryOfGradedObjects_id]
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hom_inv_id_eval | null |
inv_hom_id_eval (e : X ≅ Y) (j : J) :
e.inv j ≫ e.hom j = 𝟙 _ := by
rw [← GradedObject.categoryOfGradedObjects_comp, e.inv_hom_id,
GradedObject.categoryOfGradedObjects_id]
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | inv_hom_id_eval | null |
map_hom_inv_id_eval (e : X ≅ Y) (F : C ⥤ D) (j : J) :
F.map (e.hom j) ≫ F.map (e.inv j) = 𝟙 _ := by
rw [← F.map_comp, ← GradedObject.categoryOfGradedObjects_comp, e.hom_inv_id,
GradedObject.categoryOfGradedObjects_id, Functor.map_id]
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | map_hom_inv_id_eval | null |
map_inv_hom_id_eval (e : X ≅ Y) (F : C ⥤ D) (j : J) :
F.map (e.inv j) ≫ F.map (e.hom j) = 𝟙 _ := by
rw [← F.map_comp, ← GradedObject.categoryOfGradedObjects_comp, e.inv_hom_id,
GradedObject.categoryOfGradedObjects_id, Functor.map_id]
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | map_inv_hom_id_eval | null |
map_hom_inv_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
(F.map (e.hom j)).app Y ≫ (F.map (e.inv j)).app Y = 𝟙 _ := by
rw [← NatTrans.comp_app, ← F.map_comp, hom_inv_id_eval,
Functor.map_id, NatTrans.id_app]
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | map_hom_inv_id_eval_app | null |
map_inv_hom_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
(F.map (e.inv j)).app Y ≫ (F.map (e.hom j)).app Y = 𝟙 _ := by
rw [← NatTrans.comp_app, ← F.map_comp, inv_hom_id_eval,
Functor.map_id, NatTrans.id_app] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | map_inv_hom_id_eval_app | null |
comap {I J : Type*} (h : J → I) : GradedObject I C ⥤ GradedObject J C :=
Pi.comap (fun _ => C) h
@[simp] | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | comap | Pull back an `I`-graded object in `C` to a `J`-graded object along a function `J → I`. |
eqToHom_proj {I : Type*} {x x' : GradedObject I C} (h : x = x') (i : I) :
(eqToHom h : x ⟶ x') i = eqToHom (funext_iff.mp h i) := by
subst h
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | eqToHom_proj | null |
@[simps]
comapEq {β γ : Type w} {f g : β → γ} (h : f = g) : comap C f ≅ comap C g where
hom := { app := fun X b => eqToHom (by dsimp; simp only [h]) }
inv := { app := fun X b => eqToHom (by dsimp; simp only [h]) } | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | comapEq | The natural isomorphism comparing between
pulling back along two propositionally equal functions. |
comapEq_symm {β γ : Type w} {f g : β → γ} (h : f = g) :
comapEq C h.symm = (comapEq C h).symm := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | comapEq_symm | null |
comapEq_trans {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h) :
comapEq C (k.trans l) = comapEq C k ≪≫ comapEq C l := by cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | comapEq_trans | null |
eqToHom_apply {β : Type w} {X Y : β → C} (h : X = Y) (b : β) :
(eqToHom h : X ⟶ Y) b = eqToHom (by rw [h]) := by
subst h
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | eqToHom_apply | null |
@[simps]
comapEquiv {β γ : Type w} (e : β ≃ γ) : GradedObject β C ≌ GradedObject γ C where
functor := comap C (e.symm : γ → β)
inverse := comap C (e : β → γ)
counitIso :=
(Pi.comapComp (fun _ => C) _ _).trans (comapEq C (by ext; simp))
unitIso :=
(comapEq C (by ext; simp)).trans (Pi.comapComp _ _ _).sym... | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | comapEquiv | The equivalence between β-graded objects and γ-graded objects,
given an equivalence between β and γ. |
hasShift {β : Type*} [AddCommGroup β] (s : β) : HasShift (GradedObjectWithShift s C) ℤ :=
hasShiftMk _ _
{ F := fun n => comap C fun b : β => b + n • s
zero := comapEq C (by cat_disch) ≪≫ Pi.comapId β fun _ => C
add := fun m n => comapEq C (by ext; dsimp; rw [add_comm m n, add_zsmul, add_assoc]) ≪≫
... | instance | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hasShift | null |
shiftFunctor_obj_apply {β : Type*} [AddCommGroup β] (s : β) (X : β → C) (t : β) (n : ℤ) :
(shiftFunctor (GradedObjectWithShift s C) n).obj X t = X (t + n • s) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | shiftFunctor_obj_apply | null |
shiftFunctor_map_apply {β : Type*} [AddCommGroup β] (s : β)
{X Y : GradedObjectWithShift s C} (f : X ⟶ Y) (t : β) (n : ℤ) :
(shiftFunctor (GradedObjectWithShift s C) n).map f t = f (t + n • s) :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | shiftFunctor_map_apply | null |
@[simp]
zero_apply [HasZeroMorphisms C] (β : Type w) (X Y : GradedObject β C) (b : β) :
(0 : X ⟶ Y) b = 0 :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | zero_apply | null |
hasZeroMorphisms [HasZeroMorphisms C] (β : Type w) :
HasZeroMorphisms.{max w v} (GradedObject β C) where | instance | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hasZeroMorphisms | null |
hasZeroObject [HasZeroObject C] [HasZeroMorphisms C] (β : Type w) :
HasZeroObject.{max w v} (GradedObject β C) := by
refine ⟨⟨fun _ => 0, fun X => ⟨⟨⟨fun b => 0⟩, fun f => ?_⟩⟩, fun X =>
⟨⟨⟨fun b => 0⟩, fun f => ?_⟩⟩⟩⟩ <;> cat_disch | instance | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hasZeroObject | null |
noncomputable total : GradedObject β C ⥤ C where
obj X := ∐ fun i : β => X i
map f := Limits.Sigma.map fun i => f i | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | total | The total object of a graded object is the coproduct of the graded components. |
mapObjFun (j : J) (i : p ⁻¹' {j}) : C := X i
variable (j : J) | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapObjFun | The `total` functor taking a graded object to the coproduct of its graded components is faithful.
To prove this, we need to know that the coprojections into the coproduct are monomorphisms,
which follows from the fact we have zero morphisms and decidable equality for the grading.
-/
instance : (total β C).Faithful wher... |
HasMap : Prop := ∀ (j : J), HasCoproduct (X.mapObjFun p j)
variable {X Y} in | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | HasMap | Given `X : GradedObject I C` and `p : I → J`, `X.HasMap p` is the condition that
for all `j : J`, the coproduct of all `X i` such `p i = j` exists. |
hasMap_of_iso (e : X ≅ Y) (p : I → J) [HasMap X p] : HasMap Y p := fun j => by
have α : Discrete.functor (X.mapObjFun p j) ≅ Discrete.functor (Y.mapObjFun p j) :=
Discrete.natIso (fun ⟨i, _⟩ => (GradedObject.eval i).mapIso e)
exact hasColimit_of_iso α.symm | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hasMap_of_iso | null |
noncomputable mapObj : GradedObject J C := fun j => ∐ (X.mapObjFun p j) | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapObj | Given `X : GradedObject I C` and `p : I → J`, `X.mapObj p` is the graded object by `J`
which in degree `j` consists of the coproduct of the `X i` such that `p i = j`. |
noncomputable ιMapObj (i : I) (j : J) (hij : p i = j) : X i ⟶ X.mapObj p j :=
Sigma.ι (X.mapObjFun p j) ⟨i, hij⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ιMapObj | The canonical inclusion `X i ⟶ X.mapObj p j` when `i : I` and `j : J` are such
that `p i = j`. |
CofanMapObjFun (j : J) : Type _ := Cofan (X.mapObjFun p j) | abbrev | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | CofanMapObjFun | Given `X : GradedObject I C`, `p : I → J` and `j : J`,
`CofanMapObjFun X p j` is the type `Cofan (X.mapObjFun p j)`. The point object of
such colimits cofans are isomorphic to `X.mapObj p j`, see `CofanMapObjFun.iso`. |
@[simp]
CofanMapObjFun.mk (j : J) (pt : C) (ι' : ∀ (i : I) (_ : p i = j), X i ⟶ pt) :
CofanMapObjFun X p j :=
Cofan.mk pt (fun ⟨i, hi⟩ => ι' i hi) | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | CofanMapObjFun.mk | Constructor for `CofanMapObjFun X p j`. |
@[simp]
noncomputable cofanMapObj (j : J) : CofanMapObjFun X p j :=
CofanMapObjFun.mk X p j (X.mapObj p j) (fun i hi => X.ιMapObj p i j hi) | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | cofanMapObj | The tautological cofan corresponding to the coproduct decomposition of `X.mapObj p j`. |
noncomputable isColimitCofanMapObj (j : J) : IsColimit (X.cofanMapObj p j) :=
colimit.isColimit _
@[ext] | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | isColimitCofanMapObj | Given `X : GradedObject I C`, `p : I → J` and `j : J`, `X.mapObj p j` satisfies
the universal property of the coproduct of those `X i` such that `p i = j`. |
mapObj_ext {A : C} {j : J} (f g : X.mapObj p j ⟶ A)
(hfg : ∀ (i : I) (hij : p i = j), X.ιMapObj p i j hij ≫ f = X.ιMapObj p i j hij ≫ g) :
f = g :=
Cofan.IsColimit.hom_ext (X.isColimitCofanMapObj p j) _ _ (fun ⟨i, hij⟩ => hfg i hij) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapObj_ext | null |
noncomputable descMapObj {A : C} {j : J} (φ : ∀ (i : I) (_ : p i = j), X i ⟶ A) :
X.mapObj p j ⟶ A :=
Cofan.IsColimit.desc (X.isColimitCofanMapObj p j) (fun ⟨i, hi⟩ => φ i hi)
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | descMapObj | This is the morphism `X.mapObj p j ⟶ A` constructed from a family of
morphisms `X i ⟶ A` for all `i : I` such that `p i = j`. |
ι_descMapObj {A : C} {j : J}
(φ : ∀ (i : I) (_ : p i = j), X i ⟶ A) (i : I) (hi : p i = j) :
X.ιMapObj p i j hi ≫ X.descMapObj p φ = φ i hi := by
apply Cofan.IsColimit.fac | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ι_descMapObj | null |
hasMap (c : ∀ j, CofanMapObjFun X p j) (hc : ∀ j, IsColimit (c j)) :
X.HasMap p := fun j => ⟨_, hc j⟩
variable {j X p}
variable [X.HasMap p]
variable {c : CofanMapObjFun X p j} (hc : IsColimit c) | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hasMap | null |
noncomputable iso : c.pt ≅ X.mapObj p j :=
IsColimit.coconePointUniqueUpToIso hc (X.isColimitCofanMapObj p j)
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | iso | If `c : CofanMapObjFun X p j` is a colimit cofan, this is the induced
isomorphism `c.pt ≅ X.mapObj p j`. |
inj_iso_hom (i : I) (hi : p i = j) :
c.inj ⟨i, hi⟩ ≫ (c.iso hc).hom = X.ιMapObj p i j hi := by
apply IsColimit.comp_coconePointUniqueUpToIso_hom
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | inj_iso_hom | null |
ιMapObj_iso_inv (i : I) (hi : p i = j) :
X.ιMapObj p i j hi ≫ (c.iso hc).inv = c.inj ⟨i, hi⟩ := by
apply IsColimit.comp_coconePointUniqueUpToIso_inv | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ιMapObj_iso_inv | null |
noncomputable mapMap : X.mapObj p ⟶ Y.mapObj p := fun j =>
X.descMapObj p (fun i hi => φ i ≫ Y.ιMapObj p i j hi)
@[reassoc (attr := simp)] | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapMap | The canonical morphism of `J`-graded objects `X.mapObj p ⟶ Y.mapObj p` induced by
a morphism `X ⟶ Y` of `I`-graded objects and a map `p : I → J`. |
ι_mapMap (i : I) (j : J) (hij : p i = j) :
X.ιMapObj p i j hij ≫ mapMap φ p j = φ i ≫ Y.ιMapObj p i j hij := by
simp only [mapMap, ι_descMapObj] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ι_mapMap | null |
congr_mapMap (φ₁ φ₂ : X ⟶ Y) (h : φ₁ = φ₂) : mapMap φ₁ p = mapMap φ₂ p := by
subst h
rfl
variable (X)
@[simp] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | congr_mapMap | null |
mapMap_id : mapMap (𝟙 X) p = 𝟙 _ := by cat_disch
variable {X Z}
@[simp, reassoc] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapMap_id | null |
mapMap_comp [Z.HasMap p] : mapMap (φ ≫ ψ) p = mapMap φ p ≫ mapMap ψ p := by cat_disch | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapMap_comp | null |
@[simps]
noncomputable mapIso : X.mapObj p ≅ Y.mapObj p where
hom := mapMap e.hom p
inv := mapMap e.inv p
variable (C) | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | mapIso | The isomorphism of `J`-graded objects `X.mapObj p ≅ Y.mapObj p` induced by an
isomorphism `X ≅ Y` of graded objects and a map `p : I → J`. |
@[simps]
noncomputable map [∀ (j : J), HasColimitsOfShape (Discrete (p ⁻¹' {j})) C] :
GradedObject I C ⥤ GradedObject J C where
obj X := X.mapObj p
map φ := mapMap φ p
variable {C} (X Y)
variable (q : J → K) (r : I → K) (hpqr : ∀ i, q (p i) = r i) | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | map | Given a map `p : I → J`, this is the functor `GradedObject I C ⥤ GradedObject J C` which
sends an `I`-object `X` to the graded object `X.mapObj p` which in degree `j : J` is given
by the coproduct of those `X i` such that `p i = j`. |
@[simp]
cofanMapObjComp : X.CofanMapObjFun r k :=
CofanMapObjFun.mk _ _ _ c'.pt (fun i hi =>
(c (p i) (by rw [hpqr, hi])).inj ⟨i, rfl⟩ ≫ c'.inj (⟨p i, by
rw [Set.mem_preimage, Set.mem_singleton_iff, hpqr, hi]⟩)) | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | cofanMapObjComp | Given maps `p : I → J`, `q : J → K` and `r : I → K` such that `q.comp p = r`,
`X : GradedObject I C`, `k : K`, the datum of cofans `X.CofanMapObjFun p j` for all
`j : J` and of a cofan for all the points of these cofans, this is a cofan of
type `X.CofanMapObjFun r k`, which is a colimit (see `isColimitCofanMapObjComp`)... |
@[simp]
isColimitCofanMapObjComp :
IsColimit (cofanMapObjComp X p q r hpqr k c c') :=
mkCofanColimit _
(fun s => Cofan.IsColimit.desc hc'
(fun ⟨j, (hj : q j = k)⟩ => Cofan.IsColimit.desc (hc j hj)
(fun ⟨i, (hi : p i = j)⟩ => s.inj ⟨i, by
simp only [Set.mem_preimage, Set.mem_singleton_i... | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | isColimitCofanMapObjComp | Given maps `p : I → J`, `q : J → K` and `r : I → K` such that `q.comp p = r`,
`X : GradedObject I C`, `k : K`, the cofan constructed by `cofanMapObjComp` is a colimit.
In other words, if we have, for all `j : J` such that `hj : q j = k`,
a colimit cofan `c j hj` which computes the coproduct of the `X i` such that `p i ... |
hasMap_comp [(X.mapObj p).HasMap q] : X.HasMap r :=
fun k => ⟨_, isColimitCofanMapObjComp X p q r hpqr k _
(fun j _ => X.isColimitCofanMapObj p j) _ ((X.mapObj p).isColimitCofanMapObj q k)⟩ | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | hasMap_comp | null |
noncomputable ιMapObjOrZero : X i ⟶ X.mapObj p j :=
if h : p i = j
then X.ιMapObj p i j h
else 0 | def | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ιMapObjOrZero | The canonical inclusion `X i ⟶ X.mapObj p j` when `p i = j`, the zero morphism otherwise. |
ιMapObjOrZero_eq (h : p i = j) : X.ιMapObjOrZero p i j = X.ιMapObj p i j h := dif_pos h | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ιMapObjOrZero_eq | null |
ιMapObjOrZero_eq_zero (h : p i ≠ j) : X.ιMapObjOrZero p i j = 0 := dif_neg h
variable {X Y} in
@[reassoc (attr := simp)] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ιMapObjOrZero_eq_zero | null |
ιMapObjOrZero_mapMap :
X.ιMapObjOrZero p i j ≫ mapMap φ p j = φ i ≫ Y.ιMapObjOrZero p i j := by
by_cases h : p i = j
· simp only [ιMapObjOrZero_eq _ _ _ _ h, ι_mapMap]
· simp only [ιMapObjOrZero_eq_zero _ _ _ _ h, zero_comp, comp_zero] | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.ConcreteCategory.Basic",
"Mathlib.CategoryTheory.Shift.Basic",
"Mathlib.Data.Set.Subsingleton",
"Mathlib.Algebra.Group.Int.Defs"
] | Mathlib/CategoryTheory/GradedObject.lean | ιMapObjOrZero_mapMap | null |
Grothendieck where
/-- The underlying object in `C` -/
base : C
/-- The object in the fiber of the base object. -/
fiber : F.obj base | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | Grothendieck | The Grothendieck construction (often written as `∫ F` in mathematics) for a functor `F : C ⥤ Cat`
gives a category whose
* objects `X` consist of `X.base : C` and `X.fiber : F.obj base`
* morphisms `f : X ⟶ Y` consist of
`base : X.base ⟶ Y.base` and
`f.fiber : (F.map base).obj X.fiber ⟶ Y.fiber` |
Hom (X Y : Grothendieck F) where
/-- The morphism between base objects. -/
base : X.base ⟶ Y.base
/-- The morphism from the pushforward to the source fiber object to the target fiber object. -/
fiber : (F.map base).obj X.fiber ⟶ Y.fiber
@[ext (iff := false)] | structure | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | Hom | A morphism in the Grothendieck category `F : C ⥤ Cat` consists of
`base : X.base ⟶ Y.base` and `f.fiber : (F.map base).obj X.fiber ⟶ Y.fiber`. |
ext {X Y : Grothendieck F} (f g : Hom X Y) (w_base : f.base = g.base)
(w_fiber : eqToHom (by rw [w_base]) ≫ f.fiber = g.fiber) : f = g := by
cases f; cases g
congr
dsimp at w_base
cat_disch | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | ext | null |
id (X : Grothendieck F) : Hom X X where
base := 𝟙 X.base
fiber := eqToHom (by simp) | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | id | The identity morphism in the Grothendieck category. |
comp {X Y Z : Grothendieck F} (f : Hom X Y) (g : Hom Y Z) : Hom X Z where
base := f.base ≫ g.base
fiber :=
eqToHom (by simp) ≫ (F.map g.base).map f.fiber ≫ g.fiber
attribute [local simp] eqToHom_map | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | comp | Composition of morphisms in the Grothendieck category. |
@[simp]
id_base (X : Grothendieck F) :
Hom.base (𝟙 X) = 𝟙 X.base :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | id_base | null |
id_fiber (X : Grothendieck F) :
Hom.fiber (𝟙 X) = eqToHom (by simp) :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | id_fiber | null |
comp_base {X Y Z : Grothendieck F} (f : X ⟶ Y) (g : Y ⟶ Z) :
(f ≫ g).base = f.base ≫ g.base :=
rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | comp_base | null |
comp_fiber {X Y Z : Grothendieck F} (f : X ⟶ Y) (g : Y ⟶ Z) :
Hom.fiber (f ≫ g) =
eqToHom (by simp) ≫ (F.map g.base).map f.fiber ≫ g.fiber :=
rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | comp_fiber | null |
congr {X Y : Grothendieck F} {f g : X ⟶ Y} (h : f = g) :
f.fiber = eqToHom (by subst h; rfl) ≫ g.fiber := by
subst h
simp
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | congr | null |
base_eqToHom {X Y : Grothendieck F} (h : X = Y) :
(eqToHom h).base = eqToHom (congrArg Grothendieck.base h) := by subst h; rfl
@[simp] | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | base_eqToHom | null |
fiber_eqToHom {X Y : Grothendieck F} (h : X = Y) :
(eqToHom h).fiber = eqToHom (by subst h; simp) := by subst h; rfl | theorem | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | fiber_eqToHom | null |
eqToHom_eq {X Y : Grothendieck F} (hF : X = Y) :
eqToHom hF = { base := eqToHom (by subst hF; rfl), fiber := eqToHom (by subst hF; simp) } := by
subst hF
rfl | lemma | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | eqToHom_eq | null |
@[simps]
transport (x : Grothendieck F) {c : C} (t : x.base ⟶ c) : Grothendieck F :=
⟨c, (F.map t).obj x.fiber⟩ | def | CategoryTheory | [
"Mathlib.CategoryTheory.Category.Cat.AsSmall",
"Mathlib.CategoryTheory.Elements",
"Mathlib.CategoryTheory.Comma.Over.Basic"
] | Mathlib/CategoryTheory/Grothendieck.lean | transport | If `F : C ⥤ Cat` is a functor and `t : c ⟶ d` is a morphism in `C`, then `transport` maps each
`c`-based element of `Grothendieck F` to a `d`-based element. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.