Theorem: AlgebraicGeometry.PresheafedSpace.GlueData.snd_invApp_t_app
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean

tactic: have e := (D.snd_invApp_t_app' i j k U).choose_spec
state_before: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯)
state_after: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
e :
  invApp pullback.snd U ≫
      (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯) =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯)

tactic: replace e := reassoc_of% e
state_before: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
e :
  invApp pullback.snd U ≫
      (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯) =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯)
state_after: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
e :
  ∀ {Z : C}
    (h :
      (D.V (k, i)).presheaf.obj
          { unop := (opensFunctor pullback.fst).obj { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } } ⟶
        Z),
    invApp pullback.snd U ≫
        (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app { unop := U } ≫ invApp pullback.fst { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯)

tactic: rw [← e]
state_before: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
e :
  ∀ {Z : C}
    (h :
      (D.V (k, i)).presheaf.obj
          { unop := (opensFunctor pullback.fst).obj { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } } ⟶
        Z),
    invApp pullback.snd U ≫
        (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app { unop := U } ≫ invApp pullback.fst { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    (D.t' k i j).c.app { unop := U } ≫
      invApp pullback.fst { unop := { carrier := ⇑(D.t' k i j).base ⁻¹' ↑{ unop := U }.unop, is_open' := ⋯ } }.unop ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯)
state_after: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
e :
  ∀ {Z : C}
    (h :
      (D.V (k, i)).presheaf.obj
          { unop := (opensFunctor pullback.fst).obj { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } } ⟶
        Z),
    invApp pullback.snd U ≫
        (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app { unop := U } ≫ invApp pullback.fst { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    invApp pullback.snd U ≫
      (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯)

tactic: simp [eqToHom_map]
state_before: C : Type u
inst✝ : Category.{v, u} C
D : GlueData C
i j k : D.J
U : Opens ↑↑(pullback (D.f i j) (D.f i k))
e :
  ∀ {Z : C}
    (h :
      (D.V (k, i)).presheaf.obj
          { unop := (opensFunctor pullback.fst).obj { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } } ⟶
        Z),
    invApp pullback.snd U ≫
        (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app { unop := U } ≫ invApp pullback.fst { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp pullback.snd U ≫ (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } =
    invApp pullback.snd U ≫
      (D.t k i).c.app { unop := (opensFunctor pullback.snd).obj U } ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯)
state_after: no goals