Theorem: CategoryTheory.RanIsSheafOfCoverLifting.helper
File: Mathlib/CategoryTheory/Sites/CoverLifting.lean

tactic: dsimp only [gluedLimitCone_π_app]
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
⊢ y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W =
    (gluedLimitCone hu ℱ hS hx).π.app ((StructuredArrow.map f.op).obj W)

tactic: apply getSection_is_unique hu ℱ hS hx ((StructuredArrow.map f.op).obj W)
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
⊢ y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W = getSection hu ℱ hS hx ((StructuredArrow.map f.op).obj W)

tactic: intro V' fV' hV'
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
⊢ IsAmalgamation (pulledbackFamily ℱ S x ((StructuredArrow.map f.op).obj W))
    (y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W)

tactic: dsimp only [Ran.adjunction, Ran.equiv, pulledbackFamily_apply]
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val ⋙ coyoneda.obj X.op).map fV'.op (y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W) =
    pulledbackFamily ℱ S x ((StructuredArrow.map f.op).obj W) fV' hV'

tactic: erw [Adjunction.adjunctionOfEquivRight_counit_app]
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val ⋙ coyoneda.obj X.op).map fV'.op (y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W) =
    x (G.map fV' ≫ ((StructuredArrow.map f.op).obj W).hom.unop) hV' ≫
      ((Adjunction.adjunctionOfEquivRight
                  (fun F G_1 =>
                    {
                        toFun := fun f =>
                          NatTrans.mk fun x =>
                            f.app ((Functor.op G).obj x) ≫
                              limit.π (Ran.diagram (Functor.op G) G_1 ((Functor.op G).obj x))
                                (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))),
                        invFun := fun f =>
                          NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) G_1 x) (Ran.cone x f),
                        left_inv :=
                          (_ :
                            ∀ (x : F ⟶ Ran.loc (Functor.op G) G_1),
                              (fun f =>
                                    NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) G_1 x) (Ran.cone x f))
                                  ((fun f =>
                                      NatTrans.mk fun x =>
                                        f.app ((Functor.op G).obj x) ≫
                                          limit.π (Ran.diagram (Functor.op G) G_1 ((Functor.op G).obj x))
                                            (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))))
                                    x) =
                                x),
                        right_inv :=
                          (_ :
                            ∀ (x : ((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj (Functor.op G)).obj F ⟶ G_1),
                              (fun f =>
                                    NatTrans.mk fun x =>
                                      f.app ((Functor.op G).obj x) ≫
                                        limit.π (Ran.diagram (Functor.op G) G_1 ((Functor.op G).obj x))
                                          (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))))
                                  ((fun f =>
                                      NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) G_1 x) (Ran.cone x f))
                                    x) =
                                x) }.symm)
                  (_ :
                    ∀ (X' X : Dᵒᵖ ⥤ A) (Y : Cᵒᵖ ⥤ A) (f : X' ⟶ X)
                      (g : ((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj (Functor.op G)).obj X ⟶ Y),
                      ↑((fun F G_1 => (Ran.equiv (Functor.op G) G_1 F).symm) X' Y)
                          (((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj (Functor.op G)).map f ≫ g) =
                        f ≫ ↑((fun F G_1 => (Ran.equiv (Functor.op G) G_1 F).symm) X Y) g)).counit.app
            ℱ.val).app
        V'.op

tactic: have :
  y ≫ ((ran G.op).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op =
    x (G.map fV' ≫ W.hom.unop ≫ f) (by simpa only using hV') := by
  convert H (show S ((G.map fV' ≫ W.hom.unop) ≫ f) by simpa only [Category.assoc] using hV')
    using 2
  simp only [Category.assoc]
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val ⋙ coyoneda.obj X.op).map fV'.op (y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W) =
    x (G.map fV' ≫ ((StructuredArrow.map f.op).obj W).hom.unop) hV' ≫
      (↑{
                    toFun := fun f =>
                      NatTrans.mk fun x =>
                        f.app ((Functor.op G).obj x) ≫
                          limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj x))
                            (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))),
                    invFun := fun f =>
                      NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) ℱ.val x) (Ran.cone x f),
                    left_inv :=
                      (_ :
                        ∀ (x : Ran.loc (Functor.op G) ℱ.val ⟶ Ran.loc (Functor.op G) ℱ.val),
                          (fun f => NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) ℱ.val x) (Ran.cone x f))
                              ((fun f =>
                                  NatTrans.mk fun x =>
                                    f.app ((Functor.op G).obj x) ≫
                                      limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj x))
                                        (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))))
                                x) =
                            x),
                    right_inv :=
                      (_ :
                        ∀
                          (x :
                            ((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj (Functor.op G)).obj (Ran.loc (Functor.op G) ℱ.val) ⟶ ℱ.val),
                          (fun f =>
                                NatTrans.mk fun x =>
                                  f.app ((Functor.op G).obj x) ≫
                                    limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj x))
                                      (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))))
                              ((fun f =>
                                  NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) ℱ.val x) (Ran.cone x f))
                                x) =
                            x) }.symm.symm
            (𝟙 (Ran.loc (Functor.op G) ℱ.val))).app
        V'.op

tactic: simp only [Quiver.Hom.unop_op, Equiv.symm_symm, StructuredArrow.map_obj_hom, unop_comp,
  Equiv.coe_fn_mk, Functor.comp_map, coyoneda_obj_map, Category.assoc, ← this, op_comp,
  ran_obj_map, NatTrans.id_app]
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
⊢ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val ⋙ coyoneda.obj X.op).map fV'.op (y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W) =
    x (G.map fV' ≫ ((StructuredArrow.map f.op).obj W).hom.unop) hV' ≫
      (↑{
                    toFun := fun f =>
                      NatTrans.mk fun x =>
                        f.app ((Functor.op G).obj x) ≫
                          limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj x))
                            (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))),
                    invFun := fun f =>
                      NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) ℱ.val x) (Ran.cone x f),
                    left_inv :=
                      (_ :
                        ∀ (x : Ran.loc (Functor.op G) ℱ.val ⟶ Ran.loc (Functor.op G) ℱ.val),
                          (fun f => NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) ℱ.val x) (Ran.cone x f))
                              ((fun f =>
                                  NatTrans.mk fun x =>
                                    f.app ((Functor.op G).obj x) ≫
                                      limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj x))
                                        (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))))
                                x) =
                            x),
                    right_inv :=
                      (_ :
                        ∀
                          (x :
                            ((whiskeringLeft Cᵒᵖ Dᵒᵖ A).obj (Functor.op G)).obj (Ran.loc (Functor.op G) ℱ.val) ⟶ ℱ.val),
                          (fun f =>
                                NatTrans.mk fun x =>
                                  f.app ((Functor.op G).obj x) ≫
                                    limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj x))
                                      (StructuredArrow.mk (𝟙 ((Functor.op G).obj x))))
                              ((fun f =>
                                  NatTrans.mk fun x => limit.lift (Ran.diagram (Functor.op G) ℱ.val x) (Ran.cone x f))
                                x) =
                            x) }.symm.symm
            (𝟙 (Ran.loc (Functor.op G) ℱ.val))).app
        V'.op

tactic: erw [Category.id_comp, limit.pre_π]
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
⊢ y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W ≫ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val).map fV'.op =
    y ≫
      limit.pre (Ran.diagram (Functor.op G) ℱ.val V.op) (StructuredArrow.map (W.hom.unop.op ≫ (G.map fV').op)) ≫
        𝟙 ((Ran.loc (Functor.op G) ℱ.val).obj ((Functor.op G).obj V'.op)) ≫
          limit.π (Ran.diagram (Functor.op G) ℱ.val ((Functor.op G).obj V'.op))
            (StructuredArrow.mk (𝟙 ((Functor.op G).obj V'.op)))

tactic: congr
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
⊢ y ≫ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W ≫ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val).map fV'.op =
    y ≫
      limit.π (Ran.diagram (Functor.op G) ℱ.val V.op)
        ((StructuredArrow.map (W.hom.unop.op ≫ (G.map fV').op)).obj (StructuredArrow.mk (𝟙 ((Functor.op G).obj V'.op))))

tactic: convert limit.w (Ran.diagram G.op ℱ.val (op V)) (StructuredArrow.homMk' W fV'.op)
state_before: case e_a
C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
⊢ limit.π (Ran.diagram (Functor.op G) ℱ.val V.op) W ≫ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val).map fV'.op =
    limit.π (Ran.diagram (Functor.op G) ℱ.val V.op)
      ((StructuredArrow.map (W.hom.unop.op ≫ (G.map fV').op)).obj (StructuredArrow.mk (𝟙 ((Functor.op G).obj V'.op))))

tactic: rw [StructuredArrow.map_mk]
state_before: case h.e'_3.h.h.e'_7
C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
e_1✝ :
  (((ran (Functor.op G)).obj ℱ.val).obj V.op ⟶ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val).obj V'.op) =
    (limit (Ran.diagram (Functor.op G) ℱ.val V.op) ⟶
      (Ran.diagram (Functor.op G) ℱ.val V.op).obj (StructuredArrow.mk (W.hom ≫ (Functor.op G).map fV'.op)))
⊢ (StructuredArrow.map (W.hom.unop.op ≫ (G.map fV').op)).obj (StructuredArrow.mk (𝟙 ((Functor.op G).obj V'.op))) =
    StructuredArrow.mk (W.hom ≫ (Functor.op G).map fV'.op)

tactic: erw [Category.comp_id]
state_before: case h.e'_3.h.h.e'_7
C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
e_1✝ :
  (((ran (Functor.op G)).obj ℱ.val).obj V.op ⟶ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val).obj V'.op) =
    (limit (Ran.diagram (Functor.op G) ℱ.val V.op) ⟶
      (Ran.diagram (Functor.op G) ℱ.val V.op).obj (StructuredArrow.mk (W.hom ≫ (Functor.op G).map fV'.op)))
⊢ StructuredArrow.mk ((W.hom.unop.op ≫ (G.map fV').op) ≫ 𝟙 ((Functor.op G).obj V'.op)) =
    StructuredArrow.mk (W.hom ≫ (Functor.op G).map fV'.op)

tactic: simp only [Quiver.Hom.unop_op, Functor.op_map, Quiver.Hom.op_unop]
state_before: case h.e'_3.h.h.e'_7
C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
this : y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'
e_1✝ :
  (((ran (Functor.op G)).obj ℱ.val).obj V.op ⟶ ((𝟭 (Cᵒᵖ ⥤ A)).obj ℱ.val).obj V'.op) =
    (limit (Ran.diagram (Functor.op G) ℱ.val V.op) ⟶
      (Ran.diagram (Functor.op G) ℱ.val V.op).obj (StructuredArrow.mk (W.hom ≫ (Functor.op G).map fV'.op)))
⊢ StructuredArrow.mk (W.hom.unop.op ≫ (G.map fV').op) = StructuredArrow.mk (W.hom ≫ (Functor.op G).map fV'.op)

tactic: simpa only using hV'
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ S.arrows (G.map fV' ≫ W.hom.unop ≫ f)

tactic: convert H (show S ((G.map fV' ≫ W.hom.unop) ≫ f) by simpa only [Category.assoc] using hV')
  using 2
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ y ≫ ((ran (Functor.op G)).obj ℱ.val).map (G.map fV' ≫ W.hom.unop).op = x (G.map fV' ≫ W.hom.unop ≫ f) hV'

tactic: simp only [Category.assoc]
state_before: case h.e'_3.h.e'_2
C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ G.map fV' ≫ W.hom.unop ≫ f = (G.map fV' ≫ W.hom.unop) ≫ f

tactic: simpa only [Category.assoc] using hV'
state_before: C D : Type u
inst✝³ : Category C
inst✝² : Category D
A : Type w
inst✝¹ : Category A
inst✝ : HasLimits A
J : GrothendieckTopology C
K : GrothendieckTopology D
G : C ⥤ D
hu : CoverLifting J K G
ℱ : Sheaf J A
X : A
U : D
S : Sieve U
hS : S ∈ GrothendieckTopology.sieves K U
x : FamilyOfElements ((ran (Functor.op G)).obj ℱ.val ⋙ coyoneda.obj X.op) S.arrows
hx : Compatible x
V : D
f : V ⟶ U
y : X ⟶ ((ran (Functor.op G)).obj ℱ.val).obj V.op
W : StructuredArrow V.op (Functor.op G)
H :
  ∀ {V' : C} {fV : G.obj V' ⟶ V} (hV : S.arrows (fV ≫ f)),
    y ≫ ((ran (Functor.op G)).obj ℱ.val).map fV.op = x (fV ≫ f) hV
V' : C
fV' : V' ⟶ ((StructuredArrow.map f.op).obj W).right.unop
hV' : Presieve.functorPullback G (Sieve.pullback ((StructuredArrow.map f.op).obj W).hom.unop S).arrows fV'
⊢ S.arrows ((G.map fV' ≫ W.hom.unop) ≫ f)