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.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ U = (Opens.map H₁.hom).op.obj { unop := (Opens.map H₁.inv).obj U.unop }
state_after: no goals

tactic: delta toPushforwardOfIso
state_before: C : Type u
inst✝ : Category.{v, u} 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 ⋯) ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (((presheafEquivOfIso C H₁).toAdjunction.homEquiv ℱ 𝒢) H₂).app U =
    ℱ.map (eqToHom ⋯) ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }

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.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ (((presheafEquivOfIso C H₁).toAdjunction.homEquiv ℱ 𝒢) H₂).app U =
    ℱ.map (eqToHom ⋯) ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }
state_after: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ((presheafEquivOfIso C H₁).unit.app ℱ ≫ (presheafEquivOfIso C H₁).inverse.map H₂).app U =
    eqToHom ⋯ ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }

tactic: rw [NatTrans.comp_app, presheafEquivOfIso_inverse_map_app, Equivalence.Equivalence_mk'_unit]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : TopCat
H₁ : X ≅ Y
ℱ : Presheaf C X
𝒢 : Presheaf C Y
H₂ : H₁.hom _* ℱ ⟶ 𝒢
U : (Opens ↑X)ᵒᵖ
⊢ ((presheafEquivOfIso C H₁).unit.app ℱ ≫ (presheafEquivOfIso C H₁).inverse.map H₂).app U =
    eqToHom ⋯ ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }
state_after: C : Type u
inst✝ : Category.{v, u} 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 { unop := (Opens.map H₁.inv).obj U.unop } =
    eqToHom ⋯ ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }

tactic: congr 1
state_before: C : Type u
inst✝ : Category.{v, u} 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 { unop := (Opens.map H₁.inv).obj U.unop } =
    eqToHom ⋯ ≫ H₂.app { unop := (Opens.map H₁.inv).obj U.unop }
state_after: case e_a
C : Type u
inst✝ : Category.{v, u} 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 ⋯

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.{v, u} 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 ⋯
state_after: no goals