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.Basic

Functors 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:Cfib 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:Cfib 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 hom
variable {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 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 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 heqH.map (eqToHom heq) = eqToHom All goals completed! 🐙 hom_comp c₁ c₂ c₃ f g := 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 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 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 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₁)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 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 }{ 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 _ _ (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 All goals completed! 🐙) ?_ 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 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 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 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 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 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 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 = 𝟙 _ := rfl

Building 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 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 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 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 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 [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 = fH.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 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 = fH.map f 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) = 𝟙 (H.obj ((ι F X.base).obj X.fiber)) H.map fC: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 = fH.map f 𝟙 (H.obj ((ι F Y.base).obj Y.fiber)) = 𝟙 (H.obj ((ι F X.base).obj X.fiber)) H.map f 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 = 𝟙 _ := rfl

Natural 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 c

The 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 fibNat
variable {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 := 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 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 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 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 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 := 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 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 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 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 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 [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 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 xC: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 [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 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 xC: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 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 [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 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 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 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 xC: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 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 := 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 } 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 [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 } 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 } 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 := rfl

Building 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 α) = α := 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 dataHnatTransFrom (ofNatTransFrom α) = α 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 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 := 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 dataHofNatTransFrom (natTransFrom nat) = nat 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 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 := 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 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 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 := 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 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 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 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 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 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 := 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 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 All goals completed! 🐙 comp_id nat := 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 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 All goals completed! 🐙 assoc nat₁ nat₂ nat₃ := 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₃) 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 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 := rfl

The 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 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 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 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 [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)) 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)) 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 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).fiberC: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 All goals completed! 🐙 } inv := { fibNat := fun c (ιCompFunctorFromData data c).hom coherence := fun {c c'} f 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 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 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 [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 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 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 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 xC: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 All goals completed! 🐙 } hom_inv_id := 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 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 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 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 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 [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 := 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)) 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 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 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 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 [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) 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 = 𝟙 _ := rfl
variable (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 _ := C:Type uinst✝¹:Category.{v, u} CF:C CatE:Type u₃inst✝:Category.{v₃, u₃} Ex✝:FunctorFromData F EnatTransFrom (𝟙 x✝) = 𝟙 (functorFromData 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 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) All goals completed! 🐙 map_comp _ _ := 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✝ 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 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 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 := C:Type uinst✝¹:Category.{v, u} CF:C CatE:Type u₃inst✝:Category.{v₃, u₃} EG:Grothendieck F EofNatTransFrom ((functorFromDataOfFunctorFrom G).hom 𝟙 G (functorFromDataOfFunctorFrom G).inv) = 𝟙 (ofFunctorFrom G) 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 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 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 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) All goals completed! 🐙 map_comp {G H K} α β := 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 KofNatTransFrom ((functorFromDataOfFunctorFrom G).hom (α β) (functorFromDataOfFunctorFrom K).inv) = ofNatTransFrom ((functorFromDataOfFunctorFrom G).hom α (functorFromDataOfFunctorFrom H).inv) ofNatTransFrom ((functorFromDataOfFunctorFrom H).hom β (functorFromDataOfFunctorFrom K).inv) 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 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 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 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 [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 }) 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 } 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 } 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 } 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 } 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 := 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 } 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 [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 } 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 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 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 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 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 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 [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 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 xAll goals completed! 🐙) counitIso := NatIso.ofComponents (fun H functorFromDataOfFunctorFrom H) (fun {G H} α 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 α 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 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 [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 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 XAll goals completed! 🐙) functor_unitIso_comp data := 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) 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 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 [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) All goals completed! 🐙
variable {F E}end Grothendiecknamespace Functor

Functors 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 _ 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 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✝; All goals completed! 🐙 map_comp := fun _ _ 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 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✝; All goals completed! 🐙 } inverse := { obj := fun F Opposite.op F.rightOp map := fun η Quiver.Hom.op (NatTrans.rightOp η) map_id := fun _ 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) 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 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✝ All goals completed! 🐙 map_comp := fun _ _ 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 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 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✝ All goals completed! 🐙 } unitIso := Iso.refl _ counitIso := Iso.refl _ functor_unitIso_comp _ := 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✝) 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 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 (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 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; 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 (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₁ 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₁; 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 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 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 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 [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 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 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 [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 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 xC: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₁))))ᵒᵖ((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 [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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 [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 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 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 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 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 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 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 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 [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 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 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 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 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 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 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 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 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 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 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 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 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 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)).unopC: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 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 c

The 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 := rfl

Every 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