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

tactic: constructor
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ∃ (eq :
    {
        unop :=
          (opensFunctor pullback.snd).obj
            { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop } =
      (Opens.map (D.f j k).base).op.obj { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) }),
    D.opensImagePreimageMap i j U ≫ (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
      (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd
            { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop ≫
          (D.V (j, k)).presheaf.map (eqToHom eq)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ D.opensImagePreimageMap i j U ≫ (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

case w
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ {
      unop :=
        (opensFunctor pullback.snd).obj
          { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop } =
    (Opens.map (D.f j k).base).op.obj { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) }

tactic: delta opensImagePreimageMap
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ D.opensImagePreimageMap i j U ≫ (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ((D.f i j).c.app { unop := U } ≫
        (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
          invApp (D.f j i)
              {
                  unop :=
                    (Opens.map (D.t j i).base).toPrefunctor.1
                      ((Opens.map (D.f i j).base).op.obj { unop := U }).unop }.unop ≫
            (D.U j).presheaf.map (eqToHom ⋯).op) ≫
      (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: simp_rw [Category.assoc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ((D.f i j).c.app { unop := U } ≫
        (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
          invApp (D.f j i)
              {
                  unop :=
                    (Opens.map (D.t j i).base).toPrefunctor.1
                      ((Opens.map (D.f i j).base).op.obj { unop := U }).unop }.unop ≫
            (D.U j).presheaf.map (eqToHom ⋯).op) ≫
      (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          { unop := (Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 { unop := U }.unop }.unop ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i j).c.app { unop := U } ≫
      (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
        invApp (D.f j i)
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop) ≫
          (D.U j).presheaf.map (eqToHom ⋯).op ≫
            (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: rw [(D.f j k).c.naturality, f_invApp_f_app_assoc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i j).c.app { unop := U } ≫
      (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
        invApp (D.f j i)
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop) ≫
          (D.U j).presheaf.map (eqToHom ⋯).op ≫
            (D.f j k).c.app { unop := (Opens.map (D.ι j).base).obj (⋯.functor.obj U) } =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i j).c.app { unop := U } ≫
      (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
        pullback.fst.c.app
            {
              unop :=
                (Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop } ≫
          invApp pullback.snd
              ((Opens.map pullback.fst.base).toPrefunctor.1
                ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop)) ≫
            (D.V (j, k)).presheaf.map (eqToHom ⋯) ≫ ((D.f j k).base _* (D.V (j, k)).presheaf).map (eqToHom ⋯).op =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: erw [← (D.V (j, k)).presheaf.map_comp]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i j).c.app { unop := U } ≫
      (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
        pullback.fst.c.app
            {
              unop :=
                (Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop } ≫
          invApp pullback.snd
              ((Opens.map pullback.fst.base).toPrefunctor.1
                ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop)) ≫
            (D.V (j, k)).presheaf.map (eqToHom ⋯) ≫ ((D.f j k).base _* (D.V (j, k)).presheaf).map (eqToHom ⋯).op =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i j).c.app { unop := U } ≫
      (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
        pullback.fst.c.app
            {
              unop :=
                (Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop } ≫
          invApp pullback.snd
              ((Opens.map pullback.fst.base).toPrefunctor.1
                ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop)) ≫
            (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: simp_rw [← Category.assoc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (D.f i j).c.app { unop := U } ≫
      (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U }) ≫
        pullback.fst.c.app
            {
              unop :=
                (Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop } ≫
          invApp pullback.snd
              ((Opens.map pullback.fst.base).toPrefunctor.1
                ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop)) ≫
            (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ((((D.f i j).c.app { unop := U } ≫ (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U })) ≫
          pullback.fst.c.app
            {
              unop :=
                (Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop }) ≫
        invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop))) ≫
      (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    ((pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U)) ≫
      (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: erw [← comp_c_app, ← comp_c_app]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ((((D.f i j).c.app { unop := U } ≫ (D.t j i).c.app ((Opens.map (D.f i j).base).op.obj { unop := U })) ≫
          pullback.fst.c.app
            {
              unop :=
                (Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop }) ≫
        invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop))) ≫
      (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    ((pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U)) ≫
      (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ((pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop))) ≫
      (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    ((pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U)) ≫
      (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: simp_rw [Category.assoc]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ ((pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop))) ≫
      (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    ((pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
        invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U)) ≫
      (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop)) ≫
        (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: dsimp only [Functor.op, unop_op, Quiver.Hom.unop_op]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).op.obj { unop := U }).unop)) ≫
        (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ (Opens.map (D.f j k).base).op.map (eqToHom ⋯).op) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).obj U))) ≫
        (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ ((Opens.map (D.f j k).base).map (eqToHom ⋯)).op) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: rw [eqToHom_map (Opens.map _), eqToHom_op, eqToHom_trans]
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).obj U))) ≫
        (D.V (j, k)).presheaf.map (eqToHom ⋯ ≫ ((Opens.map (D.f j k).base).map (eqToHom ⋯)).op) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).obj U))) ≫
        (D.V (j, k)).presheaf.map (eqToHom ⋯) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)

tactic: congr
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j k : D.J
U : Opens ↑↑(D.U i)
⊢ (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd
          ((Opens.map pullback.fst.base).toPrefunctor.1
            ((Opens.map (D.t j i).base).toPrefunctor.1 ((Opens.map (D.f i j).base).obj U))) ≫
        (D.V (j, k)).presheaf.map (eqToHom ⋯) =
    (pullback.fst ≫ D.t j i ≫ D.f i j).c.app { unop := U } ≫
      invApp pullback.snd ((Opens.map (pullback.fst ≫ D.t j i ≫ D.f i j).base).toPrefunctor.1 U) ≫
        (D.V (j, k)).presheaf.map (eqToHom ?w)
state_after: no goals