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} _)).inv _ = x' from
ConcreteCategory.congr_hom
(colimit.isoColimitCocone (Types.coproductColimitCocone _)).hom_inv_id x']
rcases (colimit.isoColimitCocone (Types.coproductColimitCocone _)).hom x' with ⟨i, y⟩
exact ⟨i, y, by
simp
rfl ⟩
variable (F : C ⥤ C') | 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)).inv ≫
F.map (D.t' i j k) ≫ (PreservesPullback.iso F (D.f j k) (D.f j i)).hom
t_fac i j k := by simpa [Iso.inv_comp_eq] using congr_arg (fun f => F.map f) (D.t_fac i j k)
cocycle i j k := by
simp only [Category.assoc, Iso.hom_inv_id_assoc, ← Functor.map_comp_assoc, D.cocycle,
Iso.inv_hom_id, CategoryTheory.Functor.map_id, Category.id_comp] | 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_comp, Functor.map_id]
rfl
· erw [Category.comp_id, Category.id_comp]
rfl
· erw [Category.comp_id, Category.id_comp, Functor.map_comp]
rfl
· erw [Category.comp_id, Category.id_comp, Functor.map_id]
rfl)
@[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 | 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 ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j) :=
NatIso.ofComponents
(fun x => by
cases x
exacts [D.gluedIso F, Iso.refl _])
(by rintro (_ | _) (_ | _) (_ | _ | _) <;> simp)
apply IsLimit.postcomposeHomEquiv e _ _
apply hc.ofIsoLimit
refine Cones.ext (Iso.refl _) ?_
rintro (_ | _ | _)
all_goals simp [e]; rfl | 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 (e.hom x)
replace eq := congr_arg e.inv eq
change ((D.mapGlueData F).ι i ≫ e.inv) y = (e.hom ≫ e.inv) x at eq
rw [e.hom_inv_id, D.ι_gluedIso_inv] at eq
exact ⟨i, y, eq⟩ | 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, Mono (f i j h) := by infer_instance
f_hasPullback : ∀ i j k hij hik, HasPullback (f i j hij) (f i k hik) := by infer_instance
/-- The transition maps between the intersections. -/
t : ∀ i j h, V i j h ⟶ V j i h.symm
/-- The transition maps between the intersection of intersections. -/
t' : ∀ i j k hij hik hjk,
pullback (f i j hij) (f i k hik) ⟶ pullback (f j k hjk) (f j i hij.symm)
t_fac : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫ pullback.snd _ _ =
pullback.fst _ _ ≫ t i j hij
t_inv : ∀ i j hij, t i j hij ≫ t j i hij.symm = 𝟙 _
cocycle : ∀ i j k hij hik hjk, t' i j k hij hik hjk ≫
t' j k i hjk hij.symm hik.symm ≫ t' k i j hik.symm hjk.symm hij = 𝟙 _
attribute [local instance] GlueData'.f_mono GlueData'.f_hasPullback
attribute [reassoc (attr := simp)] GlueData'.t_inv GlueData'.cocycle
variable {C}
open scoped Classical in | 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
have : IsIso (pullback.snd (D.f' j k) (D.f' j i)) := by
subst hik; infer_instance
pullback.fst _ _ ≫ eqToHom (dif_neg hij) ≫ D.t _ _ _ ≫
eqToHom (dif_neg (Ne.symm hij)).symm ≫ inv (pullback.snd _ _)
else if hjk : j = k then
have : IsIso (pullback.snd (D.f' j k) (D.f' j i)) := by
apply (config := { allowSynthFailures := true }) pullback_snd_iso_of_left_iso
simp only [hjk, GlueData'.f', ↓reduceDIte]
infer_instance
pullback.fst _ _ ≫ eqToHom (dif_neg hij) ≫ D.t _ _ _ ≫
eqToHom (dif_neg (Ne.symm hij)).symm ≫ inv (pullback.snd _ _)
else
haveI := Ne.symm hij
pullback.map _ _ _ _ (eqToHom (by aesop)) (eqToHom (by rw [dif_neg hik]))
(eqToHom (by simp)) (by delta f'; aesop) (by delta f'; aesop) ≫
D.t' i j k hij hik hjk ≫
pullback.map _ _ _ _ (eqToHom (by aesop)) (eqToHom (by aesop)) (eqToHom (by simp))
(by delta f'; aesop) (by delta f'; aesop)
open scoped Classical in | 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 j h ≫ eqToHom (dif_neg (Ne.symm h)).symm
t_id i := by simp
t' := D.t''
t_fac i j k := by
delta GlueData'.t''
obtain rfl | _ := eq_or_ne i j
· simp
obtain rfl | _ := eq_or_ne i k
· simp [*]
obtain rfl | _ := eq_or_ne j k
· simp [*]
· simp [*, reassoc_of% D.t_fac]
cocycle i j k := by
delta GlueData'.t''
if hij : i = j then
subst hij
if hik : i = k then
subst hik
ext <;> simp
else
simp [hik, Ne.symm hik, fst_eq_snd_of_mono_eq]
else if hik : i = k then
subst hik
ext <;> simp [hij, Ne.symm hij, fst_eq_snd_of_mono_eq, pullback.condition_assoc]
else if hjk : j = k then
subst hjk
ext <;> simp [hij, Ne.symm hij, fst_eq_snd_of_mono_eq]
else
ext <;> simp [hij, Ne.symm hij, hik, Ne.symm hik, hjk, Ne.symm hjk,
pullback.map_comp_assoc] | 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 _ _ _).symm | 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]) ≪≫
(Pi.comapComp _ _ _).symm }
@[simp] | 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 where
map_injective {X Y} f g w := by
ext i
replace w := Sigma.ι (fun i : β => X i) i ≫= w
erw [colimit.ι_map, colimit.ι_map] at w
replace w : f i ≫ colimit.ι (Discrete.functor Y) ⟨i⟩ =
g i ≫ colimit.ι (Discrete.functor Y) ⟨i⟩ := by simpa
exact Mono.right_cancellation _ _ w
end GradedObject
namespace GradedObject
noncomputable section
variable (β : Type)
variable (C : Type (u + 1)) [LargeCategory C] [HasForget C] [HasCoproducts.{0} C]
[HasZeroMorphisms C]
instance : HasForget (GradedObject β C) where forget := total β C ⋙ forget C
instance : HasForget₂ (GradedObject β C) C where forget₂ := total β C
end
end GradedObject
namespace GradedObject
variable {I J K : Type*} {C : Type*} [Category C]
(X Y Z : GradedObject I C) (φ : X ⟶ Y) (e : X ≅ Y) (ψ : Y ⟶ Z) (p : I → J)
/-- If `X : GradedObject I C` and `p : I → J`, `X.mapObjFun p j` is the family of objects `X i`
for `i : I` such that `p i = j`. |
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`) if the
given cofans are. |
@[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_iff, ← hpqr, hi, hj]⟩)))
(fun s ⟨i, (hi : r i = k)⟩ => by simp)
(fun s m hm => by
apply Cofan.IsColimit.hom_ext hc'
rintro ⟨j, rfl : q j = k⟩
apply Cofan.IsColimit.hom_ext (hc j rfl)
rintro ⟨i, rfl : p i = j⟩
dsimp
rw [Cofan.IsColimit.fac, Cofan.IsColimit.fac, ← hm]
dsimp
rw [assoc])
include hpqr in | 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 = j`,
and also a colimit cofan which computes the coproduct of the points of these `c j hj`, then
the point of this latter cofan computes the coproduct of the `X i` such that `r i = k`. |
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.