Theorem: TopCat.Presheaf.toPushforwardOfIso_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: simp [Opens.map, Set.preimage_preimage]
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ U = (Functor.op (Opens.map H₁.hom)).obj ((Opens.map H₁.inv).obj U.unop).op

tactic: delta toPushforwardOfIso
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (toPushforwardOfIso H₁ H₂).app U =
    ℱ.map
        (eqToHom
          (_ :
            U =
              {
                  carrier :=
                    (forget TopCat).map H₁.hom ⁻¹'
                      ↑{ carrier := (forget TopCat).map H₁.inv ⁻¹' ↑U.unop,
                              is_open' := (_ : IsOpen (↑H₁.inv ⁻¹' ↑U.unop)) }.op.unop,
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑H₁.hom ⁻¹'
                          ↑{ carrier := (forget TopCat).map H₁.inv ⁻¹' ↑U.unop,
                                  is_open' := (_ : IsOpen (↑H₁.inv ⁻¹' ↑U.unop)) }.op.unop)) }.op)) ≫
      H₂.app ((Opens.map H₁.inv).obj U.unop).op

tactic: simp only [pushforwardObj_obj, Functor.op_obj, Equivalence.toAdjunction, Adjunction.homEquiv_unit,
  Functor.id_obj, Functor.comp_obj, Adjunction.mkOfUnitCounit_unit, unop_op, eqToHom_map]
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (↑(Adjunction.homEquiv (Equivalence.toAdjunction (presheafEquivOfIso C H₁)) ℱ 𝒢) H₂).app U =
    ℱ.map
        (eqToHom
          (_ :
            U =
              {
                  carrier :=
                    (forget TopCat).map H₁.hom ⁻¹'
                      ↑{ carrier := (forget TopCat).map H₁.inv ⁻¹' ↑U.unop,
                              is_open' := (_ : IsOpen (↑H₁.inv ⁻¹' ↑U.unop)) }.op.unop,
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑H₁.hom ⁻¹'
                          ↑{ carrier := (forget TopCat).map H₁.inv ⁻¹' ↑U.unop,
                                  is_open' := (_ : IsOpen (↑H₁.inv ⁻¹' ↑U.unop)) }.op.unop)) }.op)) ≫
      H₂.app ((Opens.map H₁.inv).obj U.unop).op

tactic: rw [NatTrans.comp_app, presheafEquivOfIso_inverse_map_app, Equivalence.Equivalence_mk'_unit]
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ((Equivalence.unit (presheafEquivOfIso C H₁)).app ℱ ≫ (presheafEquivOfIso C H₁).inverse.map H₂).app U =
    eqToHom (_ : ℱ.obj U = ℱ.obj ((Opens.map H₁.hom).obj ((Opens.map H₁.inv).obj U.unop)).op) ≫
      H₂.app ((Opens.map H₁.inv).obj U.unop).op

tactic: congr 1
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ((presheafEquivOfIso C H₁).unitIso.hom.app ℱ).app U ≫ H₂.app ((Opens.map H₁.inv).obj U.unop).op =
    eqToHom (_ : ℱ.obj U = ℱ.obj ((Opens.map H₁.hom).obj ((Opens.map H₁.inv).obj U.unop)).op) ≫
      H₂.app ((Opens.map H₁.inv).obj U.unop).op

tactic: simp only [Equivalence.unit, Equivalence.op, CategoryTheory.Equivalence.symm, Opens.mapMapIso,
  Functor.id_obj, Functor.comp_obj, Iso.symm_hom, NatIso.op_inv, Iso.symm_inv, NatTrans.op_app,
  NatIso.ofComponents_hom_app, eqToIso.hom, eqToHom_op, Equivalence.Equivalence_mk'_unitInv,
  Equivalence.Equivalence_mk'_counitInv, NatIso.op_hom, unop_op, op_unop, eqToIso.inv,
  NatIso.ofComponents_inv_app, eqToHom_unop, ←ℱ.map_comp, eqToHom_trans, eqToHom_map,
  presheafEquivOfIso_unitIso_hom_app_app]
state_before: case e_a
C : Type u
inst✝ : Category C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ((presheafEquivOfIso C H₁).unitIso.hom.app ℱ).app U =
    eqToHom (_ : ℱ.obj U = ℱ.obj ((Opens.map H₁.hom).obj ((Opens.map H₁.inv).obj U.unop)).op)