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

Proof steps:
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 (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })) ≫
        (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 (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
        (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ }))
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })) ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯)
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))
e :
  invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
        (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ }))
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })) ≫
        (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
          (op
            ((opensFunctor (pullback.fst (D.f k i) (D.f k j))).obj
              { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ })) ⟶
        Z),
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
        (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
          (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app (op U) ≫
        invApp (pullback.fst (D.f k i) (D.f k j)) { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })) ≫
        (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 :
  ∀ {Z : C}
    (h :
      (D.V (k, i)).presheaf.obj
          (op
            ((opensFunctor (pullback.fst (D.f k i) (D.f k j))).obj
              { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ })) ⟶
        Z),
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
        (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
          (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app (op U) ≫
        invApp (pullback.fst (D.f k i) (D.f k j)) { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    (D.t' k i j).c.app (op U) ≫
      invApp (pullback.fst (D.f k i) (D.f k j))
          (unop (op { carrier := ⇑(D.t' k i j).base ⁻¹' ↑(unop (op U)), is_open' := ⋯ })) ≫
        (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
          (op
            ((opensFunctor (pullback.fst (D.f k i) (D.f k j))).obj
              { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ })) ⟶
        Z),
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
        (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
          (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app (op U) ≫
        invApp (pullback.fst (D.f k i) (D.f k j)) { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ (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
          (op
            ((opensFunctor (pullback.fst (D.f k i) (D.f k j))).obj
              { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ })) ⟶
        Z),
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
        (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
          (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ h =
      (D.t' k i j).c.app (op U) ≫
        invApp (pullback.fst (D.f k i) (D.f k j)) { carrier := ⇑(D.t' k i j).base ⁻¹' ↑U, is_open' := ⋯ } ≫ h
⊢ invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) =
    invApp (pullback.snd (D.f i j) (D.f i k)) U ≫
      (D.t k i).c.app (op ((opensFunctor (pullback.snd (D.f i j) (D.f i k))).obj U)) ≫
        (D.V (k, i)).presheaf.map (eqToHom ⋯) ≫ (D.V (k, i)).presheaf.map (eqToHom ⋯)
state_after: no goals
tactic: simp [eqToHom_map]