File: Mathlib/Topology/Sheaves/Presheaf.lean

full_name: TopCat.Presheaf
code: /-- The category of `C`-valued presheaves on a (bundled) topological space `X`. -/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
def Presheaf (X : TopCat.{w}) : Type max u v w 
goal: Type (max u v w)

full_name: TopCat.instCategoryPresheaf
code: instance (X : TopCat.{w}) : Category (Presheaf.{w, v, u} C X) 
goal: CategoryTheory.Category.{max v w, max (max u v) w} (TopCat.Presheaf C X)

full_name: TopCat.Presheaf.comp_app
code: @[simp] theorem comp_app {X : TopCat} {U : (Opens X)ᵒᵖ} {P Q R : Presheaf C X}
    (f : P ⟶ Q) (g : Q ⟶ R) :
    (f ≫ g).app U = f.app U ≫ g.app U 
goal: (f ≫ g).app U = f.app U ≫ g.app U

full_name: TopCat.Presheaf.ext
code: @[ext]
lemma ext {X : TopCat} {P Q : Presheaf C X} {f g : P ⟶ Q}
    (w : ∀ U : Opens X, f.app (op U) = g.app (op U)) :
    f = g 
goal: f = g

full_name: TopCat.Presheaf.attrSheaf_restrict
code: macro "sheaf_restrict" : attr =>
  `(attr|aesop safe 50 apply (rule_sets := [$(Lean.mkIdent `Restrict):ident]))
goal: Lean.ParserDescr

full_name: TopCat.Presheaf._aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_TopCat_Presheaf_attrSheaf_restrict_1
code: macro "sheaf_restrict" : attr =>
  `(attr|aesop safe 50 apply (rule_sets := [$(Lean.mkIdent `Restrict):ident]))
goal: Lean.Macro

full_name: TopCat.Presheaf.restrict_tac
code: macro (name := restrict_tac) "restrict_tac" c:Aesop.tactic_clause* : tactic =>
`(tactic| first | assumption |
  aesop $c*
    (config := { terminal := true
                 assumptionTransparency := .reducible
                 enableSimp := false })
    (rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident]))
goal: Lean.ParserDescr

full_name: TopCat.Presheaf._aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_TopCat_Presheaf_restrict_tac_1
code: macro (name := restrict_tac) "restrict_tac" c:Aesop.tactic_clause* : tactic =>
`(tactic| first | assumption |
  aesop $c*
    (config := { terminal := true
                 assumptionTransparency := .reducible
                 enableSimp := false })
    (rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident]))
goal: Lean.Macro

full_name: TopCat.Presheaf.restrict_tac?
code: macro (name := restrict_tac?) "restrict_tac?" c:Aesop.tactic_clause* : tactic =>
`(tactic|
  aesop? $c*
    (config := { terminal := true
                 assumptionTransparency := .reducible
                 enableSimp := false
                 maxRuleApplications := 300 })
  (rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident]))
goal: Lean.ParserDescr

full_name: TopCat.Presheaf._aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_TopCat_Presheaf_restrict_tac?_1
code: macro (name := restrict_tac?) "restrict_tac?" c:Aesop.tactic_clause* : tactic =>
`(tactic|
  aesop? $c*
    (config := { terminal := true
                 assumptionTransparency := .reducible
                 enableSimp := false
                 maxRuleApplications := 300 })
  (rule_sets := [-default, -builtin, $(Lean.mkIdent `Restrict):ident]))
goal: Lean.Macro

full_name: TopCat.Presheaf.restrict
code: /-- The restriction of a section along an inclusion of open sets.
For `x : F.obj (op V)`, we provide the notation `x |_ₕ i` (`h` stands for `hom`) for `i : U ⟶ V`,
and the notation `x |_ₗ U ⟪i⟫` (`l` stands for `le`) for `i : U ≤ V`.
-/
def restrict {X : TopCat} {C : Type*} [Category C] [ConcreteCategory C] {F : X.Presheaf C}
    {V : Opens X} (x : F.obj (op V)) {U : Opens X} (h : U ⟶ V) : F.obj (op U) 
goal: (CategoryTheory.forget C).obj (F.obj (Opposite.op U))

full_name: AlgebraicGeometry.«_aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_AlgebraicGeometry_term_|_ₕ__1»
code: /-- restriction of a section along an inclusion -/
scoped[AlgebraicGeometry] infixl:80 " |_ₕ " => TopCat.Presheaf.restrict
goal: Lean.Macro

full_name: AlgebraicGeometry._aux_Mathlib_Topology_Sheaves_Presheaf___unexpand_TopCat_Presheaf_restrict_1
code: /-- restriction of a section along an inclusion -/
scoped[AlgebraicGeometry] infixl:80 " |_ₕ " => TopCat.Presheaf.restrict
goal: Lean.PrettyPrinter.Unexpander

full_name: AlgebraicGeometry.«_aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_AlgebraicGeometry_term_|_ₗ_⟪_⟫_1»
code: /-- restriction of a section along a subset relation -/
scoped[AlgebraicGeometry] notation:80 x " |_ₗ " U " ⟪" e "⟫ " =>
  @TopCat.Presheaf.restrict _ _ _ _ _ _ x U (@homOfLE (Opens _) _ U _ e)
goal: Lean.Macro

full_name: TopCat.Presheaf.restrictOpen
code: /-- The restriction of a section along an inclusion of open sets.
For `x : F.obj (op V)`, we provide the notation `x |_ U`, where the proof `U ≤ V` is inferred by
the tactic `Top.presheaf.restrict_tac'` -/
abbrev restrictOpen {X : TopCat} {C : Type*} [Category C] [ConcreteCategory C] {F : X.Presheaf C}
    {V : Opens X} (x : F.obj (op V)) (U : Opens X)
    (e : U ≤ V := by restrict_tac) :
    F.obj (op U) 
goal: (CategoryTheory.forget C).obj (F.obj (Opposite.op U))

full_name: AlgebraicGeometry._aux_Mathlib_Topology_Sheaves_Presheaf___unexpand_TopCat_Presheaf_restrictOpen_1
code: /-- restriction of a section to open subset -/
scoped[AlgebraicGeometry] infixl:80 " |_ " => TopCat.Presheaf.restrictOpen
goal: Lean.PrettyPrinter.Unexpander

full_name: AlgebraicGeometry.«_aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_AlgebraicGeometry_term_|___1»
code: /-- restriction of a section to open subset -/
scoped[AlgebraicGeometry] infixl:80 " |_ " => TopCat.Presheaf.restrictOpen
goal: Lean.Macro

full_name: TopCat.Presheaf.restrict_restrict
code: theorem restrict_restrict {X : TopCat} {C : Type*} [Category C] [ConcreteCategory C]
    {F : X.Presheaf C} {U V W : Opens X} (e₁ : U ≤ V) (e₂ : V ≤ W) (x : F.obj (op W)) :
    x |_ V |_ U = x |_ U 
goal: TopCat.Presheaf.restrictOpen (TopCat.Presheaf.restrictOpen x V e₂) U e₁ = TopCat.Presheaf.restrictOpen x U ⋯

full_name: TopCat.Presheaf.map_restrict
code: theorem map_restrict {X : TopCat} {C : Type*} [Category C] [ConcreteCategory C]
    {F G : X.Presheaf C} (e : F ⟶ G) {U V : Opens X} (h : U ≤ V) (x : F.obj (op V)) :
    e.app _ (x |_ U) = e.app _ x |_ U 
goal: (e.app (Opposite.op U)) (TopCat.Presheaf.restrictOpen x U h) =
  TopCat.Presheaf.restrictOpen ((e.app (Opposite.op V)) x) U h

full_name: TopCat.Presheaf.pushforward_obj_obj
code: /-- The pushforward functor. -/
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.pushforward C f).obj G).obj X_1 =
    G.obj (Opposite.op ((TopologicalSpace.Opens.map f).obj (Opposite.unop X_1)))

full_name: TopCat.Presheaf.pushforward_map_app
code: /-- The pushforward functor. -/
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C} (α : X_1 ⟶ Y_1) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.pushforward C f).map α).app X_2 =
    α.app (Opposite.op ((TopologicalSpace.Opens.map f).obj (Opposite.unop X_2)))

full_name: TopCat.Presheaf.pushforward_obj_map
code: /-- The pushforward functor. -/
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ} (f_1 : X_1 ⟶ Y_1),
  ((TopCat.Presheaf.pushforward C f).obj G).map f_1 = G.map ((TopologicalSpace.Opens.map f).map f_1.unop).op

full_name: TopCat.Presheaf.pushforward
code: /-- The pushforward functor. -/
@[simps!]
def pushforward {X Y : TopCat.{w}} (f : X ⟶ Y) : X.Presheaf C ⥤ Y.Presheaf C 
goal: TopCat.Presheaf C X ⥤ TopCat.Presheaf C Y

full_name: TopCat.Presheaf.«_aux_Mathlib_Topology_Sheaves_Presheaf___macroRules_TopCat_Presheaf_term__*__1»
code: /-- push forward of a presheaf-/
notation f:80 " _* " P:81 => (pushforward _ f).obj P
goal: Lean.Macro

full_name: TopCat.Presheaf.pushforward_map_app'
code: @[simp]
theorem pushforward_map_app' {X Y : TopCat.{w}} (f : X ⟶ Y) {ℱ 𝒢 : X.Presheaf C} (α : ℱ ⟶ 𝒢)
    {U : (Opens Y)ᵒᵖ} : ((pushforward C f).map α).app U = α.app (op <| (Opens.map f).obj U.unop) 
goal: ((TopCat.Presheaf.pushforward C f).map α).app U =
  α.app (Opposite.op ((TopologicalSpace.Opens.map f).obj (Opposite.unop U)))

full_name: TopCat.Presheaf.id_pushforward
code: lemma id_pushforward (X : TopCat.{w}) : pushforward C (𝟙 X) = 𝟭 (X.Presheaf C) 
goal: TopCat.Presheaf.pushforward C (𝟙 X) = 𝟭 (TopCat.Presheaf C X)

full_name: TopCat.Presheaf.Pushforward.id
code: /-- The natural isomorphism between the pushforward of a presheaf along the identity continuous map
and the original presheaf. -/
def id {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ ≅ ℱ 
goal: (TopCat.Presheaf.pushforward C (𝟙 X)).obj ℱ ≅ ℱ

full_name: TopCat.Presheaf.Pushforward.id_hom_app
code: @[simp]
theorem id_hom_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) : (id ℱ).hom.app U = 𝟙 _ 
goal: (TopCat.Presheaf.Pushforward.id ℱ).hom.app U = 𝟙 (((TopCat.Presheaf.pushforward C (𝟙 X)).obj ℱ).obj U)

full_name: TopCat.Presheaf.Pushforward.id_inv_app
code: @[simp]
theorem id_inv_app {X : TopCat.{w}} (ℱ : X.Presheaf C) (U) :
    (id ℱ).inv.app U = 𝟙 _ 
goal: (TopCat.Presheaf.Pushforward.id ℱ).inv.app U = 𝟙 (ℱ.obj U)

full_name: TopCat.Presheaf.Pushforward.id_eq
code: theorem id_eq {X : TopCat.{w}} (ℱ : X.Presheaf C) : 𝟙 X _* ℱ = ℱ 
goal: (TopCat.Presheaf.pushforward C (𝟙 X)).obj ℱ = ℱ

full_name: TopCat.Presheaf.Pushforward.comp
code: /-- The natural isomorphism between
the pushforward of a presheaf along the composition of two continuous maps and
the corresponding pushforward of a pushforward. -/
def comp {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
    (f ≫ g) _* ℱ ≅ g _* (f _* ℱ) 
goal: (TopCat.Presheaf.pushforward C (f ≫ g)).obj ℱ ≅
  (TopCat.Presheaf.pushforward C g).obj ((TopCat.Presheaf.pushforward C f).obj ℱ)

full_name: TopCat.Presheaf.Pushforward.comp_eq
code: theorem comp_eq {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) :
    (f ≫ g) _* ℱ = g _* (f _* ℱ) 
goal: (TopCat.Presheaf.pushforward C (f ≫ g)).obj ℱ =
  (TopCat.Presheaf.pushforward C g).obj ((TopCat.Presheaf.pushforward C f).obj ℱ)

full_name: TopCat.Presheaf.Pushforward.comp_hom_app
code: @[simp]
theorem comp_hom_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
    (comp f g ℱ).hom.app U = 𝟙 _ 
goal: (TopCat.Presheaf.Pushforward.comp f g ℱ).hom.app U = 𝟙 (((TopCat.Presheaf.pushforward C (f ≫ g)).obj ℱ).obj U)

full_name: TopCat.Presheaf.Pushforward.comp_inv_app
code: @[simp]
theorem comp_inv_app {X Y Z : TopCat.{w}} (f : X ⟶ Y) (g : Y ⟶ Z) (ℱ : X.Presheaf C) (U) :
    (comp f g ℱ).inv.app U = 𝟙 _ 
goal: (TopCat.Presheaf.Pushforward.comp f g ℱ).inv.app U =
  𝟙 (((TopCat.Presheaf.pushforward C g).obj ((TopCat.Presheaf.pushforward C f).obj ℱ)).obj U)

full_name: TopCat.Presheaf.pushforwardEq
code: /--
An equality of continuous maps induces a natural isomorphism between the pushforwards of a presheaf
along those maps.
-/
def pushforwardEq {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
    f _* ℱ ≅ g _* ℱ 
goal: (TopCat.Presheaf.pushforward C f).obj ℱ ≅ (TopCat.Presheaf.pushforward C g).obj ℱ

full_name: TopCat.Presheaf.pushforward_eq'
code: theorem pushforward_eq' {X Y : TopCat.{w}} {f g : X ⟶ Y} (h : f = g) (ℱ : X.Presheaf C) :
    f _* ℱ = g _* ℱ 
goal: (TopCat.Presheaf.pushforward C f).obj ℱ = (TopCat.Presheaf.pushforward C g).obj ℱ

full_name: TopCat.Presheaf.pushforwardEq_hom_app
code: @[simp]
theorem pushforwardEq_hom_app {X Y : TopCat.{w}} {f g : X ⟶ Y}
    (h : f = g) (ℱ : X.Presheaf C) (U) :
    (pushforwardEq h ℱ).hom.app U = ℱ.map (eqToHom (by aesop_cat)) 
goal: (TopCat.Presheaf.pushforwardEq h ℱ).hom.app U = ℱ.map (CategoryTheory.eqToHom ⋯)

full_name: TopCat.Presheaf.presheafEquivOfIso_functor_obj_obj
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).functor.obj G).obj X_1 =
    G.obj (Opposite.op ((TopologicalSpace.Opens.map H.hom).obj (Opposite.unop X_1)))

full_name: TopCat.Presheaf.presheafEquivOfIso_inverse_obj_obj
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).inverse.obj G).obj X_1 =
    G.obj (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_1)))

full_name: TopCat.Presheaf.presheafEquivOfIso_unitIso_inv_app_app
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).unitIso.inv.app X_1).app X_2 =
    X_1.map
        ((TopologicalSpace.Opens.mapMapIso H).symm.op.unit.app
          (Opposite.op
            ((TopologicalSpace.Opens.map H.hom).obj ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2))))) ≫
      X_1.map
          ((TopologicalSpace.Opens.map H.hom).map
              ((TopologicalSpace.Opens.mapMapIso H).symm.op.counit.app
                  (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))).unop).op ≫
        X_1.map ((TopologicalSpace.Opens.mapMapIso H).symm.op.unitInv.app X_2)

full_name: TopCat.Presheaf.presheafEquivOfIso_inverse_obj_map
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ} (f : X_1 ⟶ Y_1),
  ((TopCat.Presheaf.presheafEquivOfIso C H).inverse.obj G).map f =
    G.map ((TopologicalSpace.Opens.map H.inv).map f.unop).op

full_name: TopCat.Presheaf.presheafEquivOfIso_unitIso_hom_app_app
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).unitIso.hom.app X_1).app X_2 =
    X_1.map ((TopologicalSpace.Opens.mapMapIso H).symm.op.unit.app X_2) ≫
      X_1.map
          ((TopologicalSpace.Opens.map H.hom).map
              ((TopologicalSpace.Opens.mapMapIso H).symm.op.counitInv.app
                  (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))).unop).op ≫
        X_1.map
          ((TopologicalSpace.Opens.mapMapIso H).symm.op.unitInv.app
            (Opposite.op
              ((TopologicalSpace.Opens.map H.hom).obj ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))))

full_name: TopCat.Presheaf.presheafEquivOfIso
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: TopCat.Presheaf C X ≌ TopCat.Presheaf C Y

full_name: TopCat.Presheaf.presheafEquivOfIso_functor_map_app
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑X)ᵒᵖ ⥤ C} (α : X_1 ⟶ Y_1) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).functor.map α).app X_2 =
    α.app (Opposite.op ((TopologicalSpace.Opens.map H.hom).obj (Opposite.unop X_2)))

full_name: TopCat.Presheaf.presheafEquivOfIso_counitIso_hom_app_app
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).counitIso.hom.app X_1).app X_2 = X_1.map (CategoryTheory.eqToHom ⋯)

full_name: TopCat.Presheaf.presheafEquivOfIso_counitIso_inv_app_app
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ (X_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C) (X_2 : (TopologicalSpace.Opens ↑Y)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).counitIso.inv.app X_1).app X_2 = X_1.map (CategoryTheory.eqToHom ⋯)

full_name: TopCat.Presheaf.presheafEquivOfIso_functor_obj_map
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ} (f : X_1 ⟶ Y_1),
  ((TopCat.Presheaf.presheafEquivOfIso C H).functor.obj G).map f =
    G.map ((TopologicalSpace.Opens.map H.hom).map f.unop).op

full_name: TopCat.Presheaf.presheafEquivOfIso_inverse_map_app
code: /-- A homeomorphism of spaces gives an equivalence of categories of presheaves. -/
@[simps!]
def presheafEquivOfIso {X Y : TopCat} (H : X ≅ Y) : X.Presheaf C ≌ Y.Presheaf C 
goal: ∀ {X_1 Y_1 : (TopologicalSpace.Opens ↑Y)ᵒᵖ ⥤ C} (α : X_1 ⟶ Y_1) (X_2 : (TopologicalSpace.Opens ↑X)ᵒᵖ),
  ((TopCat.Presheaf.presheafEquivOfIso C H).inverse.map α).app X_2 =
    α.app (Opposite.op ((TopologicalSpace.Opens.map H.inv).obj (Opposite.unop X_2)))

full_name: TopCat.Presheaf.toPushforwardOfIso
code: /-- If `H : X ≅ Y` is a homeomorphism,
then given an `H _* ℱ ⟶ 𝒢`, we may obtain an `ℱ ⟶ H ⁻¹ _* 𝒢`.
-/
def toPushforwardOfIso {X Y : TopCat} (H : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
    (α : H.hom _* ℱ ⟶ 𝒢) : ℱ ⟶ H.inv _* 𝒢 
goal: ℱ ⟶ (TopCat.Presheaf.pushforward C H.inv).obj 𝒢

full_name: TopCat.Presheaf.toPushforwardOfIso_app
code: @[simp]
theorem toPushforwardOfIso_app {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : X.Presheaf C} {𝒢 : Y.Presheaf C}
    (H₂ : H₁.hom _* ℱ ⟶ 𝒢) (U : (Opens X)ᵒᵖ) :
    (toPushforwardOfIso H₁ H₂).app U =
      ℱ.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) ≫
        H₂.app (op ((Opens.map H₁.inv).obj (unop U))) 
goal: (TopCat.Presheaf.toPushforwardOfIso H₁ H₂).app U =
  ℱ.map (CategoryTheory.eqToHom ⋯) ≫ H₂.app (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U)))

full_name: TopCat.Presheaf.pushforwardToOfIso
code: /-- If `H : X ≅ Y` is a homeomorphism,
then given an `H _* ℱ ⟶ 𝒢`, we may obtain an `ℱ ⟶ H ⁻¹ _* 𝒢`.
-/
def pushforwardToOfIso {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
    (H₂ : ℱ ⟶ H₁.hom _* 𝒢) : H₁.inv _* ℱ ⟶ 𝒢 
goal: (TopCat.Presheaf.pushforward C H₁.inv).obj ℱ ⟶ 𝒢

full_name: TopCat.Presheaf.pushforwardToOfIso_app
code: @[simp]
theorem pushforwardToOfIso_app {X Y : TopCat} (H₁ : X ≅ Y) {ℱ : Y.Presheaf C} {𝒢 : X.Presheaf C}
    (H₂ : ℱ ⟶ H₁.hom _* 𝒢) (U : (Opens X)ᵒᵖ) :
    (pushforwardToOfIso H₁ H₂).app U =
      H₂.app (op ((Opens.map H₁.inv).obj (unop U))) ≫
        𝒢.map (eqToHom (by simp [Opens.map, Set.preimage_preimage])) 
goal: (TopCat.Presheaf.pushforwardToOfIso H₁ H₂).app U =
  H₂.app (Opposite.op ((TopologicalSpace.Opens.map H₁.inv).obj (Opposite.unop U))) ≫ 𝒢.map (CategoryTheory.eqToHom ⋯)

full_name: TopCat.Presheaf.pullback
code: /-- Pullback a presheaf on `Y` along a continuous map `f : X ⟶ Y`, obtaining a presheaf
on `X`. -/
def pullback {X Y : TopCat.{v}} (f : X ⟶ Y) : Y.Presheaf C ⥤ X.Presheaf C 
goal: TopCat.Presheaf C Y ⥤ TopCat.Presheaf C X

full_name: TopCat.Presheaf.pushforwardPullbackAdjunction
code: /-- The pullback and pushforward along a continuous map are adjoint to each other. -/
def pushforwardPullbackAdjunction {X Y : TopCat.{v}} (f : X ⟶ Y) :
    pullback C f ⊣ pushforward C f 
goal: TopCat.Presheaf.pullback C f ⊣ TopCat.Presheaf.pushforward C f

full_name: TopCat.Presheaf.pullbackHomIsoPushforwardInv
code: /-- Pulling back along a homeomorphism is the same as pushing forward along its inverse. -/
def pullbackHomIsoPushforwardInv {X Y : TopCat.{v}} (H : X ≅ Y) :
    pullback C H.hom ≅ pushforward C H.inv 
goal: TopCat.Presheaf.pullback C H.hom ≅ TopCat.Presheaf.pushforward C H.inv

full_name: TopCat.Presheaf.pullbackInvIsoPushforwardHom
code: /-- Pulling back along the inverse of a homeomorphism is the same as pushing forward along it. -/
def pullbackInvIsoPushforwardHom {X Y : TopCat.{v}} (H : X ≅ Y) :
    pullback C H.inv ≅ pushforward C H.hom 
goal: TopCat.Presheaf.pullback C H.inv ≅ TopCat.Presheaf.pushforward C H.hom

full_name: TopCat.Presheaf.pullbackObjObjOfImageOpen
code: /-- If `f '' U` is open, then `f⁻¹ℱ U ≅ ℱ (f '' U)`.  -/
def pullbackObjObjOfImageOpen {X Y : TopCat.{v}} (f : X ⟶ Y) (ℱ : Y.Presheaf C) (U : Opens X)
    (H : IsOpen (f '' SetLike.coe U)) : ((pullback C f).obj ℱ).obj (op U) ≅ ℱ.obj (op ⟨_, H⟩) 
goal: ((TopCat.Presheaf.pullback C f).obj ℱ).obj (Opposite.op U) ≅ ℱ.obj (Opposite.op { carrier := ⇑f '' ↑U, is_open' := H })