Theorem: AlgebraicGeometry.PresheafedSpace.GlueData.π_ιInvApp_π
File: Mathlib/Geometry/RingedSpace/PresheafedSpace/Gluing.lean

tactic: simp_rw [Category.assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ (D.diagramOverOpenπ U i ≫ D.ιInvAppπEqMap U ≫ D.ιInvApp U ≫ D.diagramOverOpenπ U j) ≫
      (componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
          (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
        𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) }) =
    D.diagramOverOpenπ U j ≫
      (componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
          (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
        𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        D.ιInvApp U ≫
          D.diagramOverOpenπ U j ≫
            (componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
                (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
              𝟙
                ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj
                  { unop := WalkingMultispan.left (i, j) }) =
    D.diagramOverOpenπ U j ≫
      (componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
          (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
        𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })

tactic: rw [limit.w_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        D.ιInvApp U ≫
          D.diagramOverOpenπ U j ≫
            (componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
                (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
              𝟙
                ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj
                  { unop := WalkingMultispan.left (i, j) }) =
    D.diagramOverOpenπ U j ≫
      (componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
          (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
        𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        D.ιInvApp U ≫
          limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) } ≫
            𝟙
              ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj
                { unop := WalkingMultispan.left (i, j) }) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) } ≫
      𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })

tactic: erw [limit.lift_π_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        D.ιInvApp U ≫
          limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) } ≫
            𝟙
              ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj
                { unop := WalkingMultispan.left (i, j) }) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) } ≫
      𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        { pt := (D.U i).presheaf.obj { unop := U },
                  π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } }.π.app
            { unop := WalkingMultispan.left (i, j) } ≫
          𝟙
            ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj
              { unop := WalkingMultispan.left (i, j) }) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) } ≫
      𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })

tactic: rw [Category.comp_id, Category.comp_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        { pt := (D.U i).presheaf.obj { unop := U },
                  π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } }.π.app
            { unop := WalkingMultispan.left (i, j) } ≫
          𝟙
            ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj
              { unop := WalkingMultispan.left (i, j) }) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) } ≫
      𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) })
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        { pt := (D.U i).presheaf.obj { unop := U },
                π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } }.π.app
          { unop := WalkingMultispan.left (i, j) } =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: change _ ≫ _ ≫ (_ ≫ _) ≫ _ = _
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        { pt := (D.U i).presheaf.obj { unop := U },
                π := { app := fun j => D.ιInvAppπApp U j.unop, naturality := ⋯ } }.π.app
          { unop := WalkingMultispan.left (i, j) } =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        ((D.f i i).c.app { unop := U } ≫
            (D.t i i).c.app ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫
              invApp (D.f i i)
                  {
                      unop :=
                        (Opens.map (D.t i i).base).toPrefunctor.1
                          ((Opens.map (D.f i i).base).op.obj { unop := U }).unop }.unop ≫
                (D.U i).presheaf.map (eqToHom ⋯).op) ≫
          (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
            (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: rw [congr_app (D.t_id _), id_c_app]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        ((D.f i i).c.app { unop := U } ≫
            (D.t i i).c.app ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫
              invApp (D.f i i)
                  {
                      unop :=
                        (Opens.map (D.t i i).base).toPrefunctor.1
                          ((Opens.map (D.f i i).base).op.obj { unop := U }).unop }.unop ≫
                (D.U i).presheaf.map (eqToHom ⋯).op) ≫
          (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
            (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        ((D.f i i).c.app { unop := U } ≫
            ((D.V (i, i)).presheaf.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U })) ≫
                (D.V (i, i)).presheaf.map (eqToHom ⋯)) ≫
              invApp (D.f i i)
                  {
                      unop :=
                        (Opens.map (D.t i i).base).toPrefunctor.1
                          ((Opens.map (D.f i i).base).op.obj { unop := U }).unop }.unop ≫
                (D.U i).presheaf.map (eqToHom ⋯).op) ≫
          (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
            (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: simp_rw [Category.assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        ((D.f i i).c.app { unop := U } ≫
            ((D.V (i, i)).presheaf.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U })) ≫
                (D.V (i, i)).presheaf.map (eqToHom ⋯)) ≫
              invApp (D.f i i)
                  {
                      unop :=
                        (Opens.map (D.t i i).base).toPrefunctor.1
                          ((Opens.map (D.f i i).base).op.obj { unop := U }).unop }.unop ≫
                (D.U i).presheaf.map (eqToHom ⋯).op) ≫
          (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
            (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.f i i).c.app { unop := U } ≫
          (D.V (i, i)).presheaf.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U })) ≫
            (D.V (i, i)).presheaf.map (eqToHom ⋯) ≫
              invApp (D.f i i)
                  ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).op.obj { unop := U }).unop) ≫
                (D.U i).presheaf.map (eqToHom ⋯).op ≫
                  (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                    (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: rw [← Functor.map_comp_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.f i i).c.app { unop := U } ≫
          (D.V (i, i)).presheaf.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U })) ≫
            (D.V (i, i)).presheaf.map (eqToHom ⋯) ≫
              invApp (D.f i i)
                  ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).op.obj { unop := U }).unop) ≫
                (D.U i).presheaf.map (eqToHom ⋯).op ≫
                  (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                    (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.f i i).c.app { unop := U } ≫
          (D.V (i, i)).presheaf.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯) ≫
            invApp (D.f i i)
                ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).op.obj { unop := U }).unop) ≫
              (D.U i).presheaf.map (eqToHom ⋯).op ≫
                (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                  (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: erw [IsOpenImmersion.inv_naturality_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.f i i).c.app { unop := U } ≫
          (D.V (i, i)).presheaf.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯) ≫
            invApp (D.f i i)
                ((Opens.map (D.t i i).base).toPrefunctor.1 ((Opens.map (D.f i i).base).op.obj { unop := U }).unop) ≫
              (D.U i).presheaf.map (eqToHom ⋯).op ≫
                (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                  (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.f i i).c.app { unop := U } ≫
          invApp (D.f i i) ((Opens.map (D.f i i).base).op.obj { unop := U }).unop ≫
            (D.U i).presheaf.map
                ((opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
              (D.U i).presheaf.map (eqToHom ⋯).op ≫
                (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                  (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: erw [IsOpenImmersion.app_invApp_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.f i i).c.app { unop := U } ≫
          invApp (D.f i i) ((Opens.map (D.f i i).base).op.obj { unop := U }).unop ≫
            (D.U i).presheaf.map
                ((opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
              (D.U i).presheaf.map (eqToHom ⋯).op ≫
                (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                  (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.U i).presheaf.map (homOfLE ⋯).op ≫
          (D.U i).presheaf.map
              ((opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
            (D.U i).presheaf.map (eqToHom ⋯).op ≫
              (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: iterate 3 rw [← Functor.map_comp_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      D.ιInvAppπEqMap U ≫
        (D.U i).presheaf.map (homOfLE ⋯).op ≫
          (D.U i).presheaf.map
              ((opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
            (D.U i).presheaf.map (eqToHom ⋯).op ≫
              (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
                (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.U i).presheaf.map
          ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
              (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
            (eqToHom ⋯).op) ≫
        (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
          (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: rw [NatTrans.naturality_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.U i).presheaf.map
          ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
              (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
            (eqToHom ⋯).op) ≫
        (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
          (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.f i j).c.app
          {
            unop :=
              (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
                (⋯.functor.obj U) } ≫
        ((D.f i j).base _* (D.V (i, j)).presheaf).map
            ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
                (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
              (eqToHom ⋯).op) ≫
          (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: erw [← (D.V (i, j)).presheaf.map_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.f i j).c.app
          {
            unop :=
              (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
                (⋯.functor.obj U) } ≫
        ((D.f i j).base _* (D.V (i, j)).presheaf).map
            ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
                (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
              (eqToHom ⋯).op) ≫
          (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.f i j).c.app
          {
            unop :=
              (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
                (⋯.functor.obj U) } ≫
        (D.V (i, j)).presheaf.map
          ((Opens.map (D.f i j).base).op.map
              ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
                  (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
                (eqToHom ⋯).op) ≫
            eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }

tactic: convert
  limit.w (componentwiseDiagram 𝖣.diagram.multispan _)
    (Quiver.Hom.op (WalkingMultispan.Hom.fst (i, j)))
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.f i j).c.app
          {
            unop :=
              (Opens.map (colimit.ι D.diagram.multispan { unop := WalkingMultispan.right i }.unop).base).obj
                (⋯.functor.obj U) } ≫
        (D.V (i, j)).presheaf.map
          ((Opens.map (D.f i j).base).op.map
              ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
                  (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
                (eqToHom ⋯).op) ≫
            eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: no goals

tactic: rw [Category.comp_id]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map
        (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))) ≫
      𝟙 ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).obj { unop := WalkingMultispan.left (i, j) }))
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))))

tactic: apply (config := { allowSynthFailures := true }) mono_comp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((componentwiseDiagram D.diagram.multispan (⋯.functor.obj U)).map (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))))
state_after: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.diagram.multispan.map (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))).unop).c.app
      {
        unop :=
          (Opens.map
                (colimit.ι D.diagram.multispan
                    { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
            (⋯.functor.obj U) })

tactic: change Mono ((_ ≫ D.f j i).c.app _)
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.diagram.multispan.map (Quiver.Hom.op (WalkingMultispan.Hom.snd (i, j))).unop).c.app
      {
        unop :=
          (Opens.map
                (colimit.ι D.diagram.multispan
                    { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
            (⋯.functor.obj U) })
state_after: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.t i j ≫ D.f j i).c.app
      {
        unop :=
          (Opens.map
                (colimit.ι D.diagram.multispan
                    { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
            (⋯.functor.obj U) })

tactic: rw [comp_c_app]
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.t i j ≫ D.f j i).c.app
      {
        unop :=
          (Opens.map
                (colimit.ι D.diagram.multispan
                    { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
            (⋯.functor.obj U) })
state_after: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.f j i).c.app
        {
          unop :=
            (Opens.map
                  (colimit.ι D.diagram.multispan
                      { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
              (⋯.functor.obj U) } ≫
      (D.t i j).c.app
        {
          unop :=
            (Opens.map (D.f j i).base).obj
              {
                  unop :=
                    (Opens.map
                          (colimit.ι D.diagram.multispan
                              { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
                      (⋯.functor.obj U) }.unop })

tactic: apply (config := { allowSynthFailures := true }) mono_comp
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.f j i).c.app
        {
          unop :=
            (Opens.map
                  (colimit.ι D.diagram.multispan
                      { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
              (⋯.functor.obj U) } ≫
      (D.t i j).c.app
        {
          unop :=
            (Opens.map (D.f j i).base).obj
              {
                  unop :=
                    (Opens.map
                          (colimit.ι D.diagram.multispan
                              { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
                      (⋯.functor.obj U) }.unop })
state_after: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.f j i).c.app
      {
        unop :=
          (Opens.map
                (colimit.ι D.diagram.multispan
                    { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
            (⋯.functor.obj U) })

case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.t i j).c.app
      {
        unop :=
          (Opens.map (D.f j i).base).obj
            {
                unop :=
                  (Opens.map
                        (colimit.ι D.diagram.multispan
                            { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
                    (⋯.functor.obj U) }.unop })

tactic: erw [D.ι_image_preimage_eq i j U]
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.f j i).c.app
      {
        unop :=
          (Opens.map
                (colimit.ι D.diagram.multispan
                    { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
            (⋯.functor.obj U) })
state_after: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.f j i).c.app
      { unop := (opensFunctor (D.f j i)).obj ((Opens.map (D.t j i).base).obj ((Opens.map (D.f i j).base).obj U)) })

tactic: infer_instance
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.f j i).c.app
      { unop := (opensFunctor (D.f j i)).obj ((Opens.map (D.t j i).base).obj ((Opens.map (D.f i j).base).obj U)) })
state_after: no goals

tactic: have : IsIso (D.t i j).c := by apply c_isIso_of_iso
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ Mono
    ((D.t i j).c.app
      {
        unop :=
          (Opens.map (D.f j i).base).obj
            {
                unop :=
                  (Opens.map
                        (colimit.ι D.diagram.multispan
                            { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
                    (⋯.functor.obj U) }.unop })
state_after: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
this : IsIso (D.t i j).c
⊢ Mono
    ((D.t i j).c.app
      {
        unop :=
          (Opens.map (D.f j i).base).obj
            {
                unop :=
                  (Opens.map
                        (colimit.ι D.diagram.multispan
                            { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
                    (⋯.functor.obj U) }.unop })

tactic: infer_instance
state_before: case inst
C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
this : IsIso (D.t i j).c
⊢ Mono
    ((D.t i j).c.app
      {
        unop :=
          (Opens.map (D.f j i).base).obj
            {
                unop :=
                  (Opens.map
                        (colimit.ι D.diagram.multispan
                            { unop := WalkingMultispan.right (D.diagram.sndFrom (i, j)) }.unop).base).obj
                    (⋯.functor.obj U) }.unop })
state_after: no goals

tactic: apply c_isIso_of_iso
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ IsIso (D.t i j).c
state_after: no goals

tactic: rw [← Functor.map_comp_assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.U i).presheaf.map
          (((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
            (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
        (D.U i).presheaf.map (eqToHom ⋯).op ≫
          (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
            (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }
state_after: C : Type u
inst✝¹ : Category.{v, u} C
D : GlueData C
inst✝ : HasLimits C
i j : D.J
U : Opens ↑↑(D.U i)
⊢ D.diagramOverOpenπ U i ≫
      (D.U i).presheaf.map
          ((((eqToIso ⋯).inv ≫ (homOfLE ⋯).op) ≫
              (opensFunctor (D.f i i)).op.map (𝟙 ((Opens.map (D.f i i).base).op.obj { unop := U }) ≫ eqToHom ⋯)) ≫
            (eqToHom ⋯).op) ≫
        (D.f i j).c.app { unop := (Opens.map (D.ι i).base).obj (⋯.functor.obj U) } ≫
          (D.V (i, j)).presheaf.map (eqToHom ⋯) =
    limit.π (D.diagramOverOpen U) { unop := WalkingMultispan.left (i, j) }