-- Mathlib/CategoryTheory/Sites/DenseSubsite/SheafEquiv.lean
lemma isIso_ranCounit_app_of_isDenseSubsite (Y : Sheaf J A) (U X) :
    IsIso ((yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X))

Proof state:
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
f : (yoneda.obj (((𝟭 (Cᵒᵖ ⥤ A)).obj Y.val).obj (op U))).obj (op X)
l : (X Y Z : C) → (f : X ⟶ Y) → (g : G.obj Y ⟶ G.obj Z) → (G.imageSieve g).arrows f → (X ⟶ Z)
hl :
  ∀ (X Y Z : C) (f : X ⟶ Y) (g : G.obj Y ⟶ G.obj Z) (hf : (G.imageSieve g).arrows f),
    G.map (l X Y Z f g hf) = G.map f ≫ g
W₁ : C
g₁ : op (G.obj U) ⟶ op (G.obj W₁)
W₂ : C
g₂ : op (G.obj U) ⟶ op (G.obj W₂)
i : op W₁ ⟶ op W₂
hi : 𝟙 (op (G.obj U)) ≫ g₂ = g₁ ≫ (G.map i.unop).op
⊢ g₂ = g₁ ≫ (G.map i.unop).op

Tactic:
simpa only [Category.id_comp] using hi

Result:
no goals

Proof state:
case right
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
f : (yoneda.obj (((𝟭 (Cᵒᵖ ⥤ A)).obj Y.val).obj (op U))).obj (op X)
l : (X Y Z : C) → (f : X ⟶ Y) → (g : G.obj Y ⟶ G.obj Z) → (G.imageSieve g).arrows f → (X ⟶ Z)
hl :
  ∀ (X Y Z : C) (f : X ⟶ Y) (g : G.obj Y ⟶ G.obj Z) (hf : (G.imageSieve g).arrows f),
    G.map (l X Y Z f g hf) = G.map f ≫ g
c : Limits.Cone (StructuredArrow.proj (op (G.obj U)) G.op ⋙ Y.val) :=
  { pt := X,
    π :=
      {
        app := fun g =>
          ⋯.amalgamate ⟨G.imageSieve g.hom.unop, ⋯⟩ (fun I => f ≫ Y.val.map (l I.Y (unop g.2) U I.f g.hom.unop ⋯).op) ⋯,
        naturality := ⋯ } }
⊢ ∃ a, (yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X) a = f

Tactic:
refine ⟨(isPointwiseRightKanExtensionRanCounit G.op Y.1 (.op (G.obj U))).lift c, ?_⟩

Result:
case right
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
f : (yoneda.obj (((𝟭 (Cᵒᵖ ⥤ A)).obj Y.val).obj (op U))).obj (op X)
l : (X Y Z : C) → (f : X ⟶ Y) → (g : G.obj Y ⟶ G.obj Z) → (G.imageSieve g).arrows f → (X ⟶ Z)
hl :
  ∀ (X Y Z : C) (f : X ⟶ Y) (g : G.obj Y ⟶ G.obj Z) (hf : (G.imageSieve g).arrows f),
    G.map (l X Y Z f g hf) = G.map f ≫ g
c : Limits.Cone (StructuredArrow.proj (op (G.obj U)) G.op ⋙ Y.val) :=
  { pt := X,
    π :=
      {
        app := fun g =>
          ⋯.amalgamate ⟨G.imageSieve g.hom.unop, ⋯⟩ (fun I => f ≫ Y.val.map (l I.Y (unop g.2) U I.f g.hom.unop ⋯).op) ⋯,
        naturality := ⋯ } }
⊢ (yoneda.map ((G.op.ranCounit.app Y.val).app (op U))).app (op X)
      ((G.op.isPointwiseRightKanExtensionRanCounit Y.val (op (G.obj U))).lift c) =
    f

Proof state:
case refine_2.mk.mk.unit.op.mk.mk.unit.op.mk.up.up.refl.refl.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
f : (yoneda.obj (((𝟭 (Cᵒᵖ ⥤ A)).obj Y.val).obj (op U))).obj (op X)
l : (X Y Z : C) → (f : X ⟶ Y) → (g : G.obj Y ⟶ G.obj Z) → (G.imageSieve g).arrows f → (X ⟶ Z)
hl :
  ∀ (X Y Z : C) (f : X ⟶ Y) (g : G.obj Y ⟶ G.obj Z) (hf : (G.imageSieve g).arrows f),
    G.map (l X Y Z f g hf) = G.map f ≫ g
W₁ W₂ : C
i : op W₁ ⟶ op W₂
g : G.obj W₁ ⟶ G.obj U
hi : 𝟙 (op (G.obj U)) ≫ g.op ≫ (G.map i.unop).op = g.op ≫ (G.map i.unop).op
⊢ 𝟙 X ≫
      ⋯.amalgamate
        ⟨G.imageSieve { left := { as := PUnit.unit }, right := op W₂, hom := g.op ≫ (G.map i.unop).op }.hom.unop, ⋯⟩
        (fun I =>
          f ≫
            Y.val.map
              (l I.Y (unop { left := { as := PUnit.unit }, right := op W₂, hom := g.op ≫ (G.map i.unop).op }.2) U I.f
                  { left := { as := PUnit.unit }, right := op W₂, hom := g.op ≫ (G.map i.unop).op }.hom.unop ⋯).op)
        ⋯ =
    ⋯.amalgamate ⟨G.imageSieve { left := { as := PUnit.unit }, right := op W₁, hom := g.op }.hom.unop, ⋯⟩
        (fun I =>
          f ≫
            Y.val.map
              (l I.Y (unop { left := { as := PUnit.unit }, right := op W₁, hom := g.op }.2) U I.f
                  { left := { as := PUnit.unit }, right := op W₁, hom := g.op }.hom.unop ⋯).op)
        ⋯ ≫
      Y.val.map { left := { down := { down := ⋯ } }, right := i, w := hi }.right

Tactic:
have h : ∃ i' : W₂ ⟶ W₁, i = i'.op := ⟨i.unop, rfl⟩

Result:
case refine_2.mk.mk.unit.op.mk.mk.unit.op.mk.up.up.refl.refl.intro
C : Type u_1
D : Type u_2
inst✝⁴ : Category.{u_3, u_1} C
inst✝³ : Category.{u_4, u_2} D
G : C ⥤ D
J : GrothendieckTopology C
K : GrothendieckTopology D
A : Type w
inst✝² : Category.{w', w} A
inst✝¹ : ∀ (X : Dᵒᵖ), Limits.HasLimitsOfShape (StructuredArrow X G.op) A
inst✝ : IsDenseSubsite J K G
Y : Sheaf J A
U : C
X : A
f : (yoneda.obj (((𝟭 (Cᵒᵖ ⥤ A)).obj Y.val).obj (op U))).obj (op X)
l : (X Y Z : C) → (f : X ⟶ Y) → (g : G.obj Y ⟶ G.obj Z) → (G.imageSieve g).arrows f → (X ⟶ Z)
hl :
  ∀ (X Y Z : C) (f : X ⟶ Y) (g : G.obj Y ⟶ G.obj Z) (hf : (G.imageSieve g).arrows f),
    G.map (l X Y Z f g hf) = G.map f ≫ g
W₁ W₂ : C
i : op W₁ ⟶ op W₂
g : G.obj W₁ ⟶ G.obj U
hi : 𝟙 (op (G.obj U)) ≫ g.op ≫ (G.map i.unop).op = g.op ≫ (G.map i.unop).op
h : ∃ i', i = i'.op
⊢ 𝟙 X ≫
      ⋯.amalgamate
        ⟨G.imageSieve { left := { as := PUnit.unit }, right := op W₂, hom := g.op ≫ (G.map i.unop).op }.hom.unop, ⋯⟩
        (fun I =>
          f ≫
            Y.val.map
              (l I.Y (unop { left := { as := PUnit.unit }, right := op W₂, hom := g.op ≫ (G.map i.unop).op }.2) U I.f
                  { left := { as := PUnit.unit }, right := op W₂, hom := g.op ≫ (G.map i.unop).op }.hom.unop ⋯).op)
        ⋯ =
    ⋯.amalgamate ⟨G.imageSieve { left := { as := PUnit.unit }, right := op W₁, hom := g.op }.hom.unop, ⋯⟩
        (fun I =>
          f ≫
            Y.val.map
              (l I.Y (unop { left := { as := PUnit.unit }, right := op W₁, hom := g.op }.2) U I.f
                  { left := { as := PUnit.unit }, right := op W₁, hom := g.op }.hom.unop ⋯).op)
        ⋯ ≫
      Y.val.map { left := { down := { down := ⋯ } }, right := i, w := hi }.right