Imports
/-
Copyright (c) 2026 Terence Rokop. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Terence Rokop
-/
module
public import Geb.Mathlib.CategoryTheory.Grothendieck.BasicFunctors out of a Grothendieck construction
For F : C ⥤ Cat, a functor Grothendieck F ⥤ E amounts to a fiber functor
over each object of C together with a transition transformation over each
morphism of C, subject to identity and composition coherence; a natural
transformation of two such functors amounts to a transformation of fiber
functors coherent with the transitions. This module bundles each family of
data as a structure, gives the data a category structure whose morphisms are
the bundled transformations, and compares that category with the functor
category. The contravariant construction is treated alongside the covariant
one.
Main definitions
CategoryTheory.Grothendieck.FunctorFromData and
Grothendieck.functorFromData
CategoryTheory.Grothendieck.NatTransFromData and
Grothendieck.natTransFrom
CategoryTheory.Functor.leftOpEquiv
CategoryTheory.CoGrothendieck.FunctorFromData, with the constructor
FunctorFromData.mk, its accessors, and the morphism interface
natTransFromMk/natTransFromFibNat
Main statements
Grothendieck.natTransFromEquiv: the transformation data determines the
transformation, bijectively
Grothendieck.functorFromDataEquivCat and
CoGrothendieck.functorFromDataEquivCat: the category of data is equivalent
to the functor category
Implementation notes
The correspondence is an equivalence rather than an isomorphism: extracting the
fiber functors from functorFromData data restricts along Grothendieck.ι,
which recovers data.fib c up to the canonical isomorphism
ιCompFunctorFromData rather than on the nose.
functorFromData repeats the construction of mathlib's
Grothendieck.functorFrom rather than calling it. The coherence arguments of
mathlib's version carry eqToHom proof terms private to that module, and the
module system does not export them, so a definition applying it fails in the
kernel with an unknown private constant.
The contravariant data type is the covariant one for G ⋙ Cat.opFunctor,
taken in the opposite category so that its transformations run in the direction
of the codomain, with a constructor and accessors phrased in terms of morphisms
of C. Functor.leftOpEquiv supplies the transport of the equivalence; the
conversions between the two presentations of the coherence conditions are the
image and preimage of the whole equation under NatTrans.op.
Cat is a semireducible def whose morphisms are a bundled Cat.Hom, so
keyed simp/rw matching fails against generic lemmas on terms routed through
F.obj/F.map even where the two sides are definitionally equal; see
Geb/Mathlib/CategoryTheory/Grothendieck/Basic.lean § Implementation notes.
The erw steps below isolate exactly those crossings.
References
The description of functors out of a Grothendieck construction by fiberwise data is standard; see [Vistoli2008] and [JohnsonYau2021].
Tags
Grothendieck construction, contravariant, functor category, universal property
@[expose] public sectionuniverse u v u₁ v₁ u₂ v₂ u₃ v₃ u₄ v₄ u₅ v₅ u₆ v₆namespace CategoryTheoryopen CategoryTheory.Functornamespace Grothendieckvariable {C : Type u} [Category.{v} C] (F : C ⥤ Cat.{v₂, u₂})Functors out of a covariant Grothendieck construction
variable {E : Type u₃} [Category.{v₃} E]
The fiber-functor component of the data determining a functor out of
Grothendieck F: a functor on the fiber over each object of C.
variable (E) inabbrev FunctorFromFib := ∀ c, F.obj c ⥤ E
The transition component of the data determining a functor out of
Grothendieck F: for each f : c ⟶ c', a transformation from the fiber functor
over c to the fiber functor over c' precomposed with the pushforward.
abbrev FunctorFromHom (fib : FunctorFromFib F E) :=
∀ {c c' : C} (f : c ⟶ c'), fib c ⟶ (F.map f).toFunctor ⋙ fib c'The identity coherence condition on the transition component.
abbrev FunctorFromHomId (fib : FunctorFromFib F E) (hom : FunctorFromHom F fib) :=
∀ c, hom (𝟙 c) = eqToHom (C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Efib:FunctorFromFib F Ehom:FunctorFromHom F fibc:C⊢ fib c = (F.map (𝟙 c)).toFunctor ⋙ fib c C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Efib:FunctorFromFib F Ehom:FunctorFromHom F fibc:C⊢ fib c = (𝟙 (F.obj c)).toFunctor ⋙ fib c; All goals completed! 🐙)The composition coherence condition on the transition component.
abbrev FunctorFromHomComp (fib : FunctorFromFib F E) (hom : FunctorFromHom F fib) :=
∀ c₁ c₂ c₃ (f : c₁ ⟶ c₂) (g : c₂ ⟶ c₃), hom (f ≫ g) =
hom f ≫ Functor.whiskerLeft (F.map f).toFunctor (hom g) ≫
eqToHom (C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Efib:FunctorFromFib F Ehom:FunctorFromHom F fibc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (F.map f).toFunctor ⋙ (F.map g).toFunctor ⋙ fib c₃ = (F.map (f ≫ g)).toFunctor ⋙ fib c₃ C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Efib:FunctorFromFib F Ehom:FunctorFromHom F fibc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (F.map f).toFunctor ⋙ (F.map g).toFunctor ⋙ fib c₃ = (F.map f ≫ F.map g).toFunctor ⋙ fib c₃; All goals completed! 🐙)
The data determining a functor Grothendieck F ⥤ E: a fiber functor over
each object of C, a transition transformation over each morphism of C, and
the two coherence conditions.
The fiber functor over each object of C.
The transition transformation over each morphism of C.
Identity coherence.
Composition coherence.
variable (E) instructure FunctorFromData : Type (max u v u₂ v₂ u₃ v₃) where fib : FunctorFromFib F E hom : FunctorFromHom F fib hom_id : FunctorFromHomId F fib hom hom_comp : FunctorFromHomComp F fib homvariable {F}
The functor Grothendieck F ⥤ E determined by a FunctorFromData.
set_option backward.isDefEq.respectTransparency.types false indef functorFromData (data : FunctorFromData F E) : Grothendieck F ⥤ E where
obj X := (data.fib X.base).obj X.fiber
map f := (data.hom f.base).app _ ≫ (data.fib _).map f.fiber
map_id X := C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F EX:Grothendieck F⊢ (data.hom (𝟙 X).base).app X.fiber ≫ (data.fib X.base).map (𝟙 X).fiber = 𝟙 ((data.fib X.base).obj X.fiber) All goals completed! 🐙
map_comp f g := C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F EX✝:Grothendieck FY✝:Grothendieck FZ✝:Grothendieck Ff:X✝ ⟶ Y✝g:Y✝ ⟶ Z✝⊢ (data.hom (f ≫ g).base).app X✝.fiber ≫ (data.fib Z✝.base).map (f ≫ g).fiber =
((data.hom f.base).app X✝.fiber ≫ (data.fib Y✝.base).map f.fiber) ≫
(data.hom g.base).app Y✝.fiber ≫ (data.fib Z✝.base).map g.fiber All goals completed! 🐙
The FunctorFromData determined by a functor Grothendieck F ⥤ E: restrict
along the fiber inclusions, with the transitions induced by ιNatTrans.
set_option backward.isDefEq.respectTransparency false indef ofFunctorFrom (H : Grothendieck F ⥤ E) : FunctorFromData F E where
fib c := Grothendieck.ι F c ⋙ H
hom f := Functor.whiskerRight (Grothendieck.ιNatTrans f) H
hom_id c := C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:C⊢ (fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (𝟙 c) = eqToHom ⋯
C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)⊢ ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (𝟙 c)).app x = (eqToHom ⋯).app x
C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)heq:{ base := c, fiber := x } = { base := c, fiber := (F.map (𝟙 c)).toFunctor.obj x }⊢ ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (𝟙 c)).app x = (eqToHom ⋯).app x
have h : (Grothendieck.ιNatTrans (F := F) (𝟙 c)).app x = eqToHom heq := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:C⊢ (fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (𝟙 c) = eqToHom ⋯
refine Grothendieck.ext _ _ (by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)heq:{ base := c, fiber := x } = { base := c, fiber := (F.map (𝟙 c)).toFunctor.obj x }⊢ ((ιNatTrans (𝟙 c)).app x).base = (eqToHom heq).base cat_disch All goals completed! 🐙) ?_
simp only [Functor.comp_obj, Grothendieck.ιNatTrans_app_fiber,
Grothendieck.fiber_eqToHom] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)heq:{ base := c, fiber := x } = { base := c, fiber := (F.map (𝟙 c)).toFunctor.obj x }⊢ eqToHom ⋯ ≫ 𝟙 ((F.map (𝟙 c)).toFunctor.obj ((ι F c).obj x).fiber) = eqToHom ⋯
exact Category.comp_id _ C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)heq:{ base := c, fiber := x } = { base := c, fiber := (F.map (𝟙 c)).toFunctor.obj x }h:(ιNatTrans (𝟙 c)).app x = eqToHom heq⊢ ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (𝟙 c)).app x = (eqToHom ⋯).app x
simp only [Functor.whiskerRight_app, h, eqToHom_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)heq:{ base := c, fiber := x } = { base := c, fiber := (F.map (𝟙 c)).toFunctor.obj x }h:(ιNatTrans (𝟙 c)).app x = eqToHom heq⊢ H.map (eqToHom heq) = eqToHom ⋯
exact eqToHom_map H heq All goals completed! 🐙
hom_comp c₁ c₂ c₃ f g := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (f ≫ g) =
(fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) f ≫
(F.map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) g) ≫ eqToHom ⋯
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)⊢ ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (f ≫ g)).app x =
((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) f ≫
(F.map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) g) ≫ eqToHom ⋯).app
x
simp only [Functor.comp_obj, NatTrans.comp_app, Functor.whiskerRight_app,
Functor.whiskerLeft_app, eqToHom_app, Grothendieck.ιNatTrans] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map { base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
H.map { base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) } ≫
eqToHom ⋯
rw [← Category.assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
(H.map { base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
H.map { base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom ⋯ ← H.map_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map
({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom ⋯] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map
({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom ⋯
have heq : (⟨c₃, (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x)⟩ :
Grothendieck F) = ⟨c₃, (F.map (f ≫ g)).toFunctor.obj x⟩ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (f ≫ g) =
(fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) f ≫
(F.map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) g) ≫ eqToHom ⋯
congr 1 C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)⊢ (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) = (F.map (f ≫ g)).toFunctor.obj x
exact (Functor.congr_obj congr($(F.map_comp f g).toFunctor) x).symm C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map
({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom ⋯
rw [← eqToHom_map H heq, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map
({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
H.map (eqToHom heq) ← H.map_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map
(({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom heq)] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ H.map { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
H.map
(({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom heq)
congr 1 C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) } =
({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom heq
refine Grothendieck.ext _ _ (by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) }.base =
(({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom heq).base simp All goals completed! 🐙) ?_
have hb : (eqToHom heq).base = 𝟙 c₃ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (f ≫ g) =
(fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) f ≫
(F.map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) g) ≫ eqToHom ⋯
erw [Grothendieck.base_eqToHom C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ eqToHom ⋯ = 𝟙 c₃] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }⊢ eqToHom ⋯ = 𝟙 c₃
simp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃⊢ eqToHom ⋯ ≫ { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) }.fiber =
(({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom heq).fiber
have hF : (F.map (eqToHom heq).base).toFunctor = 𝟭 ↑(F.obj c₃) := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) (f ≫ g) =
(fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) f ≫
(F.map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ whiskerRight (ιNatTrans f) H) g) ≫ eqToHom ⋯
rw [hb, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃⊢ (F.map (𝟙 c₃)).toFunctor = 𝟭 ↑(F.obj c₃) F.map_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃⊢ (𝟙 (F.obj { base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) }.base)).toFunctor = 𝟭 ↑(F.obj c₃)] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃⊢ (𝟙 (F.obj { base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) }.base)).toFunctor = 𝟭 ↑(F.obj c₃)
rfl C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃hF:(F.map (eqToHom heq).base).toFunctor = 𝟭 ↑(F.obj c₃)⊢ eqToHom ⋯ ≫ { base := f ≫ g, fiber := 𝟙 ((F.map (f ≫ g)).toFunctor.obj ((ι F c₁).obj x).fiber) }.fiber =
(({ base := f, fiber := 𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber) } ≫
{ base := g, fiber := 𝟙 ((F.map g).toFunctor.obj ((ι F c₂).obj ((F.map f).toFunctor.obj x)).fiber) }) ≫
eqToHom heq).fiber
simp only [Grothendieck.comp_fiber, Category.comp_id] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃hF:(F.map (eqToHom heq).base).toFunctor = 𝟭 ↑(F.obj c₃)⊢ eqToHom ⋯ =
eqToHom ⋯ ≫
(F.map (eqToHom heq).base).toFunctor.map
(eqToHom ⋯ ≫ (F.map g).toFunctor.map (𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber))) ≫
(eqToHom heq).fiber
rw [Functor.congr_hom hF C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃hF:(F.map (eqToHom heq).base).toFunctor = 𝟭 ↑(F.obj c₃)⊢ eqToHom ⋯ =
eqToHom ⋯ ≫
(eqToHom ⋯ ≫
(𝟭 ↑(F.obj c₃)).map (eqToHom ⋯ ≫ (F.map g).toFunctor.map (𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber))) ≫
eqToHom ⋯) ≫
(eqToHom heq).fiber] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ Ec₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(F.obj c₁)heq:{ base := c₃, fiber := (F.map g).toFunctor.obj ((F.map f).toFunctor.obj x) } =
{ base := c₃, fiber := (F.map (f ≫ g)).toFunctor.obj x }hb:(eqToHom heq).base = 𝟙 c₃hF:(F.map (eqToHom heq).base).toFunctor = 𝟭 ↑(F.obj c₃)⊢ eqToHom ⋯ =
eqToHom ⋯ ≫
(eqToHom ⋯ ≫
(𝟭 ↑(F.obj c₃)).map (eqToHom ⋯ ≫ (F.map g).toFunctor.map (𝟙 ((F.map f).toFunctor.obj ((ι F c₁).obj x).fiber))) ≫
eqToHom ⋯) ≫
(eqToHom heq).fiber
simp All goals completed! 🐙
Restricting the functor determined by a FunctorFromData along a fiber
inclusion recovers the fiber functor over that object.
def ιCompFunctorFromData (data : FunctorFromData F E) (c : C) :
Grothendieck.ι F c ⋙ functorFromData data ≅ data.fib c :=
NatIso.ofComponents (fun _ ↦ Iso.refl _) (fun f ↦ by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:CX✝:↑(F.obj c)Y✝:↑(F.obj c)f:X✝ ⟶ Y✝⊢ (ι F c ⋙ functorFromData data).map f ≫ (Iso.refl ((ι F c ⋙ functorFromData data).obj Y✝)).hom =
(Iso.refl ((ι F c ⋙ functorFromData data).obj X✝)).hom ≫ (data.fib c).map f
simp [functorFromData, Grothendieck.ι, data.hom_id, eqToHom_map] All goals completed! 🐙)
The isomorphism ιCompFunctorFromData acts as the identity on objects.
@[simp]
theorem ιCompFunctorFromData_hom_app (data : FunctorFromData F E) (c : C)
(x : F.obj c) : (ιCompFunctorFromData data c).hom.app x = 𝟙 _ :=
rfl
The inverse of ιCompFunctorFromData acts as the identity on objects.
@[simp]
theorem ιCompFunctorFromData_inv_app (data : FunctorFromData F E) (c : C)
(x : F.obj c) : (ιCompFunctorFromData data c).inv.app x = 𝟙 _ :=
rflBuilding a functor from the data extracted from it recovers the functor.
def functorFromDataOfFunctorFrom (H : Grothendieck F ⥤ E) :
functorFromData (ofFunctorFrom H) ≅ H :=
NatIso.ofComponents (fun _ ↦ Iso.refl _) (fun {X Y} f ↦ by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ (functorFromData (ofFunctorFrom H)).map f ≫ (Iso.refl ((functorFromData (ofFunctorFrom H)).obj Y)).hom =
(Iso.refl ((functorFromData (ofFunctorFrom H)).obj X)).hom ≫ H.map f
simp only [functorFromData, ofFunctorFrom, Functor.comp_obj, Functor.comp_map,
Functor.whiskerRight_app, Iso.refl_hom] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ (H.map ((ιNatTrans f.base).app X.fiber) ≫ H.map ((ι F Y.base).map f.fiber)) ≫ 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) =
𝟙 (H.obj ((ι F X.base).obj X.fiber)) ≫ H.map f
have hbase : ((Grothendieck.ιNatTrans (F := F) f.base).app X.fiber ≫
(Grothendieck.ι F Y.base).map f.fiber).base = f.base := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ (functorFromData (ofFunctorFrom H)).map f ≫ (Iso.refl ((functorFromData (ofFunctorFrom H)).obj Y)).hom =
(Iso.refl ((functorFromData (ofFunctorFrom H)).obj X)).hom ≫ H.map f
erw [Grothendieck.comp_base C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ ((ιNatTrans f.base).app X.fiber).base ≫ ((ι F Y.base).map f.fiber).base = f.base] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ ((ιNatTrans f.base).app X.fiber).base ≫ ((ι F Y.base).map f.fiber).base = f.base
exact Category.comp_id _ C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ (H.map ((ιNatTrans f.base).app X.fiber) ≫ H.map ((ι F Y.base).map f.fiber)) ≫ 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) =
𝟙 (H.obj ((ι F X.base).obj X.fiber)) ≫ H.map f
have hmor : (Grothendieck.ιNatTrans (F := F) f.base).app X.fiber ≫
(Grothendieck.ι F Y.base).map f.fiber = f := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ (functorFromData (ofFunctorFrom H)).map f ≫ (Iso.refl ((functorFromData (ofFunctorFrom H)).obj Y)).hom =
(Iso.refl ((functorFromData (ofFunctorFrom H)).obj X)).hom ≫ H.map f
refine Grothendieck.ext _ _ hbase ?_ C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫ ((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).fiber = f.fiber
erw [Grothendieck.comp_fiber C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫
eqToHom ⋯ ≫
(F.map ((ι F Y.base).map f.fiber).base).toFunctor.map ((ιNatTrans f.base).app X.fiber).fiber ≫
((ι F Y.base).map f.fiber).fiber =
f.fiber] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫
eqToHom ⋯ ≫
(F.map ((ι F Y.base).map f.fiber).base).toFunctor.map ((ιNatTrans f.base).app X.fiber).fiber ≫
((ι F Y.base).map f.fiber).fiber =
f.fiber
simp only [Grothendieck.ι, Grothendieck.ιNatTrans] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫
eqToHom ⋯ ≫ (F.map (𝟙 Y.base)).toFunctor.map (𝟙 ((F.map f.base).toFunctor.obj X.fiber)) ≫ eqToHom ⋯ ≫ f.fiber =
f.fiber
erw [CategoryTheory.Functor.map_id (F.map (𝟙 Y.base)).toFunctor
((F.map f.base).toFunctor.obj X.fiber) C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫
eqToHom ⋯ ≫ 𝟙 ((F.map (𝟙 Y.base)).toFunctor.obj ((F.map f.base).toFunctor.obj X.fiber)) ≫ eqToHom ⋯ ≫ f.fiber =
f.fiber] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫
eqToHom ⋯ ≫ 𝟙 ((F.map (𝟙 Y.base)).toFunctor.obj ((F.map f.base).toFunctor.obj X.fiber)) ≫ eqToHom ⋯ ≫ f.fiber =
f.fiber
erw [Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫ eqToHom ⋯ ≫ eqToHom ⋯ ≫ f.fiber = f.fiber eqToHom_trans_assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫ eqToHom ⋯ ≫ f.fiber = f.fiber eqToHom_trans_assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ eqToHom ⋯ ≫ f.fiber = f.fiber eqToHom_refl, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ 𝟙 ((F.map f.base).toFunctor.obj X.fiber) ≫ f.fiber = f.fiber
Category.id_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.base⊢ f.fiber = f.fiber] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.basehmor:(ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber = f⊢ (H.map ((ιNatTrans f.base).app X.fiber) ≫ H.map ((ι F Y.base).map f.fiber)) ≫ 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) =
𝟙 (H.obj ((ι F X.base).obj X.fiber)) ≫ H.map f
erw [← Functor.map_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.basehmor:(ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber = f⊢ H.map ((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber) ≫ 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) =
𝟙 (H.obj ((ι F X.base).obj X.fiber)) ≫ H.map f hmor C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.basehmor:(ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber = f⊢ H.map f ≫ 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) = 𝟙 (H.obj ((ι F X.base).obj X.fiber)) ≫ H.map f] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EH:Grothendieck F ⥤ EX:Grothendieck FY:Grothendieck Ff:X ⟶ Yhbase:((ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber).base = f.basehmor:(ιNatTrans f.base).app X.fiber ≫ (ι F Y.base).map f.fiber = f⊢ H.map f ≫ 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) = 𝟙 (H.obj ((ι F X.base).obj X.fiber)) ≫ H.map f
exact (Category.comp_id _).trans (Category.id_comp _).symm All goals completed! 🐙)
The isomorphism functorFromDataOfFunctorFrom acts as the identity on
objects.
@[simp]
theorem functorFromDataOfFunctorFrom_hom_app (H : Grothendieck F ⥤ E)
(X : Grothendieck F) : (functorFromDataOfFunctorFrom H).hom.app X = 𝟙 _ :=
rfl
The inverse of functorFromDataOfFunctorFrom acts as the identity on
objects.
@[simp]
theorem functorFromDataOfFunctorFrom_inv_app (H : Grothendieck F ⥤ E)
(X : Grothendieck F) : (functorFromDataOfFunctorFrom H).inv.app X = 𝟙 _ :=
rflNatural transformations of functors out of a covariant Grothendieck
construction
variable (F)
The fiber component of the data determining a natural transformation between
functors out of Grothendieck F.
abbrev NatTransFromFib (dataG dataH : FunctorFromData F E) :=
∀ c, dataG.fib c ⟶ dataH.fib cThe coherence condition on the fiber component: the fiber transformations commute with the transition transformations.
abbrev NatTransFromCoherence (dataG dataH : FunctorFromData F E)
(fibNat : NatTransFromFib F dataG dataH) :=
∀ {c c' : C} (f : c ⟶ c'),
dataG.hom f ≫ Functor.whiskerLeft (F.map f).toFunctor (fibNat c') =
fibNat c ≫ dataH.hom f
The data determining a natural transformation between functors out of
Grothendieck F: a transformation of fiber functors over each object of C,
coherent with the transition transformations.
The transformation of fiber functors over each object of C.
Coherence with the transition transformations.
@[ext]
structure NatTransFromData (dataG dataH : FunctorFromData F E) :
Type (max u u₂ v₃) where fibNat : NatTransFromFib F dataG dataH coherence : NatTransFromCoherence F dataG dataH fibNatvariable {F}
The natural transformation determined by a NatTransFromData.
def natTransFrom {dataG dataH : FunctorFromData F E}
(nat : NatTransFromData F dataG dataH) :
functorFromData dataG ⟶ functorFromData dataH where
app X := (nat.fibNat X.base).app X.fiber
naturality {X Y} f := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Y⊢ (functorFromData dataG).map f ≫ (nat.fibNat Y.base).app Y.fiber =
(nat.fibNat X.base).app X.fiber ≫ (functorFromData dataH).map f
have h := congrFun (congrArg NatTrans.app (nat.coherence f.base)) X.fiber C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base ≫ (F.map f.base).toFunctor.whiskerLeft (nat.fibNat Y.base)).app X.fiber =
(nat.fibNat X.base ≫ dataH.hom f.base).app X.fiber⊢ (functorFromData dataG).map f ≫ (nat.fibNat Y.base).app Y.fiber =
(nat.fibNat X.base).app X.fiber ≫ (functorFromData dataH).map f
simp only [NatTrans.comp_app, Functor.whiskerLeft_app] at h C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber⊢ (functorFromData dataG).map f ≫ (nat.fibNat Y.base).app Y.fiber =
(nat.fibNat X.base).app X.fiber ≫ (functorFromData dataH).map f
simp only [functorFromData, Category.assoc, (nat.fibNat Y.base).naturality f.fiber] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber⊢ (dataG.hom f.base).app X.fiber ≫
(nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) ≫ (dataH.fib Y.base).map f.fiber =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber ≫ (dataH.fib Y.base).map f.fiber
rw [← Category.assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber⊢ ((dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber)) ≫
(dataH.fib Y.base).map f.fiber =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber ≫ (dataH.fib Y.base).map f.fiber ← Category.assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber⊢ ((dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber)) ≫
(dataH.fib Y.base).map f.fiber =
((nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber) ≫ (dataH.fib Y.base).map f.fiber h, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber⊢ ((nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber) ≫ (dataH.fib Y.base).map f.fiber =
((nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber) ≫ (dataH.fib Y.base).map f.fiber Category.assoc C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHX:Grothendieck FY:Grothendieck Ff:X ⟶ Yh:(dataG.hom f.base).app X.fiber ≫ (nat.fibNat Y.base).app ((F.map f.base).toFunctor.obj X.fiber) =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber⊢ (nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber ≫ (dataH.fib Y.base).map f.fiber =
(nat.fibNat X.base).app X.fiber ≫ (dataH.hom f.base).app X.fiber ≫ (dataH.fib Y.base).map f.fiber] All goals completed! 🐙
The NatTransFromData determined by a natural transformation between
functors out of Grothendieck F.
def ofNatTransFrom {dataG dataH : FunctorFromData F E}
(α : functorFromData dataG ⟶ functorFromData dataH) :
NatTransFromData F dataG dataH where
fibNat c := (ιCompFunctorFromData dataG c).inv ≫
Functor.whiskerLeft (Grothendieck.ι F c) α ≫ (ιCompFunctorFromData dataH c).hom
coherence {c c'} f := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'⊢ dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((fun c ↦ (ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) c') =
(fun c ↦ (ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) c ≫
dataH.hom f
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((fun c ↦ (ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom)
c')).app
x =
((fun c ↦ (ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) c ≫
dataH.hom f).app
x
beta_reduce C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x
have nat := α.naturality ((Grothendieck.ιNatTrans (F := F) f).app x) C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(functorFromData dataG).map ((ιNatTrans f).app x) ≫ α.app (((F.map f).toFunctor ⋙ ι F c').obj x) =
α.app ((ι F c).obj x) ≫ (functorFromData dataH).map ((ιNatTrans f).app x)⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x
simp only [functorFromData, Grothendieck.ιNatTrans, Functor.comp_obj] at nat C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:((dataG.hom f).app ((ι F c).obj x).fiber ≫
(dataG.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).map
(𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber))) ≫
α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫
(dataH.hom f).app ((ι F c).obj x).fiber ≫
(dataH.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).map
(𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber))⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x
erw [CategoryTheory.Functor.map_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:((dataG.hom f).app ((ι F c).obj x).fiber ≫
𝟙
((dataG.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).obj
((F.map f).toFunctor.obj ((ι F c).obj x).fiber))) ≫
α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫
(dataH.hom f).app ((ι F c).obj x).fiber ≫
(dataH.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).map
(𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber))⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x CategoryTheory.Functor.map_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:((dataG.hom f).app ((ι F c).obj x).fiber ≫
𝟙
((dataG.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).obj
((F.map f).toFunctor.obj ((ι F c).obj x).fiber))) ≫
α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫
(dataH.hom f).app ((ι F c).obj x).fiber ≫
𝟙
((dataH.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).obj
((F.map f).toFunctor.obj ((ι F c).obj x).fiber))⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:((dataG.hom f).app ((ι F c).obj x).fiber ≫
𝟙
((dataG.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).obj
((F.map f).toFunctor.obj ((ι F c).obj x).fiber))) ≫
α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫
(dataH.hom f).app ((ι F c).obj x).fiber ≫
𝟙
((dataH.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).obj
((F.map f).toFunctor.obj ((ι F c).obj x).fiber))⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x at nat
erw [Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫
(dataH.hom f).app ((ι F c).obj x).fiber ≫
𝟙
((dataH.fib ((ι F c').obj ((F.map f).toFunctor.obj x)).base).obj
((F.map f).toFunctor.obj ((ι F c).obj x).fiber))⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f ≫
(F.map f).toFunctor.whiskerLeft
((ιCompFunctorFromData dataG c').inv ≫ (ι F c').whiskerLeft α ≫ (ιCompFunctorFromData dataH c').hom)).app
x =
(((ιCompFunctorFromData dataG c).inv ≫ (ι F c).whiskerLeft α ≫ (ιCompFunctorFromData dataH c).hom) ≫ dataH.hom f).app
x at nat
simp only [NatTrans.comp_app, Functor.whiskerLeft_app,
ιCompFunctorFromData_hom_app, ιCompFunctorFromData_inv_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f).app x ≫
𝟙 ((dataG.fib c').obj ((F.map f).toFunctor.obj x)) ≫
α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) ≫
𝟙 ((ι F c' ⋙ functorFromData dataH).obj ((F.map f).toFunctor.obj x)) =
(𝟙 ((dataG.fib c).obj x) ≫ α.app ((ι F c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData dataH).obj x)) ≫ (dataH.hom f).app x
erw [Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f).app x ≫
α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) ≫
𝟙 ((ι F c' ⋙ functorFromData dataH).obj ((F.map f).toFunctor.obj x)) =
(𝟙 ((dataG.fib c).obj x) ≫ α.app ((ι F c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData dataH).obj x)) ≫ (dataH.hom f).app x Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f).app x ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
(𝟙 ((dataG.fib c).obj x) ≫ α.app ((ι F c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData dataH).obj x)) ≫ (dataH.hom f).app x Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f).app x ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
(α.app ((ι F c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData dataH).obj x)) ≫ (dataH.hom f).app x Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f).app x ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) = α.app ((ι F c).obj x) ≫ (dataH.hom f).app x] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cc':Cf:c ⟶ c'x:↑(F.obj c)nat:(dataG.hom f).app ((ι F c).obj x).fiber ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) =
α.app ((ι F c).obj x) ≫ (dataH.hom f).app ((ι F c).obj x).fiber⊢ (dataG.hom f).app x ≫ α.app ((ι F c').obj ((F.map f).toFunctor.obj x)) = α.app ((ι F c).obj x) ≫ (dataH.hom f).app x
exact nat All goals completed! 🐙
The fiber components of ofNatTransFrom are the components of the
transformation at the objects of the fiber.
@[simp]
theorem ofNatTransFrom_fibNat_app {dataG dataH : FunctorFromData F E}
(α : functorFromData dataG ⟶ functorFromData dataH) (c : C) (x : F.obj c) :
((ofNatTransFrom α).fibNat c).app x = α.app ⟨c, x⟩ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cx:↑(F.obj c)⊢ ((ofNatTransFrom α).fibNat c).app x = α.app { base := c, fiber := x }
simp only [ofNatTransFrom, NatTrans.comp_app, Functor.whiskerLeft_app,
ιCompFunctorFromData_hom_app, ιCompFunctorFromData_inv_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cx:↑(F.obj c)⊢ 𝟙 ((dataG.fib c).obj x) ≫ α.app ((ι F c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData dataH).obj x) =
α.app { base := c, fiber := x }
erw [Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cx:↑(F.obj c)⊢ α.app ((ι F c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData dataH).obj x) = α.app { base := c, fiber := x } Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cx:↑(F.obj c)⊢ α.app ((ι F c).obj x) = α.app { base := c, fiber := x }] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHc:Cx:↑(F.obj c)⊢ α.app ((ι F c).obj x) = α.app { base := c, fiber := x }
rfl All goals completed! 🐙
The components of natTransFrom are the fiber components of the data at the
fiber objects.
@[simp]
theorem natTransFrom_app {dataG dataH : FunctorFromData F E}
(nat : NatTransFromData F dataG dataH) (X : Grothendieck F) :
(natTransFrom nat).app X = (nat.fibNat X.base).app X.fiber :=
rflBuilding a natural transformation from the data extracted from it recovers the transformation.
theorem natTransFrom_ofNatTransFrom {dataG dataH : FunctorFromData F E}
(α : functorFromData dataG ⟶ functorFromData dataH) :
natTransFrom (ofNatTransFrom α) = α := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataH⊢ natTransFrom (ofNatTransFrom α) = α
ext X C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Eα:functorFromData dataG ⟶ functorFromData dataHX:Grothendieck F⊢ (natTransFrom (ofNatTransFrom α)).app X = α.app X
simp only [natTransFrom_app, ofNatTransFrom_fibNat_app] All goals completed! 🐙Extracting the data from the natural transformation built on it recovers the data.
theorem ofNatTransFrom_natTransFrom {dataG dataH : FunctorFromData F E}
(nat : NatTransFromData F dataG dataH) :
ofNatTransFrom (natTransFrom nat) = nat := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataH⊢ ofNatTransFrom (natTransFrom nat) = nat
ext c x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F Enat:NatTransFromData F dataG dataHc:Cx:↑(F.obj c)⊢ ((ofNatTransFrom (natTransFrom nat)).fibNat c).app x = (nat.fibNat c).app x
simp only [ofNatTransFrom_fibNat_app, natTransFrom_app] All goals completed! 🐙
Natural transformations between functors out of Grothendieck F correspond
to their determining data.
def natTransFromEquiv (dataG dataH : FunctorFromData F E) :
NatTransFromData F dataG dataH ≃
(functorFromData dataG ⟶ functorFromData dataH) where
toFun := natTransFrom
invFun := ofNatTransFrom
left_inv := ofNatTransFrom_natTransFrom
right_inv := natTransFrom_ofNatTransFrom
The identity transformation of a FunctorFromData.
def NatTransFromData.id (data : FunctorFromData F E) :
NatTransFromData F data data where
fibNat c := 𝟙 (data.fib c)
coherence {c c'} f := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'⊢ data.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ 𝟙 (data.fib c)) c') = (fun c ↦ 𝟙 (data.fib c)) c ≫ data.hom f
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ 𝟙 (data.fib c)) c')).app x =
((fun c ↦ 𝟙 (data.fib c)) c ≫ data.hom f).app x
simp All goals completed! 🐙
Composition of transformations of FunctorFromData.
def NatTransFromData.comp {dataG dataH dataK : FunctorFromData F E}
(nat₁ : NatTransFromData F dataG dataH)
(nat₂ : NatTransFromData F dataH dataK) : NatTransFromData F dataG dataK where
fibNat c := nat₁.fibNat c ≫ nat₂.fibNat c
coherence {c c'} f := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'⊢ dataG.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c') =
(fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c ≫ dataK.hom f
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (dataG.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c')).app x =
((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c ≫ dataK.hom f).app x
have h₁ := congrFun (congrArg NatTrans.app (nat₁.coherence f)) x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f ≫ (F.map f).toFunctor.whiskerLeft (nat₁.fibNat c')).app x = (nat₁.fibNat c ≫ dataH.hom f).app x⊢ (dataG.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c')).app x =
((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c ≫ dataK.hom f).app x
have h₂ := congrFun (congrArg NatTrans.app (nat₂.coherence f)) x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f ≫ (F.map f).toFunctor.whiskerLeft (nat₁.fibNat c')).app x = (nat₁.fibNat c ≫ dataH.hom f).app xh₂:(dataH.hom f ≫ (F.map f).toFunctor.whiskerLeft (nat₂.fibNat c')).app x = (nat₂.fibNat c ≫ dataK.hom f).app x⊢ (dataG.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c')).app x =
((fun c ↦ nat₁.fibNat c ≫ nat₂.fibNat c) c ≫ dataK.hom f).app x
simp only [NatTrans.comp_app, Functor.whiskerLeft_app] at h₁ h₂ ⊢ C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₁.fibNat c).app x ≫ (dataH.hom f).app xh₂:(dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₂.fibNat c).app x ≫ (dataK.hom f).app x⊢ (dataG.hom f).app x ≫
(nat₁.fibNat c').app ((F.map f).toFunctor.obj x) ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) =
((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x
rw [← Category.assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₁.fibNat c).app x ≫ (dataH.hom f).app xh₂:(dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₂.fibNat c).app x ≫ (dataK.hom f).app x⊢ ((dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x)) ≫
(nat₂.fibNat c').app ((F.map f).toFunctor.obj x) =
((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x h₁, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₁.fibNat c).app x ≫ (dataH.hom f).app xh₂:(dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₂.fibNat c).app x ≫ (dataK.hom f).app x⊢ ((nat₁.fibNat c).app x ≫ (dataH.hom f).app x) ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) =
((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x Category.assoc, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₁.fibNat c).app x ≫ (dataH.hom f).app xh₂:(dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₂.fibNat c).app x ≫ (dataK.hom f).app x⊢ (nat₁.fibNat c).app x ≫ (dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) =
((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x h₂, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₁.fibNat c).app x ≫ (dataH.hom f).app xh₂:(dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₂.fibNat c).app x ≫ (dataK.hom f).app x⊢ (nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x ≫ (dataK.hom f).app x =
((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x ← Category.assoc C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EdataG:FunctorFromData F EdataH:FunctorFromData F EdataK:FunctorFromData F Enat₁:NatTransFromData F dataG dataHnat₂:NatTransFromData F dataH dataKc:Cc':Cf:c ⟶ c'x:↑(F.obj c)h₁:(dataG.hom f).app x ≫ (nat₁.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₁.fibNat c).app x ≫ (dataH.hom f).app xh₂:(dataH.hom f).app x ≫ (nat₂.fibNat c').app ((F.map f).toFunctor.obj x) = (nat₂.fibNat c).app x ≫ (dataK.hom f).app x⊢ ((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x =
((nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x) ≫ (dataK.hom f).app x] All goals completed! 🐙
The category of data determining functors Grothendieck F ⥤ E.
variable (F E) ininstance functorFromDataCategory : Category.{max u u₂ v₃} (FunctorFromData F E) where
Hom := NatTransFromData F
id := NatTransFromData.id
comp := NatTransFromData.comp
id_comp nat := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F Enat:NatTransFromData F X✝ Y✝⊢ (NatTransFromData.id X✝).comp nat = nat
ext c x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F Enat:NatTransFromData F X✝ Y✝c:Cx:↑(F.obj c)⊢ (((NatTransFromData.id X✝).comp nat).fibNat c).app x = (nat.fibNat c).app x
simp [NatTransFromData.comp, NatTransFromData.id] All goals completed! 🐙
comp_id nat := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F Enat:NatTransFromData F X✝ Y✝⊢ nat.comp (NatTransFromData.id Y✝) = nat
ext c x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F Enat:NatTransFromData F X✝ Y✝c:Cx:↑(F.obj c)⊢ ((nat.comp (NatTransFromData.id Y✝)).fibNat c).app x = (nat.fibNat c).app x
simp [NatTransFromData.comp, NatTransFromData.id] All goals completed! 🐙
assoc nat₁ nat₂ nat₃ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EW✝:FunctorFromData F EX✝:FunctorFromData F EY✝:FunctorFromData F EZ✝:FunctorFromData F Enat₁:NatTransFromData F W✝ X✝nat₂:NatTransFromData F X✝ Y✝nat₃:NatTransFromData F Y✝ Z✝⊢ (nat₁.comp nat₂).comp nat₃ = nat₁.comp (nat₂.comp nat₃)
ext c x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EW✝:FunctorFromData F EX✝:FunctorFromData F EY✝:FunctorFromData F EZ✝:FunctorFromData F Enat₁:NatTransFromData F W✝ X✝nat₂:NatTransFromData F X✝ Y✝nat₃:NatTransFromData F Y✝ Z✝c:Cx:↑(F.obj c)⊢ (((nat₁.comp nat₂).comp nat₃).fibNat c).app x = ((nat₁.comp (nat₂.comp nat₃)).fibNat c).app x
simp [NatTransFromData.comp] All goals completed! 🐙Composition in the category of data acts componentwise.
@[simp]
theorem comp_fibNat_app {dataG dataH dataK : FunctorFromData F E}
(nat₁ : dataG ⟶ dataH) (nat₂ : dataH ⟶ dataK) (c : C) (x : F.obj c) :
((nat₁ ≫ nat₂).fibNat c).app x =
(nat₁.fibNat c).app x ≫ (nat₂.fibNat c).app x :=
rflThe identity of the category of data acts componentwise as an identity.
@[simp]
theorem id_fibNat_app (data : FunctorFromData F E) (c : C) (x : F.obj c) :
(NatTransFromData.fibNat (𝟙 data) c).app x = 𝟙 ((data.fib c).obj x) :=
rfl
The data extracted from the functor determined by a FunctorFromData
recovers that data.
def ofFunctorFromFunctorFromData (data : FunctorFromData F E) :
data ≅ ofFunctorFrom (functorFromData data) where
hom :=
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv
coherence := fun {c c'} f ↦ by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'⊢ data.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ (ιCompFunctorFromData data c).inv) c') =
(fun c ↦ (ιCompFunctorFromData data c).inv) c ≫ (ofFunctorFrom (functorFromData data)).hom f
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f ≫ (F.map f).toFunctor.whiskerLeft ((fun c ↦ (ιCompFunctorFromData data c).inv) c')).app x =
((fun c ↦ (ιCompFunctorFromData data c).inv) c ≫ (ofFunctorFrom (functorFromData data)).hom f).app x
simp only [NatTrans.comp_app, Functor.whiskerLeft_app,
ιCompFunctorFromData_inv_app, ofFunctorFrom, Functor.whiskerRight_app,
functorFromData, Grothendieck.ιNatTrans] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app x ≫ 𝟙 ((data.fib c').obj ((F.map f).toFunctor.obj x)) =
𝟙 ((data.fib c).obj x) ≫
(data.hom f).app ((ι F c).obj x).fiber ≫
(data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).map (𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber))
erw [Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app x =
𝟙 ((data.fib c).obj x) ≫
(data.hom f).app ((ι F c).obj x).fiber ≫
(data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).map (𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber)) CategoryTheory.Functor.map_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app x =
𝟙 ((data.fib c).obj x) ≫
(data.hom f).app ((ι F c).obj x).fiber ≫
𝟙 ((data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).obj ((F.map f).toFunctor.obj ((ι F c).obj x).fiber)) Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app x = 𝟙 ((data.fib c).obj x) ≫ (data.hom f).app ((ι F c).obj x).fiber
Category.id_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app x = (data.hom f).app ((ι F c).obj x).fiber] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app x = (data.hom f).app ((ι F c).obj x).fiber
rfl All goals completed! 🐙 }
inv :=
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom
coherence := fun {c c'} f ↦ by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'⊢ (ofFunctorFrom (functorFromData data)).hom f ≫
(F.map f).toFunctor.whiskerLeft ((fun c ↦ (ιCompFunctorFromData data c).hom) c') =
(fun c ↦ (ιCompFunctorFromData data c).hom) c ≫ data.hom f
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ ((ofFunctorFrom (functorFromData data)).hom f ≫
(F.map f).toFunctor.whiskerLeft ((fun c ↦ (ιCompFunctorFromData data c).hom) c')).app
x =
((fun c ↦ (ιCompFunctorFromData data c).hom) c ≫ data.hom f).app x
simp only [NatTrans.comp_app, Functor.whiskerLeft_app,
ιCompFunctorFromData_hom_app, ofFunctorFrom, Functor.whiskerRight_app,
functorFromData, Grothendieck.ιNatTrans] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ ((data.hom f).app ((ι F c).obj x).fiber ≫
(data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).map (𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber))) ≫
𝟙
((ι F c' ⋙
{ obj := fun X ↦ (data.fib X.base).obj X.fiber,
map := fun {X Y} f ↦ (data.hom f.base).app X.fiber ≫ (data.fib Y.base).map f.fiber, map_id := ⋯,
map_comp := ⋯ }).obj
((F.map f).toFunctor.obj x)) =
𝟙
((ι F c ⋙
{ obj := fun X ↦ (data.fib X.base).obj X.fiber,
map := fun {X Y} f ↦ (data.hom f.base).app X.fiber ≫ (data.fib Y.base).map f.fiber, map_id := ⋯,
map_comp := ⋯ }).obj
x) ≫
(data.hom f).app x
erw [Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ ((data.hom f).app ((ι F c).obj x).fiber ≫
(data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).map (𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber))) ≫
𝟙
((ι F c' ⋙
{ obj := fun X ↦ (data.fib X.base).obj X.fiber,
map := fun {X Y} f ↦ (data.hom f.base).app X.fiber ≫ (data.fib Y.base).map f.fiber, map_id := ⋯,
map_comp := ⋯ }).obj
((F.map f).toFunctor.obj x)) =
(data.hom f).app x Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app ((ι F c).obj x).fiber ≫
(data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).map (𝟙 ((F.map f).toFunctor.obj ((ι F c).obj x).fiber)) =
(data.hom f).app x CategoryTheory.Functor.map_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app ((ι F c).obj x).fiber ≫
𝟙 ((data.fib (((F.map f).toFunctor ⋙ ι F c').obj x).base).obj ((F.map f).toFunctor.obj ((ι F c).obj x).fiber)) =
(data.hom f).app x
Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app ((ι F c).obj x).fiber = (data.hom f).app x] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cc':Cf:c ⟶ c'x:↑(F.obj c)⊢ (data.hom f).app ((ι F c).obj x).fiber = (data.hom f).app x
rfl All goals completed! 🐙 }
hom_inv_id := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F E⊢ { fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ } =
𝟙 data
apply NatTransFromData.ext C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F E⊢ ({ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ }).fibNat =
(𝟙 data).fibNat
funext c C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:C⊢ ({ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ }).fibNat
c =
(𝟙 data).fibNat c
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ (({ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ }).fibNat
c).app
x =
((𝟙 data).fibNat c).app x
simp only [comp_fibNat_app, id_fibNat_app, ιCompFunctorFromData_hom_app,
ιCompFunctorFromData_inv_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ 𝟙 ((data.fib c).obj x) ≫ 𝟙 ((ι F c ⋙ functorFromData data).obj x) = 𝟙 ((data.fib c).obj x)
erw [Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ 𝟙 ((data.fib c).obj x) = 𝟙 ((data.fib c).obj x)] All goals completed! 🐙
inv_hom_id := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F E⊢ { fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ } =
𝟙 (ofFunctorFrom (functorFromData data))
apply NatTransFromData.ext C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F E⊢ ({ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ }).fibNat =
(𝟙 (ofFunctorFrom (functorFromData data))).fibNat
funext c C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:C⊢ ({ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ }).fibNat
c =
(𝟙 (ofFunctorFrom (functorFromData data))).fibNat c
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ (({ fibNat := fun c ↦ (ιCompFunctorFromData data c).hom, coherence := ⋯ } ≫
{ fibNat := fun c ↦ (ιCompFunctorFromData data c).inv, coherence := ⋯ }).fibNat
c).app
x =
((𝟙 (ofFunctorFrom (functorFromData data))).fibNat c).app x
simp only [comp_fibNat_app, id_fibNat_app, ιCompFunctorFromData_hom_app,
ιCompFunctorFromData_inv_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ 𝟙 ((ι F c ⋙ functorFromData data).obj x) ≫ 𝟙 ((data.fib c).obj x) =
𝟙 (((ofFunctorFrom (functorFromData data)).fib c).obj x)
erw [Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ 𝟙 ((ι F c ⋙ functorFromData data).obj x) = 𝟙 (((ofFunctorFrom (functorFromData data)).fib c).obj x)] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Ec:Cx:↑(F.obj c)⊢ 𝟙 ((ι F c ⋙ functorFromData data).obj x) = 𝟙 (((ofFunctorFrom (functorFromData data)).fib c).obj x)
rfl All goals completed! 🐙
The fiber components of the transformation determined by
ofFunctorFromFunctorFromData are identities.
@[simp]
theorem ofFunctorFromFunctorFromData_hom_fibNat_app (data : FunctorFromData F E)
(c : C) (x : F.obj c) :
(((ofFunctorFromFunctorFromData data).hom).fibNat c).app x = 𝟙 _ :=
rflvariable (F E)
The functor from the category of data determining functors
Grothendieck F ⥤ E to that functor category.
def functorFromDataToFunctorCat : FunctorFromData F E ⥤ (Grothendieck F ⥤ E) where
obj := functorFromData
map := natTransFrom
map_id _ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Ex✝:FunctorFromData F E⊢ natTransFrom (𝟙 x✝) = 𝟙 (functorFromData x✝)
ext X C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Ex✝:FunctorFromData F EX:Grothendieck F⊢ (natTransFrom (𝟙 x✝)).app X = (𝟙 (functorFromData x✝)).app X
simp only [natTransFrom_app, id_fibNat_app, NatTrans.id_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Ex✝:FunctorFromData F EX:Grothendieck F⊢ 𝟙 ((x✝.fib X.base).obj X.fiber) = 𝟙 ((functorFromData x✝).obj X)
rfl All goals completed! 🐙
map_comp _ _ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F EZ✝:FunctorFromData F Ex✝¹:X✝ ⟶ Y✝x✝:Y✝ ⟶ Z✝⊢ natTransFrom (x✝¹ ≫ x✝) = natTransFrom x✝¹ ≫ natTransFrom x✝
ext X C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F EZ✝:FunctorFromData F Ex✝¹:X✝ ⟶ Y✝x✝:Y✝ ⟶ Z✝X:Grothendieck F⊢ (natTransFrom (x✝¹ ≫ x✝)).app X = (natTransFrom x✝¹ ≫ natTransFrom x✝).app X
simp only [natTransFrom_app, comp_fibNat_app, NatTrans.comp_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EX✝:FunctorFromData F EY✝:FunctorFromData F EZ✝:FunctorFromData F Ex✝¹:X✝ ⟶ Y✝x✝:Y✝ ⟶ Z✝X:Grothendieck F⊢ (x✝¹.fibNat X.base).app X.fiber ≫ (x✝.fibNat X.base).app X.fiber =
(x✝¹.fibNat X.base).app X.fiber ≫ (x✝.fibNat X.base).app X.fiber
rfl All goals completed! 🐙
The functor from the functor category Grothendieck F ⥤ E to the category
of data determining its objects.
def functorCatToFunctorFromData : (Grothendieck F ⥤ E) ⥤ FunctorFromData F E where
obj := ofFunctorFrom
map {G H} α := ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ α ≫
(functorFromDataOfFunctorFrom H).inv)
map_id G := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ E⊢ ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ 𝟙 G ≫ (functorFromDataOfFunctorFrom G).inv) = 𝟙 (ofFunctorFrom G)
apply NatTransFromData.ext C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ E⊢ (ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ 𝟙 G ≫ (functorFromDataOfFunctorFrom G).inv)).fibNat =
(𝟙 (ofFunctorFrom G)).fibNat
funext c C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ Ec:C⊢ (ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ 𝟙 G ≫ (functorFromDataOfFunctorFrom G).inv)).fibNat c =
(𝟙 (ofFunctorFrom G)).fibNat c
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)⊢ ((ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ 𝟙 G ≫ (functorFromDataOfFunctorFrom G).inv)).fibNat c).app x =
((𝟙 (ofFunctorFrom G)).fibNat c).app x
simp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ Ec:Cx:↑(F.obj c)⊢ 𝟙 ((functorFromData (ofFunctorFrom G)).obj { base := c, fiber := x }) = 𝟙 (((ofFunctorFrom G).fib c).obj x)
rfl All goals completed! 🐙
map_comp {G H K} α β := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ K⊢ ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ (α ≫ β) ≫ (functorFromDataOfFunctorFrom K).inv) =
ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ α ≫ (functorFromDataOfFunctorFrom H).inv) ≫
ofNatTransFrom ((functorFromDataOfFunctorFrom H).hom ≫ β ≫ (functorFromDataOfFunctorFrom K).inv)
apply NatTransFromData.ext C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ K⊢ (ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ (α ≫ β) ≫ (functorFromDataOfFunctorFrom K).inv)).fibNat =
(ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ α ≫ (functorFromDataOfFunctorFrom H).inv) ≫
ofNatTransFrom ((functorFromDataOfFunctorFrom H).hom ≫ β ≫ (functorFromDataOfFunctorFrom K).inv)).fibNat
funext c C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:C⊢ (ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ (α ≫ β) ≫ (functorFromDataOfFunctorFrom K).inv)).fibNat c =
(ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ α ≫ (functorFromDataOfFunctorFrom H).inv) ≫
ofNatTransFrom ((functorFromDataOfFunctorFrom H).hom ≫ β ≫ (functorFromDataOfFunctorFrom K).inv)).fibNat
c
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ ((ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ (α ≫ β) ≫ (functorFromDataOfFunctorFrom K).inv)).fibNat c).app
x =
((ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom ≫ α ≫ (functorFromDataOfFunctorFrom H).inv) ≫
ofNatTransFrom ((functorFromDataOfFunctorFrom H).hom ≫ β ≫ (functorFromDataOfFunctorFrom K).inv)).fibNat
c).app
x
simp only [Category.assoc, ofNatTransFrom_fibNat_app, NatTrans.comp_app,
functorFromDataOfFunctorFrom_hom_app, functorFromDataOfFunctorFrom_inv_app,
comp_fibNat_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ 𝟙 ((functorFromData (ofFunctorFrom G)).obj { base := c, fiber := x }) ≫
α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } ≫ 𝟙 (K.obj { base := c, fiber := x }) =
(𝟙 ((functorFromData (ofFunctorFrom G)).obj { base := c, fiber := x }) ≫
α.app { base := c, fiber := x } ≫ 𝟙 (H.obj { base := c, fiber := x })) ≫
𝟙 ((functorFromData (ofFunctorFrom H)).obj { base := c, fiber := x }) ≫
β.app { base := c, fiber := x } ≫ 𝟙 (K.obj { base := c, fiber := x })
erw [Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } ≫ 𝟙 (K.obj { base := c, fiber := x }) =
(𝟙 ((functorFromData (ofFunctorFrom G)).obj { base := c, fiber := x }) ≫
α.app { base := c, fiber := x } ≫ 𝟙 (H.obj { base := c, fiber := x })) ≫
𝟙 ((functorFromData (ofFunctorFrom H)).obj { base := c, fiber := x }) ≫
β.app { base := c, fiber := x } ≫ 𝟙 (K.obj { base := c, fiber := x }) Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } =
(𝟙 ((functorFromData (ofFunctorFrom G)).obj { base := c, fiber := x }) ≫
α.app { base := c, fiber := x } ≫ 𝟙 (H.obj { base := c, fiber := x })) ≫
𝟙 ((functorFromData (ofFunctorFrom H)).obj { base := c, fiber := x }) ≫ β.app { base := c, fiber := x } Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } =
(α.app { base := c, fiber := x } ≫ 𝟙 (H.obj { base := c, fiber := x })) ≫
𝟙 ((functorFromData (ofFunctorFrom H)).obj { base := c, fiber := x }) ≫ β.app { base := c, fiber := x } Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } =
α.app { base := c, fiber := x } ≫
𝟙 ((functorFromData (ofFunctorFrom H)).obj { base := c, fiber := x }) ≫ β.app { base := c, fiber := x }
Category.id_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } =
α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x }] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ EK:Grothendieck F ⥤ Eα:G ⟶ Hβ:H ⟶ Kc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x } =
α.app { base := c, fiber := x } ≫ β.app { base := c, fiber := x }
rfl All goals completed! 🐙
The fiber components of the transformation determined by
functorCatToFunctorFromData are the components of the transformation.
@[simp]
theorem functorCatToFunctorFromData_map_fibNat_app {G H : Grothendieck F ⥤ E}
(α : G ⟶ H) (c : C) (x : F.obj c) :
(((functorCatToFunctorFromData F E).map α).fibNat c).app x =
α.app ⟨c, x⟩ := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ Hc:Cx:↑(F.obj c)⊢ (((functorCatToFunctorFromData F E).map α).fibNat c).app x = α.app { base := c, fiber := x }
simp only [functorCatToFunctorFromData, ofNatTransFrom_fibNat_app,
NatTrans.comp_app, functorFromDataOfFunctorFrom_hom_app,
functorFromDataOfFunctorFrom_inv_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ Hc:Cx:↑(F.obj c)⊢ 𝟙 ((functorFromData (ofFunctorFrom G)).obj { base := c, fiber := x }) ≫
α.app { base := c, fiber := x } ≫ 𝟙 (H.obj { base := c, fiber := x }) =
α.app { base := c, fiber := x }
erw [Category.id_comp, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ Hc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } ≫ 𝟙 (H.obj { base := c, fiber := x }) = α.app { base := c, fiber := x } Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ Hc:Cx:↑(F.obj c)⊢ α.app { base := c, fiber := x } = α.app { base := c, fiber := x }] All goals completed! 🐙
The category of data determining functors Grothendieck F ⥤ E is
equivalent to that functor category.
def functorFromDataEquivCat : FunctorFromData F E ≌ (Grothendieck F ⥤ E) where
functor := functorFromDataToFunctorCat F E
inverse := functorCatToFunctorFromData F E
unitIso := NatIso.ofComponents (fun data ↦ ofFunctorFromFunctorFromData data)
(fun {data data'} nat ↦ by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'⊢ (𝟭 (FunctorFromData F E)).map nat ≫ (ofFunctorFromFunctorFromData data').hom =
(ofFunctorFromFunctorFromData data).hom ≫ (functorFromDataToFunctorCat F E ⋙ functorCatToFunctorFromData F E).map nat
apply NatTransFromData.ext C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'⊢ ((𝟭 (FunctorFromData F E)).map nat ≫ (ofFunctorFromFunctorFromData data').hom).fibNat =
((ofFunctorFromFunctorFromData data).hom ≫
(functorFromDataToFunctorCat F E ⋙ functorCatToFunctorFromData F E).map nat).fibNat
funext c C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'c:C⊢ ((𝟭 (FunctorFromData F E)).map nat ≫ (ofFunctorFromFunctorFromData data').hom).fibNat c =
((ofFunctorFromFunctorFromData data).hom ≫
(functorFromDataToFunctorCat F E ⋙ functorCatToFunctorFromData F E).map nat).fibNat
c
ext x C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'c:Cx:↑(F.obj c)⊢ (((𝟭 (FunctorFromData F E)).map nat ≫ (ofFunctorFromFunctorFromData data').hom).fibNat c).app x =
(((ofFunctorFromFunctorFromData data).hom ≫
(functorFromDataToFunctorCat F E ⋙ functorCatToFunctorFromData F E).map nat).fibNat
c).app
x
simp only [Functor.id_map, Functor.comp_map, functorFromDataToFunctorCat,
comp_fibNat_app, functorCatToFunctorFromData_map_fibNat_app,
natTransFrom_app, ofFunctorFromFunctorFromData_hom_fibNat_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'c:Cx:↑(F.obj c)⊢ (nat.fibNat c).app x ≫ 𝟙 ((data'.fib c).obj x) = 𝟙 ((data.fib c).obj x) ≫ (nat.fibNat c).app x
erw [Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'c:Cx:↑(F.obj c)⊢ (nat.fibNat c).app x = 𝟙 ((data.fib c).obj x) ≫ (nat.fibNat c).app x Category.id_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F Edata':FunctorFromData F Enat:data ⟶ data'c:Cx:↑(F.obj c)⊢ (nat.fibNat c).app x = (nat.fibNat c).app x] All goals completed! 🐙)
counitIso := NatIso.ofComponents (fun H ↦ functorFromDataOfFunctorFrom H)
(fun {G H} α ↦ by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ H⊢ (functorCatToFunctorFromData F E ⋙ functorFromDataToFunctorCat F E).map α ≫ (functorFromDataOfFunctorFrom H).hom =
(functorFromDataOfFunctorFrom G).hom ≫ (𝟭 (Grothendieck F ⥤ E)).map α
ext X C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ HX:Grothendieck F⊢ ((functorCatToFunctorFromData F E ⋙ functorFromDataToFunctorCat F E).map α ≫ (functorFromDataOfFunctorFrom H).hom).app
X =
((functorFromDataOfFunctorFrom G).hom ≫ (𝟭 (Grothendieck F ⥤ E)).map α).app X
simp only [Functor.id_map, Functor.comp_map, functorFromDataToFunctorCat,
NatTrans.comp_app, functorCatToFunctorFromData_map_fibNat_app,
natTransFrom_app, functorFromDataOfFunctorFrom_hom_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ HX:Grothendieck F⊢ α.app { base := X.base, fiber := X.fiber } ≫ 𝟙 ((functorFromData (ofFunctorFrom H)).obj X) =
𝟙 ((functorFromData (ofFunctorFrom G)).obj X) ≫ α.app X
erw [Category.comp_id, C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ HX:Grothendieck F⊢ α.app { base := X.base, fiber := X.fiber } = 𝟙 ((functorFromData (ofFunctorFrom G)).obj X) ≫ α.app X Category.id_comp C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F ⥤ EH:Grothendieck F ⥤ Eα:G ⟶ HX:Grothendieck F⊢ α.app { base := X.base, fiber := X.fiber } = α.app X] All goals completed! 🐙)
functor_unitIso_comp data := by C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F E⊢ (functorFromDataToFunctorCat F E).map
((NatIso.ofComponents (fun data ↦ ofFunctorFromFunctorFromData data) ⋯).hom.app data) ≫
(NatIso.ofComponents (fun H ↦ functorFromDataOfFunctorFrom H) ⋯).hom.app
((functorFromDataToFunctorCat F E).obj data) =
𝟙 ((functorFromDataToFunctorCat F E).obj data)
ext X C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F EX:Grothendieck F⊢ ((functorFromDataToFunctorCat F E).map
((NatIso.ofComponents (fun data ↦ ofFunctorFromFunctorFromData data) ⋯).hom.app data) ≫
(NatIso.ofComponents (fun H ↦ functorFromDataOfFunctorFrom H) ⋯).hom.app
((functorFromDataToFunctorCat F E).obj data)).app
X =
(𝟙 ((functorFromDataToFunctorCat F E).obj data)).app X
simp only [functorFromDataToFunctorCat, natTransFrom_app, NatTrans.comp_app,
NatTrans.id_app] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F EX:Grothendieck F⊢ (((NatIso.ofComponents (fun data ↦ ofFunctorFromFunctorFromData data) ⋯).hom.app data).fibNat X.base).app X.fiber ≫
((NatIso.ofComponents (fun H ↦ functorFromDataOfFunctorFrom H) ⋯).hom.app (functorFromData data)).app X =
𝟙 ((functorFromData data).obj X)
erw [Category.comp_id C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F EX:Grothendieck F⊢ (((NatIso.ofComponents (fun data ↦ ofFunctorFromFunctorFromData data) ⋯).hom.app data).fibNat X.base).app X.fiber =
𝟙 ((functorFromData data).obj X)] C:Type uinst✝¹:Category.{v, u} CF:C ⥤ CatE:Type u₃inst✝:Category.{v₃, u₃} Edata:FunctorFromData F EX:Grothendieck F⊢ (((NatIso.ofComponents (fun data ↦ ofFunctorFromFunctorFromData data) ⋯).hom.app data).fibNat X.base).app X.fiber =
𝟙 ((functorFromData data).obj X)
rfl All goals completed! 🐙variable {F E}end Grothendiecknamespace FunctorFunctors into an opposite category correspond, contravariantly, to functors out of the opposite of the domain.
def leftOpEquiv (A : Type u₁) [Category.{v₁} A] (B : Type u₃) [Category.{v₃} B] :
(A ⥤ Bᵒᵖ)ᵒᵖ ≌ (Aᵒᵖ ⥤ B) where
functor :=
{ obj := fun F ↦ F.unop.leftOp
map := fun η ↦ NatTrans.leftOp η.unop
map_id := fun _ ↦ by A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝:(A ⥤ Bᵒᵖ)ᵒᵖ⊢ NatTrans.leftOp (𝟙 x✝).unop = 𝟙 (Opposite.unop x✝).leftOp ext A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝¹:(A ⥤ Bᵒᵖ)ᵒᵖx✝:Aᵒᵖ⊢ (NatTrans.leftOp (𝟙 x✝¹).unop).app x✝ = (𝟙 (Opposite.unop x✝¹).leftOp).app x✝; rfl All goals completed! 🐙
map_comp := fun _ _ ↦ by A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} BX✝:(A ⥤ Bᵒᵖ)ᵒᵖY✝:(A ⥤ Bᵒᵖ)ᵒᵖZ✝:(A ⥤ Bᵒᵖ)ᵒᵖx✝¹:X✝ ⟶ Y✝x✝:Y✝ ⟶ Z✝⊢ NatTrans.leftOp (x✝¹ ≫ x✝).unop = NatTrans.leftOp x✝¹.unop ≫ NatTrans.leftOp x✝.unop ext A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} BX✝:(A ⥤ Bᵒᵖ)ᵒᵖY✝:(A ⥤ Bᵒᵖ)ᵒᵖZ✝:(A ⥤ Bᵒᵖ)ᵒᵖx✝²:X✝ ⟶ Y✝x✝¹:Y✝ ⟶ Z✝x✝:Aᵒᵖ⊢ (NatTrans.leftOp (x✝² ≫ x✝¹).unop).app x✝ = (NatTrans.leftOp x✝².unop ≫ NatTrans.leftOp x✝¹.unop).app x✝; rfl All goals completed! 🐙 }
inverse :=
{ obj := fun F ↦ Opposite.op F.rightOp
map := fun η ↦ Quiver.Hom.op (NatTrans.rightOp η)
map_id := fun _ ↦ by A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝:Aᵒᵖ ⥤ B⊢ (NatTrans.rightOp (𝟙 x✝)).op = 𝟙 (Opposite.op x✝.rightOp)
apply Quiver.Hom.unop_inj A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝:Aᵒᵖ ⥤ B⊢ (NatTrans.rightOp (𝟙 x✝)).op.unop = (𝟙 (Opposite.op x✝.rightOp)).unop
ext A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝¹:Aᵒᵖ ⥤ Bx✝:A⊢ (NatTrans.rightOp (𝟙 x✝¹)).op.unop.app x✝ = (𝟙 (Opposite.op x✝¹.rightOp)).unop.app x✝
rfl All goals completed! 🐙
map_comp := fun _ _ ↦ by A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} BX✝:Aᵒᵖ ⥤ BY✝:Aᵒᵖ ⥤ BZ✝:Aᵒᵖ ⥤ Bx✝¹:X✝ ⟶ Y✝x✝:Y✝ ⟶ Z✝⊢ (NatTrans.rightOp (x✝¹ ≫ x✝)).op = (NatTrans.rightOp x✝¹).op ≫ (NatTrans.rightOp x✝).op
apply Quiver.Hom.unop_inj A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} BX✝:Aᵒᵖ ⥤ BY✝:Aᵒᵖ ⥤ BZ✝:Aᵒᵖ ⥤ Bx✝¹:X✝ ⟶ Y✝x✝:Y✝ ⟶ Z✝⊢ (NatTrans.rightOp (x✝¹ ≫ x✝)).op.unop = ((NatTrans.rightOp x✝¹).op ≫ (NatTrans.rightOp x✝).op).unop
ext A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} BX✝:Aᵒᵖ ⥤ BY✝:Aᵒᵖ ⥤ BZ✝:Aᵒᵖ ⥤ Bx✝²:X✝ ⟶ Y✝x✝¹:Y✝ ⟶ Z✝x✝:A⊢ (NatTrans.rightOp (x✝² ≫ x✝¹)).op.unop.app x✝ = ((NatTrans.rightOp x✝²).op ≫ (NatTrans.rightOp x✝¹).op).unop.app x✝
rfl All goals completed! 🐙 }
unitIso := Iso.refl _
counitIso := Iso.refl _
functor_unitIso_comp _ := by A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝:(A ⥤ Bᵒᵖ)ᵒᵖ⊢ { obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯, map_comp := ⋯ }.map
((Iso.refl (𝟭 (A ⥤ Bᵒᵖ)ᵒᵖ)).hom.app x✝) ≫
(Iso.refl
({ obj := fun F ↦ Opposite.op F.rightOp, map := fun {X Y} η ↦ (NatTrans.rightOp η).op, map_id := ⋯,
map_comp := ⋯ } ⋙
{ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ })).hom.app
({ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ }.obj
x✝) =
𝟙
({ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ }.obj
x✝)
ext x A:Type u₁inst✝¹:Category.{v₁, u₁} AB:Type u₃inst✝:Category.{v₃, u₃} Bx✝:(A ⥤ Bᵒᵖ)ᵒᵖx:Aᵒᵖ⊢ ({ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ }.map
((Iso.refl (𝟭 (A ⥤ Bᵒᵖ)ᵒᵖ)).hom.app x✝) ≫
(Iso.refl
({ obj := fun F ↦ Opposite.op F.rightOp, map := fun {X Y} η ↦ (NatTrans.rightOp η).op, map_id := ⋯,
map_comp := ⋯ } ⋙
{ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ })).hom.app
({ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ }.obj
x✝)).app
x =
(𝟙
({ obj := fun F ↦ (Opposite.unop F).leftOp, map := fun {X Y} η ↦ NatTrans.leftOp η.unop, map_id := ⋯,
map_comp := ⋯ }.obj
x✝)).app
x
simp All goals completed! 🐙end Functornamespace CoGrothendieckvariable {C : Type u} [Category.{v} C] (G : Cᵒᵖ ⥤ Cat.{v₂, u₂})variable {T : Type u₃} [Category.{v₃} T]
The fiber-functor component of the data determining a functor out of
CoGrothendieck G: a functor on the fiber over each object of C.
variable (T) inabbrev FunctorFromFib := ∀ c : C, G.obj (Opposite.op c) ⥤ T
The transition component of the data determining a functor out of
CoGrothendieck G: for each f : c ⟶ c', a transformation from the fiber
functor over c precomposed with the pullback to the fiber functor over
c'.
abbrev FunctorFromHom (fib : FunctorFromFib G T) :=
∀ {c c' : C} (f : c ⟶ c'), (G.map f.op).toFunctor ⋙ fib c ⟶ fib c'The identity coherence condition on the transition component.
abbrev FunctorFromHomId (fib : FunctorFromFib G T) (hom : FunctorFromHom G fib) :=
∀ c, hom (𝟙 c) =
eqToHom (by C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibc:C⊢ (G.map (𝟙 c).op).toFunctor ⋙ fib c = fib c simp only [op_id, CategoryTheory.Functor.map_id] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibc:C⊢ (𝟙 (G.obj (Opposite.op c))).toFunctor ⋙ fib c = fib c; rfl All goals completed! 🐙)The composition coherence condition on the transition component.
abbrev FunctorFromHomComp (fib : FunctorFromFib G T)
(hom : FunctorFromHom G fib) :=
∀ c₁ c₂ c₃ (f : c₁ ⟶ c₂) (g : c₂ ⟶ c₃), hom (f ≫ g) =
eqToHom (by C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (G.map (f ≫ g).op).toFunctor ⋙ fib c₁ = (G.map g.op).toFunctor ⋙ (G.map f.op).toFunctor ⋙ fib c₁ simp only [op_comp, CategoryTheory.Functor.map_comp] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (G.map g.op ≫ G.map f.op).toFunctor ⋙ fib c₁ = (G.map g.op).toFunctor ⋙ (G.map f.op).toFunctor ⋙ fib c₁; rfl All goals completed! 🐙) ≫
Functor.whiskerLeft (G.map g.op).toFunctor (hom f) ≫ hom g
The data determining a functor CoGrothendieck G ⥤ T: the data determining
the corresponding functor GrothendieckOp G ⥤ Tᵒᵖ, taken in the opposite
category so that its transformations run in the direction of T.
variable (T) in@[implicit_reducible]
def FunctorFromData : Type (max u v u₂ v₂ u₃ v₃) :=
(Grothendieck.FunctorFromData (G ⋙ Cat.opFunctor) Tᵒᵖ)ᵒᵖ
The category structure on the data determining functors
CoGrothendieck G ⥤ T, inherited from the opposite of the covariant one.
instance functorFromDataCategory : Category.{max u u₂ v₃} (FunctorFromData G T) :=
inferInstanceAs
(Category (Grothendieck.FunctorFromData (G ⋙ Cat.opFunctor) Tᵒᵖ)ᵒᵖ)variable {G}
Construct the data determining a functor CoGrothendieck G ⥤ T from a fiber
functor over each object of C, a transition transformation over each morphism
of C, and the two coherence conditions.
def FunctorFromData.mk (fib : FunctorFromFib G T) (hom : FunctorFromHom G fib)
(hom_id : FunctorFromHomId G fib hom)
(hom_comp : FunctorFromHomComp G fib hom) : FunctorFromData G T :=
Opposite.op
{ fib := fun c ↦ (fib c.unop).op
hom := fun f ↦ NatTrans.op (hom f.unop)
hom_id := fun c ↦ by C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc:Cᵒᵖ⊢ (fun {c c'} f ↦ NatTrans.op (hom f.unop)) (𝟙 c) = eqToHom ⋯
ext x C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc:Cᵒᵖx:(↑(G.obj (Opposite.op (Opposite.unop c))))ᵒᵖ⊢ ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) (𝟙 c)).app x = (eqToHom ⋯).app x
simp only [NatTrans.op_app, unop_id, hom_id c.unop, eqToHom_app,
eqToHom_op] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc:Cᵒᵖx:(↑(G.obj (Opposite.op (Opposite.unop c))))ᵒᵖ⊢ eqToHom ⋯ = (eqToHom ⋯).app x
erw [eqToHom_app C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc:Cᵒᵖx:(↑(G.obj (Opposite.op (Opposite.unop c))))ᵒᵖ⊢ eqToHom ⋯ = eqToHom ⋯] All goals completed! 🐙
hom_comp := fun c₁ c₂ c₃ f g ↦ by C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (fun {c c'} f ↦ NatTrans.op (hom f.unop)) (f ≫ g) =
(fun {c c'} f ↦ NatTrans.op (hom f.unop)) f ≫
((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) g) ≫ eqToHom ⋯
ext x C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) (f ≫ g)).app x =
((fun {c c'} f ↦ NatTrans.op (hom f.unop)) f ≫
((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) g) ≫ eqToHom ⋯).app
x
erw [NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) (f ≫ g)).app x =
((fun {c c'} f ↦ NatTrans.op (hom f.unop)) f).app x ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) g) ≫ eqToHom ⋯).app x NatTrans.comp_app C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) (f ≫ g)).app x =
((fun {c c'} f ↦ NatTrans.op (hom f.unop)) f).app x ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) g)).app x ≫
(eqToHom ⋯).app x] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) (f ≫ g)).app x =
((fun {c c'} f ↦ NatTrans.op (hom f.unop)) f).app x ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft ((fun {c c'} f ↦ NatTrans.op (hom f.unop)) g)).app x ≫
(eqToHom ⋯).app x
simp only [NatTrans.op_app, unop_comp,
hom_comp c₃.unop c₂.unop c₁.unop g.unop f.unop, op_comp] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((eqToHom ⋯ ≫ (G.map f.unop.op).toFunctor.whiskerLeft (hom g.unop) ≫ hom f.unop).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x
erw [NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((eqToHom ⋯).app (Opposite.unop x) ≫
((G.map f.unop.op).toFunctor.whiskerLeft (hom g.unop) ≫ hom f.unop).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((eqToHom ⋯).app (Opposite.unop x) ≫
((G.map f.unop.op).toFunctor.whiskerLeft (hom g.unop)).app (Opposite.unop x) ≫
(hom f.unop).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x Functor.whiskerLeft_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((eqToHom ⋯).app (Opposite.unop x) ≫
(hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x)) ≫ (hom f.unop).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x
op_comp, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x)) ≫ (hom f.unop).app (Opposite.unop x)).op ≫
((eqToHom ⋯).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x op_comp, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ (((hom f.unop).app (Opposite.unop x)).op ≫ ((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op) ≫
((eqToHom ⋯).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x Category.assoc, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ ((eqToHom ⋯).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x Functor.whiskerLeft_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ ((eqToHom ⋯).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
(((G ⋙ Cat.opFunctor).map f).toFunctor.whiskerLeft (NatTrans.op (hom g.unop))).app x ≫ (eqToHom ⋯).app x
NatTrans.op_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ ((eqToHom ⋯).app (Opposite.unop x)).op =
((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app (Opposite.unop (((G ⋙ Cat.opFunctor).map f).toFunctor.obj x))).op ≫ (eqToHom ⋯).app x eqToHom_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ (eqToHom ⋯).op =
((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app (Opposite.unop (((G ⋙ Cat.opFunctor).map f).toFunctor.obj x))).op ≫ (eqToHom ⋯).app x eqToHom_op, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ eqToHom ⋯ =
((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app (Opposite.unop (((G ⋙ Cat.opFunctor).map f).toFunctor.obj x))).op ≫ (eqToHom ⋯).app x eqToHom_app C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ eqToHom ⋯ =
((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app (Opposite.unop (((G ⋙ Cat.opFunctor).map f).toFunctor.obj x))).op ≫ eqToHom ⋯] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tfib:FunctorFromFib G Thom:FunctorFromHom G fibhom_id:FunctorFromHomId G fib fun {c c'} ↦ homhom_comp:FunctorFromHomComp G fib fun {c c'} ↦ homc₁:Cᵒᵖc₂:Cᵒᵖc₃:Cᵒᵖf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:(↑(G.obj (Opposite.op (Opposite.unop c₁))))ᵒᵖ⊢ ((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app ((G.map f.unop.op).toFunctor.obj (Opposite.unop x))).op ≫ eqToHom ⋯ =
((hom f.unop).app (Opposite.unop x)).op ≫
((hom g.unop).app (Opposite.unop (((G ⋙ Cat.opFunctor).map f).toFunctor.obj x))).op ≫ eqToHom ⋯
rfl All goals completed! 🐙 }
The fiber functor over each object of C.
def FunctorFromData.fib (data : FunctorFromData G T) : FunctorFromFib G T :=
fun c ↦ (data.unop.fib (Opposite.op c)).unop
The transition transformation over each morphism of C.
def FunctorFromData.hom (data : FunctorFromData G T) :
FunctorFromHom G data.fib :=
fun f ↦ NatTrans.unop (data.unop.hom f.op)The identity coherence satisfied by the transition transformations.
theorem FunctorFromData.hom_id (data : FunctorFromData G T) :
FunctorFromHomId G data.fib data.hom := fun c ↦ by C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:C⊢ (fun {c c'} ↦ data.hom) (𝟙 c) = eqToHom ⋯
ext x C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ ((fun {c c'} ↦ data.hom) (𝟙 c)).app x = (eqToHom ⋯).app x
simp only [FunctorFromData.hom, op_id, data.unop.hom_id] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ (NatTrans.unop (eqToHom ⋯)).app x = (eqToHom ⋯).app x
erw [NatTrans.unop_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ ((eqToHom ⋯).app (Opposite.op x)).unop = (eqToHom ⋯).app x eqToHom_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ (eqToHom ⋯).unop = (eqToHom ⋯).app x eqToHom_unop, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ eqToHom ⋯ = (eqToHom ⋯).app x eqToHom_app C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ eqToHom ⋯ = eqToHom ⋯] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc:Cx:↑(G.obj (Opposite.op c))⊢ eqToHom ⋯ = eqToHom ⋯
rfl All goals completed! 🐙The composition coherence satisfied by the transition transformations.
theorem FunctorFromData.hom_comp (data : FunctorFromData G T) :
FunctorFromHomComp G data.fib data.hom := fun c₁ c₂ c₃ f g ↦ by C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃⊢ (fun {c c'} ↦ data.hom) (f ≫ g) =
eqToHom ⋯ ≫ (G.map g.op).toFunctor.whiskerLeft ((fun {c c'} ↦ data.hom) f) ≫ (fun {c c'} ↦ data.hom) g
ext x C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ ((fun {c c'} ↦ data.hom) (f ≫ g)).app x =
(eqToHom ⋯ ≫ (G.map g.op).toFunctor.whiskerLeft ((fun {c c'} ↦ data.hom) f) ≫ (fun {c c'} ↦ data.hom) g).app x
simp only [FunctorFromData.hom, op_comp, data.unop.hom_comp] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (NatTrans.unop
((Opposite.unop data).hom g.op ≫
((G ⋙ Cat.opFunctor).map g.op).toFunctor.whiskerLeft ((Opposite.unop data).hom f.op) ≫ eqToHom ⋯)).app
x =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x
erw [NatTrans.unop_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (((Opposite.unop data).hom g.op ≫
((G ⋙ Cat.opFunctor).map g.op).toFunctor.whiskerLeft ((Opposite.unop data).hom f.op) ≫ eqToHom ⋯).app
(Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (((Opposite.unop data).hom g.op).app (Opposite.op x) ≫
(((G ⋙ Cat.opFunctor).map g.op).toFunctor.whiskerLeft ((Opposite.unop data).hom f.op) ≫ eqToHom ⋯).app
(Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (((Opposite.unop data).hom g.op).app (Opposite.op x) ≫
(((G ⋙ Cat.opFunctor).map g.op).toFunctor.whiskerLeft ((Opposite.unop data).hom f.op)).app (Opposite.op x) ≫
(eqToHom ⋯).app (Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x unop_comp, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ ((((G ⋙ Cat.opFunctor).map g.op).toFunctor.whiskerLeft ((Opposite.unop data).hom f.op)).app (Opposite.op x) ≫
(eqToHom ⋯).app (Opposite.op x)).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x
unop_comp, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (((eqToHom ⋯).app (Opposite.op x)).unop ≫
((((G ⋙ Cat.opFunctor).map g.op).toFunctor.whiskerLeft ((Opposite.unop data).hom f.op)).app
(Opposite.op x)).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x Functor.whiskerLeft_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (((eqToHom ⋯).app (Opposite.op x)).unop ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x eqToHom_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ ((eqToHom ⋯).unop ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x eqToHom_unop, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯ ≫
(G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x
NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯).app x ≫
((G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op)) ≫
NatTrans.unop ((Opposite.unop data).hom g.op)).app
x NatTrans.comp_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯).app x ≫
((G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op))).app x ≫
(NatTrans.unop ((Opposite.unop data).hom g.op)).app x Functor.whiskerLeft_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯).app x ≫
((G.map g.op).toFunctor.whiskerLeft (NatTrans.unop ((Opposite.unop data).hom f.op))).app x ≫
(NatTrans.unop ((Opposite.unop data).hom g.op)).app x
NatTrans.unop_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯).app x ≫
(((Opposite.unop data).hom f.op).app (Opposite.op ((G.map g.op).toFunctor.obj x))).unop ≫
(NatTrans.unop ((Opposite.unop data).hom g.op)).app x NatTrans.unop_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
(eqToHom ⋯).app x ≫
(((Opposite.unop data).hom f.op).app (Opposite.op ((G.map g.op).toFunctor.obj x))).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop eqToHom_app, C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ (eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop) ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (Opposite.op ((G.map g.op).toFunctor.obj x))).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop Category.assoc C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (Opposite.op ((G.map g.op).toFunctor.obj x))).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop] C:Type uinst✝¹:Category.{v, u} CG:Cᵒᵖ ⥤ CatT:Type u₃inst✝:Category.{v₃, u₃} Tdata:FunctorFromData G Tc₁:Cc₂:Cc₃:Cf:c₁ ⟶ c₂g:c₂ ⟶ c₃x:↑(G.obj (Opposite.op c₃))⊢ eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (((G ⋙ Cat.opFunctor).map g.op).toFunctor.obj (Opposite.op x))).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop =
eqToHom ⋯ ≫
(((Opposite.unop data).hom f.op).app (Opposite.op ((G.map g.op).toFunctor.obj x))).unop ≫
(((Opposite.unop data).hom g.op).app (Opposite.op x)).unop
rfl All goals completed! 🐙
FunctorFromData.mk recovers the fiber functors on the nose.
@[simp]
theorem FunctorFromData.fib_mk (fib : FunctorFromFib G T)
(hom : FunctorFromHom G fib) (hom_id : FunctorFromHomId G fib hom)
(hom_comp : FunctorFromHomComp G fib hom) (c : C) :
(FunctorFromData.mk fib hom hom_id hom_comp).fib c = fib c :=
rfl
FunctorFromData.mk recovers the transition transformations on the nose.
@[simp]
theorem FunctorFromData.hom_mk (fib : FunctorFromFib G T)
(hom : FunctorFromHom G fib) (hom_id : FunctorFromHomId G fib hom)
(hom_comp : FunctorFromHomComp G fib hom) {c c' : C} (f : c ⟶ c') :
(FunctorFromData.mk fib hom hom_id hom_comp).hom f = hom f :=
rfl
The fiber component of the data determining a morphism between data
determining functors out of CoGrothendieck G.
variable (G) inabbrev NatTransFromFib (dataG dataH : FunctorFromData G T) :=
∀ c : C, dataG.fib c ⟶ dataH.fib cThe coherence condition on the fiber component: the fiber transformations commute with the transition transformations.
variable (G) inabbrev NatTransFromCoherence (dataG dataH : FunctorFromData G T)
(fibNat : NatTransFromFib G dataG dataH) :=
∀ {c c' : C} (f : c ⟶ c'),
Functor.whiskerLeft (G.map f.op).toFunctor (fibNat c) ≫ dataH.hom f =
dataG.hom f ≫ fibNat c'
Construct a morphism of the data determining functors out of
CoGrothendieck G from a fiber component and its coherence.
def natTransFromMk {dataG dataH : FunctorFromData G T}
(fibNat : NatTransFromFib G dataG dataH)
(coherence : NatTransFromCoherence G dataG dataH fibNat) : dataG ⟶ dataH :=
Quiver.Hom.op
{ fibNat := fun c ↦ NatTrans.op (fibNat c.unop)
coherence := fun {_ _} f ↦ congrArg NatTrans.op (coherence f.unop) }The fiber component of a morphism of the data.
def natTransFromFibNat {dataG dataH : FunctorFromData G T} (nat : dataG ⟶ dataH) :
NatTransFromFib G dataG dataH :=
fun c ↦ NatTrans.unop (nat.unop.fibNat (Opposite.op c))The coherence satisfied by the fiber component of a morphism of the data.
theorem natTransFromCoherence {dataG dataH : FunctorFromData G T}
(nat : dataG ⟶ dataH) :
NatTransFromCoherence G dataG dataH (natTransFromFibNat nat) :=
fun {_ _} f ↦ congrArg NatTrans.unop (nat.unop.coherence f.op)
natTransFromMk recovers the fiber component on the nose.
@[simp]
theorem natTransFromFibNat_mk {dataG dataH : FunctorFromData G T}
(fibNat : NatTransFromFib G dataG dataH)
(coherence : NatTransFromCoherence G dataG dataH fibNat) (c : C) :
natTransFromFibNat (natTransFromMk fibNat coherence) c = fibNat c :=
rflEvery morphism of the data is assembled from its own fiber component.
theorem natTransFromMk_fibNat {dataG dataH : FunctorFromData G T}
(nat : dataG ⟶ dataH)
(coherence : NatTransFromCoherence G dataG dataH (natTransFromFibNat nat)) :
natTransFromMk (natTransFromFibNat nat) coherence = nat :=
rfl
The functor CoGrothendieck G ⥤ T determined by a FunctorFromData.
def functorFromData (data : FunctorFromData G T) : CoGrothendieck G ⥤ T :=
(Grothendieck.functorFromData data.unop).leftOp
The FunctorFromData determined by a functor CoGrothendieck G ⥤ T.
def ofFunctorFrom (H : CoGrothendieck G ⥤ T) : FunctorFromData G T :=
Opposite.op (Grothendieck.ofFunctorFrom H.rightOp)variable (G T)
The category of data determining functors CoGrothendieck G ⥤ T is
equivalent to that functor category.
def functorFromDataEquivCat : FunctorFromData G T ≌ (CoGrothendieck G ⥤ T) :=
(Grothendieck.functorFromDataEquivCat (G ⋙ Cat.opFunctor) Tᵒᵖ).op.trans
(Functor.leftOpEquiv (Grothendieck (G ⋙ Cat.opFunctor)) T)variable {G T}end CoGrothendieckend CategoryTheory