File: Mathlib/Geometry/Manifold/Sheaf/Smooth.lean

full_name: smoothSheaf
code: /-- The sheaf of smooth functions from `M` to `N`, as a sheaf of types. -/
def smoothSheaf : TopCat.Sheaf (Type u) (TopCat.of M) 
goal: TopCat.Sheaf (Type u) (TopCat.of M)

full_name: smoothSheaf.coeFun
code: instance smoothSheaf.coeFun (U : (Opens (TopCat.of M))ᵒᵖ) :
    CoeFun ((smoothSheaf IM I M N).presheaf.obj U) (fun _ ↦ ↑(unop U) → N) 
goal: CoeFun ((smoothSheaf IM I M N).presheaf.obj U) fun x => ↥(Opposite.unop U) → N

full_name: smoothSheaf.obj_eq
code: /-- The object of `smoothSheaf IM I M N` for the open set `U` in `M` is
`C^∞⟮IM, (unop U : Opens M); I, N⟯`, the `(IM, I)`-smooth functions from `U` to `N`.  This is not
just a "moral" equality but a literal and definitional equality! -/
lemma smoothSheaf.obj_eq (U : (Opens (TopCat.of M))ᵒᵖ) :
    (smoothSheaf IM I M N).presheaf.obj U = C^∞⟮IM, (unop U : Opens M); I, N⟯ 
goal: (smoothSheaf IM I M N).presheaf.obj U = ContMDiffMap IM I (↥(Opposite.unop U)) N ⊤

full_name: smoothSheaf.eval
code: /-- Canonical map from the stalk of `smoothSheaf IM I M N` at `x` to `N`, given by evaluating
sections at `x`. -/
def smoothSheaf.eval (x : M) : (smoothSheaf IM I M N).presheaf.stalk x → N 
goal: (smoothSheaf IM I M N).presheaf.stalk x → N

full_name: smoothSheaf.evalHom
code: /-- Canonical map from the stalk of `smoothSheaf IM I M N` at `x` to `N`, given by evaluating
sections at `x`, considered as a morphism in the category of types. -/
def smoothSheaf.evalHom (x : TopCat.of M) : (smoothSheaf IM I M N).presheaf.stalk x ⟶ N 
goal: (smoothSheaf IM I M N).presheaf.stalk x ⟶ N

full_name: smoothSheaf.evalAt
code: /-- Given manifolds `M`, `N` and an open neighbourhood `U` of a point `x : M`, the evaluation-at-`x`
map to `N` from smooth functions from  `U` to `N`. -/
def smoothSheaf.evalAt (x : TopCat.of M) (U : OpenNhds x)
    (i : (smoothSheaf IM I M N).presheaf.obj (Opposite.op U.obj)) : N 
goal: N

full_name: smoothSheaf.ι_evalHom
code: @[simp, reassoc, elementwise] lemma smoothSheaf.ι_evalHom (x : TopCat.of M) (U) :
    colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M N).val) U ≫
    smoothSheaf.evalHom IM I N x =
    smoothSheaf.evalAt _ _ _ _ _ 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.colimit.ι ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheaf IM I M N).val) U)
    (smoothSheaf.evalHom IM I N x) =
  smoothSheaf.evalAt IM I N x (Opposite.unop U)

full_name: smoothSheaf.eval_surjective
code: /-- The `eval` map is surjective at `x`. -/
lemma smoothSheaf.eval_surjective (x : M) : Function.Surjective (smoothSheaf.eval IM I N x) 
goal: Function.Surjective (smoothSheaf.eval IM I N x)

full_name: instNontrivialStalkPresheafSmoothSheaf
code: instance [Nontrivial N] (x : M) : Nontrivial ((smoothSheaf IM I M N).presheaf.stalk x) 
goal: Nontrivial ((smoothSheaf IM I M N).presheaf.stalk x)

full_name: smoothSheaf.eval_germ
code: @[simp] lemma smoothSheaf.eval_germ (U : Opens M) (x : U)
    (f : (smoothSheaf IM I M N).presheaf.obj (op U)) :
    smoothSheaf.eval IM I N (x : M) ((smoothSheaf IM I M N).presheaf.germ x f) = f x 
goal: smoothSheaf.eval IM I N (↑x) ((smoothSheaf IM I M N).presheaf.germ x f) = ↑f x

full_name: smoothSheaf.smooth_section
code: lemma smoothSheaf.smooth_section {U : (Opens (TopCat.of M))ᵒᵖ}
    (f : (smoothSheaf IM I M N).presheaf.obj U) :
    Smooth IM I f 
goal: Smooth IM I ↑f

full_name: instGroupObjOppositeOpensαTopologicalSpaceOfPresheafSmoothSheaf
code: @[to_additive]
noncomputable instance (U : (Opens (TopCat.of M))ᵒᵖ) :
    Group ((smoothSheaf IM I M G).presheaf.obj U) 
goal: Group ((smoothSheaf IM I M G).presheaf.obj U)

full_name: instAddGroupObjOppositeOpensαTopologicalSpaceOfPresheafSmoothSheaf
code: @[to_additive]
noncomputable instance (U : (Opens (TopCat.of M))ᵒᵖ) :
    Group ((smoothSheaf IM I M G).presheaf.obj U) 
goal: AddGroup ((smoothSheaf IM I M G).presheaf.obj U)

full_name: smoothPresheafGroup
code: /-- The presheaf of smooth functions from `M` to `G`, for `G` a Lie group, as a presheaf of groups.
-/
@[to_additive "The presheaf of smooth functions from `M` to `G`, for `G` an additive Lie group, as a
presheaf of additive groups."]
noncomputable def smoothPresheafGroup : TopCat.Presheaf Grp.{u} (TopCat.of M) 
goal: TopCat.Presheaf Grp (TopCat.of M)

full_name: smoothPresheafAddGroup
code: /-- The presheaf of smooth functions from `M` to `G`, for `G` a Lie group, as a presheaf of groups.
-/
@[to_additive "The presheaf of smooth functions from `M` to `G`, for `G` an additive Lie group, as a
presheaf of additive groups."]
noncomputable def smoothPresheafGroup : TopCat.Presheaf Grp.{u} (TopCat.of M) 
goal: TopCat.Presheaf AddGrp (TopCat.of M)

full_name: smoothSheafGroup
code: /-- The sheaf of smooth functions from `M` to `G`, for `G` a Lie group, as a sheaf of
groups. -/
@[to_additive "The sheaf of smooth functions from `M` to `G`, for `G` an additive Lie group, as a
sheaf of additive groups."]
noncomputable def smoothSheafGroup : TopCat.Sheaf Grp.{u} (TopCat.of M) 
goal: TopCat.Sheaf Grp (TopCat.of M)

full_name: smoothSheafAddGroup
code: /-- The sheaf of smooth functions from `M` to `G`, for `G` a Lie group, as a sheaf of
groups. -/
@[to_additive "The sheaf of smooth functions from `M` to `G`, for `G` an additive Lie group, as a
sheaf of additive groups."]
noncomputable def smoothSheafGroup : TopCat.Sheaf Grp.{u} (TopCat.of M) 
goal: TopCat.Sheaf AddGrp (TopCat.of M)

full_name: instAddCommGroupObjOppositeOpensαTopologicalSpaceOfPresheafSmoothSheaf
code: @[to_additive] noncomputable instance (U : (Opens (TopCat.of M))ᵒᵖ) :
    CommGroup ((smoothSheaf IM I M A).presheaf.obj U) 
goal: AddCommGroup ((smoothSheaf IM I M A).presheaf.obj U)

full_name: instCommGroupObjOppositeOpensαTopologicalSpaceOfPresheafSmoothSheaf
code: @[to_additive] noncomputable instance (U : (Opens (TopCat.of M))ᵒᵖ) :
    CommGroup ((smoothSheaf IM I M A).presheaf.obj U) 
goal: CommGroup ((smoothSheaf IM I M A).presheaf.obj U)

full_name: smoothPresheafCommGroup
code: /-- The presheaf of smooth functions from `M` to `A`, for `A` an abelian Lie group, as a
presheaf of abelian groups. -/
@[to_additive "The presheaf of smooth functions from `M` to `A`, for `A` an additive abelian Lie
group, as a presheaf of additive abelian groups."]
noncomputable def smoothPresheafCommGroup : TopCat.Presheaf CommGrp.{u} (TopCat.of M) 
goal: TopCat.Presheaf CommGrp (TopCat.of M)

full_name: smoothPresheafAddCommGroup
code: /-- The presheaf of smooth functions from `M` to `A`, for `A` an abelian Lie group, as a
presheaf of abelian groups. -/
@[to_additive "The presheaf of smooth functions from `M` to `A`, for `A` an additive abelian Lie
group, as a presheaf of additive abelian groups."]
noncomputable def smoothPresheafCommGroup : TopCat.Presheaf CommGrp.{u} (TopCat.of M) 
goal: TopCat.Presheaf AddCommGrp (TopCat.of M)

full_name: smoothSheafCommGroup
code: /-- The sheaf of smooth functions from `M` to `A`, for `A` an abelian Lie group, as a
sheaf of abelian groups. -/
@[to_additive "The sheaf of smooth functions from `M` to
`A`, for `A` an abelian additive Lie group, as a sheaf of abelian additive groups."]
noncomputable def smoothSheafCommGroup : TopCat.Sheaf CommGrp.{u} (TopCat.of M) 
goal: TopCat.Sheaf CommGrp (TopCat.of M)

full_name: smoothSheafAddCommGroup
code: /-- The sheaf of smooth functions from `M` to `A`, for `A` an abelian Lie group, as a
sheaf of abelian groups. -/
@[to_additive "The sheaf of smooth functions from `M` to
`A`, for `A` an abelian additive Lie group, as a sheaf of abelian additive groups."]
noncomputable def smoothSheafCommGroup : TopCat.Sheaf CommGrp.{u} (TopCat.of M) 
goal: TopCat.Sheaf AddCommGrp (TopCat.of M)

full_name: smoothSheafAddCommGroup.compLeft
code: /-- For a manifold `M` and a smooth homomorphism `φ` between abelian Lie groups `A`, `A'`, the
'left-composition-by-`φ`' morphism of sheaves from `smoothSheafCommGroup IM I M A` to
`smoothSheafCommGroup IM I' M A'`. -/
@[to_additive "For a manifold `M` and a smooth homomorphism `φ` between abelian additive Lie groups
`A`, `A'`, the 'left-composition-by-`φ`' morphism of sheaves from `smoothSheafAddCommGroup IM I M A`
to `smoothSheafAddCommGroup IM I' M A'`."]
def smoothSheafCommGroup.compLeft (φ : A →* A') (hφ : Smooth I I' φ) :
    smoothSheafCommGroup IM I M A ⟶ smoothSheafCommGroup IM I' M A' 
goal: smoothSheafAddCommGroup IM I M A ⟶ smoothSheafAddCommGroup IM I' M A'

full_name: smoothSheafCommGroup.compLeft
code: /-- For a manifold `M` and a smooth homomorphism `φ` between abelian Lie groups `A`, `A'`, the
'left-composition-by-`φ`' morphism of sheaves from `smoothSheafCommGroup IM I M A` to
`smoothSheafCommGroup IM I' M A'`. -/
@[to_additive "For a manifold `M` and a smooth homomorphism `φ` between abelian additive Lie groups
`A`, `A'`, the 'left-composition-by-`φ`' morphism of sheaves from `smoothSheafAddCommGroup IM I M A`
to `smoothSheafAddCommGroup IM I' M A'`."]
def smoothSheafCommGroup.compLeft (φ : A →* A') (hφ : Smooth I I' φ) :
    smoothSheafCommGroup IM I M A ⟶ smoothSheafCommGroup IM I' M A' 
goal: smoothSheafCommGroup IM I M A ⟶ smoothSheafCommGroup IM I' M A'

full_name: instRingObjOppositeOpensαTopologicalSpaceOfPresheafSmoothSheaf
code: instance (U : (Opens (TopCat.of M))ᵒᵖ) : Ring ((smoothSheaf IM I M R).presheaf.obj U) 
goal: Ring ((smoothSheaf IM I M R).presheaf.obj U)

full_name: smoothPresheafRing
code: /-- The presheaf of smooth functions from `M` to `R`, for `R` a smooth ring, as a presheaf
of rings. -/
def smoothPresheafRing : TopCat.Presheaf RingCat.{u} (TopCat.of M) 
goal: TopCat.Presheaf RingCat (TopCat.of M)

full_name: smoothSheafRing
code: /-- The sheaf of smooth functions from `M` to `R`, for `R` a smooth ring, as a sheaf of
rings. -/
def smoothSheafRing : TopCat.Sheaf RingCat.{u} (TopCat.of M) 
goal: TopCat.Sheaf RingCat (TopCat.of M)

full_name: instCommRingObjOppositeOpensαTopologicalSpaceOfPresheafSmoothSheaf
code: instance (U : (Opens (TopCat.of M))ᵒᵖ) : CommRing ((smoothSheaf IM I M R).presheaf.obj U) 
goal: CommRing ((smoothSheaf IM I M R).presheaf.obj U)

full_name: smoothPresheafCommRing
code: /-- The presheaf of smooth functions from `M` to `R`, for `R` a smooth commutative ring, as a
presheaf of commutative rings. -/
def smoothPresheafCommRing : TopCat.Presheaf CommRingCat.{u} (TopCat.of M) 
goal: TopCat.Presheaf CommRingCat (TopCat.of M)

full_name: smoothSheafCommRing
code: /-- The sheaf of smooth functions from `M` to `R`, for `R` a smooth commutative ring, as a sheaf of
commutative rings. -/
def smoothSheafCommRing : TopCat.Sheaf CommRingCat.{u} (TopCat.of M) 
goal: TopCat.Sheaf CommRingCat (TopCat.of M)

full_name: smoothSheafCommRing.coeFun
code: instance smoothSheafCommRing.coeFun (U : (Opens (TopCat.of M))ᵒᵖ) :
    CoeFun ((smoothSheafCommRing IM I M R).presheaf.obj U) (fun _ ↦ ↑(unop U) → R) 
goal: CoeFun ↑((smoothSheafCommRing IM I M R).presheaf.obj U) fun x => ↥(Opposite.unop U) → R

full_name: smoothSheafCommRing.forgetStalk
code: /-- Identify the stalk at a point of the sheaf-of-commutative-rings of functions from `M` to `R`
(for `R` a smooth ring) with the stalk at that point of the corresponding sheaf of types. -/
def smoothSheafCommRing.forgetStalk (x : TopCat.of M) :
    (forget _).obj ((smoothSheafCommRing IM I M R).presheaf.stalk x) ≅
    (smoothSheaf IM I M R).presheaf.stalk x 
goal: (CategoryTheory.forget CommRingCat).obj ((smoothSheafCommRing IM I M R).presheaf.stalk x) ≅
  (smoothSheaf IM I M R).presheaf.stalk x

full_name: smoothSheafCommRing.ι_forgetStalk_hom
code: @[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_forgetStalk_hom (x : TopCat.of M) (U) :
    CategoryStruct.comp
      (Z := (smoothSheaf IM I M R).presheaf.stalk x)
      (DFunLike.coe
        (α := ((forget CommRingCat).obj ((smoothSheafCommRing IM I M R).presheaf.obj
          (op ((OpenNhds.inclusion x).obj U.unop)))))
        (colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheafCommRing IM I M R).presheaf) U))
      (forgetStalk IM I M R x).hom =
    colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M R).presheaf) U 
goal: CategoryTheory.CategoryStruct.comp
    (⇑(CategoryTheory.Limits.colimit.ι
        ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheafCommRing IM I M R).presheaf) U))
    (smoothSheafCommRing.forgetStalk IM I M R x).hom =
  CategoryTheory.Limits.colimit.ι ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheaf IM I M R).presheaf) U

full_name: smoothSheafCommRing.ι_forgetStalk_inv
code: @[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_forgetStalk_inv (x : TopCat.of M) (U) :
    colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheaf IM I M R).presheaf) U ≫
    (smoothSheafCommRing.forgetStalk IM I M R x).inv =
    (forget CommRingCat).map
      (colimit.ι ((OpenNhds.inclusion x).op ⋙ (smoothSheafCommRing IM I M R).presheaf) U) 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.colimit.ι ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheaf IM I M R).presheaf)
      U)
    (smoothSheafCommRing.forgetStalk IM I M R x).inv =
  (CategoryTheory.forget CommRingCat).map
    (CategoryTheory.Limits.colimit.ι
      ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheafCommRing IM I M R).presheaf) U)

full_name: smoothSheafCommRing.evalAt
code: /-- Given a smooth commutative ring `R` and a manifold `M`, and an open neighbourhood `U` of a point
`x : M`, the evaluation-at-`x` map to `R` from smooth functions from  `U` to `R`. -/
def smoothSheafCommRing.evalAt (x : TopCat.of M) (U : OpenNhds x) :
    (smoothSheafCommRing IM I M R).presheaf.obj (Opposite.op U.1) ⟶ CommRingCat.of R 
goal: (smoothSheafCommRing IM I M R).presheaf.obj (Opposite.op U.obj) ⟶ CommRingCat.of R

full_name: smoothSheafCommRing.evalHom
code: /-- Canonical ring homomorphism from the stalk of `smoothSheafCommRing IM I M R` at `x` to `R`,
given by evaluating sections at `x`, considered as a morphism in the category of commutative rings.
-/
def smoothSheafCommRing.evalHom (x : TopCat.of M) :
    (smoothSheafCommRing IM I M R).presheaf.stalk x ⟶ CommRingCat.of R 
goal: (smoothSheafCommRing IM I M R).presheaf.stalk x ⟶ CommRingCat.of R

full_name: smoothSheafCommRing.eval
code: /-- Canonical ring homomorphism from the stalk of `smoothSheafCommRing IM I M R` at `x` to `R`,
given by evaluating sections at `x`. -/
def smoothSheafCommRing.eval (x : M) : (smoothSheafCommRing IM I M R).presheaf.stalk x →+* R 
goal: ↑((smoothSheafCommRing IM I M R).presheaf.stalk x) →+* R

full_name: smoothSheafCommRing.ι_evalHom
code: @[simp, reassoc, elementwise] lemma smoothSheafCommRing.ι_evalHom (x : TopCat.of M) (U) :
    colimit.ι ((OpenNhds.inclusion x).op ⋙ _) U ≫ smoothSheafCommRing.evalHom IM I M R x =
    smoothSheafCommRing.evalAt _ _ _ _ _ _ 
goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.Limits.colimit.ι
      ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheafCommRing IM I M R).presheaf) U)
    (smoothSheafCommRing.evalHom IM I M R x) =
  smoothSheafCommRing.evalAt IM I M R x (Opposite.unop U)

full_name: smoothSheafCommRing.evalHom_germ
code: @[simp] lemma smoothSheafCommRing.evalHom_germ (U : Opens (TopCat.of M)) (x : U)
    (f : (smoothSheafCommRing IM I M R).presheaf.obj (op U)) :
    smoothSheafCommRing.evalHom IM I M R (x : TopCat.of M)
      ((smoothSheafCommRing IM I M R).presheaf.germ x f)
    = f x 
goal: (smoothSheafCommRing.evalHom IM I M R ↑x) (((smoothSheafCommRing IM I M R).presheaf.germ x) f) = ↑f x

full_name: smoothSheafCommRing.forgetStalk_inv_comp_eval
code: @[simp, reassoc, elementwise] lemma smoothSheafCommRing.forgetStalk_inv_comp_eval
    (x : TopCat.of M) :
    (smoothSheafCommRing.forgetStalk IM I M R x).inv ≫
     (DFunLike.coe (smoothSheafCommRing.evalHom IM I M R x)) =
    smoothSheaf.evalHom _ _ _ _ 
goal: CategoryTheory.CategoryStruct.comp (smoothSheafCommRing.forgetStalk IM I M R x).inv
    ⇑(smoothSheafCommRing.evalHom IM I M R x) =
  smoothSheaf.evalHom IM I R x

full_name: smoothSheafCommRing.forgetStalk_hom_comp_evalHom
code: @[simp, reassoc, elementwise] lemma smoothSheafCommRing.forgetStalk_hom_comp_evalHom
    (x : TopCat.of M) :
    (smoothSheafCommRing.forgetStalk IM I M R x).hom ≫ (smoothSheaf.evalHom IM I R x) =
    (forget _).map (smoothSheafCommRing.evalHom _ _ _ _ _) 
goal: CategoryTheory.CategoryStruct.comp (smoothSheafCommRing.forgetStalk IM I M R x).hom (smoothSheaf.evalHom IM I R x) =
  (CategoryTheory.forget CommRingCat).map (smoothSheafCommRing.evalHom IM I M R x)

full_name: smoothSheafCommRing.eval_surjective
code: lemma smoothSheafCommRing.eval_surjective (x) :
    Function.Surjective (smoothSheafCommRing.eval IM I M R x) 
goal: Function.Surjective ⇑(smoothSheafCommRing.eval IM I M R x)

full_name: instNontrivialαCommRingStalkCommRingCatPresheafSmoothSheafCommRing
code: instance [Nontrivial R] (x : M) : Nontrivial ((smoothSheafCommRing IM I M R).presheaf.stalk x) 
goal: Nontrivial ↑((smoothSheafCommRing IM I M R).presheaf.stalk x)

full_name: smoothSheafCommRing.eval_germ
code: @[simp] lemma smoothSheafCommRing.eval_germ (U : Opens M) (x : U)
    (f : (smoothSheafCommRing IM I M R).presheaf.obj (op U)) :
    smoothSheafCommRing.eval IM I M R x ((smoothSheafCommRing IM I M R).presheaf.germ x f)
    = f x 
goal: (smoothSheafCommRing.eval IM I M R ↑x) (((smoothSheafCommRing IM I M R).presheaf.germ x) f) = ↑f x