Theorem: CategoryTheory.GrothendieckTopology.Cover.multicospanComp_hom_app
File: Mathlib/CategoryTheory/Sites/Whiskering.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
⊢ ∀ {X_1 Y : WalkingMulticospan (S.index (P ⋙ F)).fstTo (S.index (P ⋙ F)).sndTo} (f : X_1 ⟶ Y),
    (S.index (P ⋙ F)).multicospan.map f ≫
        ((fun t =>
              match t with
              | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
              | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
            Y).hom =
      ((fun t =>
              match t with
              | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
              | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
            X_1).hom ≫
        ((S.index P).multicospan ⋙ F).map f
state_after: case left.left.id
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
a : (S.index (P ⋙ F)).L
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.id (WalkingMulticospan.left a)) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left a)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left a)).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.id (WalkingMulticospan.left a))

case left.right.fst
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
b : (S.index (P ⋙ F)).R
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.fst b) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left ((S.index (P ⋙ F)).fstTo b))).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.fst b)

case left.right.snd
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
b : (S.index (P ⋙ F)).R
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.snd b) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left ((S.index (P ⋙ F)).sndTo b))).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.snd b)

case right.right.id
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
b : (S.index (P ⋙ F)).R
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.id (WalkingMulticospan.right b)) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.id (WalkingMulticospan.right b))
tactic: rintro (a | b) (a | b) (f | f | f)
state_before: case left.left.id
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
a : (S.index (P ⋙ F)).L
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.id (WalkingMulticospan.left a)) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left a)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left a)).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.id (WalkingMulticospan.left a))

case left.right.fst
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
b : (S.index (P ⋙ F)).R
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.fst b) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left ((S.index (P ⋙ F)).fstTo b))).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.fst b)

case left.right.snd
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
b : (S.index (P ⋙ F)).R
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.snd b) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.left ((S.index (P ⋙ F)).sndTo b))).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.snd b)

case right.right.id
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
A : Type u₂
inst✝⁴ : Category.{v₂, u₂} A
B : Type u₃
inst✝³ : Category.{v₃, u₃} B
J : GrothendieckTopology C
U : C
R : Presieve U
F G H : A ⥤ B
η : F ⟶ G
γ : G ⟶ H
inst✝² : J.HasSheafCompose F
inst✝¹ : J.HasSheafCompose G
inst✝ : J.HasSheafCompose H
P : Cᵒᵖ ⥤ A
X : C
S : J.Cover X
b : (S.index (P ⋙ F)).R
⊢ (S.index (P ⋙ F)).multicospan.map (WalkingMulticospan.Hom.id (WalkingMulticospan.right b)) ≫
      ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom =
    ((fun t =>
            match t with
            | WalkingMulticospan.left a => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.left a))
            | WalkingMulticospan.right b => Iso.refl ((S.index (P ⋙ F)).multicospan.obj (WalkingMulticospan.right b)))
          (WalkingMulticospan.right b)).hom ≫
      ((S.index P).multicospan ⋙ F).map (WalkingMulticospan.Hom.id (WalkingMulticospan.right b))
state_after: no goals
tactic: all_goals aesop_cat