l3lab/ntp-mathlib huggingface dataset:
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    

Proof state:
case w.h.h.h
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
x : ((coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.86325)).obj ℱ).obj X).obj U
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
⊢ (ℱ'.val ⋙ coyoneda.obj (op Y.unop)).map f'.op (f.unop ≫ appHom (homOver α X.unop) U.unop x) =
    (fun Y_1 f_1 h => pushforwardFamily (homOver α Y.unop) (f.unop ≫ x) f_1 h) Y' f' hf'

Next tactic:
change unop X ⟶ ℱ.obj (op (unop _)) at x
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    

Proof state:
case w.h.h.h
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ (ℱ'.val ⋙ coyoneda.obj (op Y.unop)).map f'.op (f.unop ≫ appHom (homOver α X.unop) U.unop x) =
    (fun Y_1 f_1 h => pushforwardFamily (homOver α Y.unop) (f.unop ≫ x) f_1 h) Y' f' hf'

Next tactic:
dsimp
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    

Proof state:
case w.h.h.h
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ (f.unop ≫ appHom (homOver α X.unop) U.unop x) ≫ ℱ'.val.map f'.op =
    (((f.unop ≫ x) ≫ ℱ.map (Nonempty.some hf').map.op) ≫ α.app (op (Nonempty.some hf').1)) ≫
      ℱ'.val.map (Nonempty.some hf').lift.op

Next tactic:
simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    

Proof state:
case w.h.h.h
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ f.unop ≫ appHom (homOver α X.unop) U.unop x ≫ ℱ'.val.map f'.op =
    f.unop ≫
      x ≫ ℱ.map (Nonempty.some hf').map.op ≫ α.app (op (Nonempty.some hf').1) ≫ ℱ'.val.map (Nonempty.some hf').lift.op

Next tactic:
congr 1
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    congr 1
    

Proof state:
case w.h.h.h.e_a
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ appHom (homOver α X.unop) U.unop x ≫ ℱ'.val.map f'.op =
    x ≫ ℱ.map (Nonempty.some hf').map.op ≫ α.app (op (Nonempty.some hf').1) ≫ ℱ'.val.map (Nonempty.some hf').lift.op

Next tactic:
conv_lhs => rw [← hf'.some.fac]
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    congr 1
    conv_lhs => 

Proof state:
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
| appHom (homOver α X.unop) U.unop x ≫ ℱ'.val.map f'.op

Next tactic:
rw [← hf'.some.fac]
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    congr 1
    conv_lhs => rw [← hf'.some.fac]
    

Proof state:
case w.h.h.h.e_a
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ appHom (homOver α X.unop) U.unop x ≫ ℱ'.val.map ((Nonempty.some hf').lift ≫ (Nonempty.some hf').map).op =
    x ≫ ℱ.map (Nonempty.some hf').map.op ≫ α.app (op (Nonempty.some hf').1) ≫ ℱ'.val.map (Nonempty.some hf').lift.op

Next tactic:
simp only [← Category.assoc, op_comp, Functor.map_comp]
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    congr 1
    conv_lhs => rw [← hf'.some.fac]
    simp only [← Category.assoc, op_comp, Functor.map_comp]
    

Proof state:
case w.h.h.h.e_a
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ (appHom (homOver α X.unop) U.unop x ≫ ℱ'.val.map (Nonempty.some hf').map.op) ≫
      ℱ'.val.map (Nonempty.some hf').lift.op =
    ((x ≫ ℱ.map (Nonempty.some hf').map.op) ≫ α.app (op (Nonempty.some hf').1)) ≫ ℱ'.val.map (Nonempty.some hf').lift.op

Next tactic:
congr 1
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    congr 1
    conv_lhs => rw [← hf'.some.fac]
    simp only [← Category.assoc, op_comp, Functor.map_comp]
    congr 1
    

Proof state:
case w.h.h.h.e_a.e_a
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ appHom (homOver α X.unop) U.unop x ≫ ℱ'.val.map (Nonempty.some hf').map.op =
    (x ≫ ℱ.map (Nonempty.some hf').map.op) ≫ α.app (op (Nonempty.some hf').1)

Next tactic:
refine' (appHom_restrict (homOver α (unop X)) hf'.some.map.op x).trans _
/-- (Implementation). The sheaf map given in `types.sheaf_hom` is natural in terms of `X`. -/
@[simps]
noncomputable def sheafCoyonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ ⟶
      coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type _)).obj ℱ'.val where
  app X := presheafHom (homOver α (unop X))
  naturality X Y f := by
    ext U x
    change
      appHom (homOver α (unop Y)) (unop U) (f.unop ≫ x) =
        f.unop ≫ appHom (homOver α (unop X)) (unop U) x
    symm
    apply sheaf_eq_amalgamation
    apply G.is_cover_of_isCoverDense
    -- porting note: the following line closes a goal which didn't exist before reenableeta
    · exact pushforwardFamily_compatible (homOver α Y.unop) (f.unop ≫ x)
    intro Y' f' hf'
    change unop X ⟶ ℱ.obj (op (unop _)) at x
    dsimp
    simp only [pushforwardFamily, Functor.comp_map, coyoneda_obj_map, homOver_app, Category.assoc]
    congr 1
    conv_lhs => rw [← hf'.some.fac]
    simp only [← Category.assoc, op_comp, Functor.map_comp]
    congr 1
    refine' (appHom_restrict (homOver α (unop X)) hf'.some.map.op x).trans _
    

Proof state:
case w.h.h.h.e_a.e_a
C : Type u_1
inst✝⁵ : Category.{?u.83243, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.83250, u_2} D
E : Type u_3
inst✝³ : Category.{?u.83257, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.86325, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
X Y : Aᵒᵖ
f : X ⟶ Y
U : Dᵒᵖ
Y' : D
f' : Y' ⟶ U.unop
hf' : (Sieve.coverByImage G U.unop).arrows f'
x : X.unop ⟶ ℱ.obj (op U.unop)
⊢ (homOver α X.unop).app (op (Nonempty.some hf').obj)
      ((ℱ ⋙ coyoneda.obj (op X.unop)).map (Nonempty.some hf').map.op x) =
    (x ≫ ℱ.map (Nonempty.some hf').map.op) ≫ α.app (op (Nonempty.some hf').1)

Next tactic:
simp
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  

Proof state:
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
⊢ ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda

Next tactic:
let α := sheafCoyonedaHom α
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  let α := sheafCoyonedaHom α
  

Proof state:
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α✝ : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
α : coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ ⟶
  coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ'.val :=
  sheafCoyonedaHom α✝
⊢ ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda

Next tactic:
refine'
    { app := _
      naturality := _ }
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  let α := sheafCoyonedaHom α
  refine'
    { app := _
      naturality := _ }
  · 

Proof state:
case refine'_1
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α✝ : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
α : coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ ⟶
  coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ'.val :=
  sheafCoyonedaHom α✝
⊢ (X : Dᵒᵖ) → (ℱ ⋙ yoneda).obj X ⟶ (ℱ'.val ⋙ yoneda).obj X

Next tactic:
intro U
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  let α := sheafCoyonedaHom α
  refine'
    { app := _
      naturality := _ }
  · intro U
    

Proof state:
case refine'_1
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α✝ : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
α : coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ ⟶
  coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ'.val :=
  sheafCoyonedaHom α✝
U : Dᵒᵖ
⊢ (ℱ ⋙ yoneda).obj U ⟶ (ℱ'.val ⋙ yoneda).obj U

Next tactic:
refine'
      { app := fun X => (α.app X).app U
        naturality := fun X Y f => by simpa using congr_app (α.naturality f) U }
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  let α := sheafCoyonedaHom α
  refine'
    { app := _
      naturality := _ }
  · intro U
    refine'
      { app := fun X => (α.app X).app U
        naturality := fun X Y f => by 

Proof state:
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α✝ : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
α : coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ ⟶
  coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ'.val :=
  sheafCoyonedaHom α✝
U : Dᵒᵖ
X Y : Aᵒᵖ
f : X ⟶ Y
⊢ ((ℱ ⋙ yoneda).obj U).map f ≫ (fun X => (α.app X).app U) Y =
    (fun X => (α.app X).app U) X ≫ ((ℱ'.val ⋙ yoneda).obj U).map f

Next tactic:
simpa using congr_app (α.naturality f) U
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  let α := sheafCoyonedaHom α
  refine'
    { app := _
      naturality := _ }
  · intro U
    refine'
      { app := fun X => (α.app X).app U
        naturality := fun X Y f => by simpa using congr_app (α.naturality f) U }
  · 

Proof state:
case refine'_2
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α✝ : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
α : coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ ⟶
  coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ'.val :=
  sheafCoyonedaHom α✝
⊢ ∀ ⦃X Y : Dᵒᵖ⦄ (f : X ⟶ Y),
    ((ℱ ⋙ yoneda).map f ≫ NatTrans.mk fun X => (α.app X).app Y) =
      (NatTrans.mk fun X_1 => (α.app X_1).app X) ≫ (ℱ'.val ⋙ yoneda).map f

Next tactic:
intro U V i
/--
(Implementation). `sheafCoyonedaHom` but the order of the arguments of the functor are swapped.
-/
noncomputable def sheafYonedaHom (α : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val) :
    ℱ ⋙ yoneda ⟶ ℱ'.val ⋙ yoneda := by
  let α := sheafCoyonedaHom α
  refine'
    { app := _
      naturality := _ }
  · intro U
    refine'
      { app := fun X => (α.app X).app U
        naturality := fun X Y f => by simpa using congr_app (α.naturality f) U }
  · intro U V i
    

Proof state:
case refine'_2
C : Type u_1
inst✝⁵ : Category.{?u.91921, u_1} C
D : Type u_2
inst✝⁴ : Category.{?u.91928, u_2} D
E : Type u_3
inst✝³ : Category.{?u.91935, u_3} E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type u_4
inst✝² : Category.{?u.91987, u_4} A
G : C ⥤ D
inst✝¹ : IsCoverDense G K
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ A
ℱ' : Sheaf K A
α✝ : G.op ⋙ ℱ ⟶ G.op ⋙ ℱ'.val
α : coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ ⟶
  coyoneda ⋙ (whiskeringLeft Dᵒᵖ A (Type ?u.91987)).obj ℱ'.val :=
  sheafCoyonedaHom α✝
U V : Dᵒᵖ
i : U ⟶ V
⊢ ((ℱ ⋙ yoneda).map i ≫ NatTrans.mk fun X => (α.app X).app V) =
    (NatTrans.mk fun X => (α.app X).app U) ≫ (ℱ'.val ⋙ yoneda).map i

Next tactic:
ext X x