Theorem: CategoryTheory.currying_inverse_map_app_app
File: Mathlib/CategoryTheory/Functor/Currying.lean

Proof steps:
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
X : C × D
⊢ ((curry ⋙ uncurry).obj F).obj X = ((𝟭 (C × D ⥤ E)).obj F).obj X
state_after: no goals
tactic: simp
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
⊢ ∀ {X Y : C × D} (f : X ⟶ Y),
    ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
state_after: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
X Y : C × D
f : X ⟶ Y
⊢ ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
    ((fun X => eqToIso ⋯) X).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
tactic: intros X Y f
state_before: B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
X Y : C × D
f : X ⟶ Y
⊢ ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
    ((fun X => eqToIso ⋯) X).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
state_after: case mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
Y : C × D
fst✝ : C
snd✝ : D
f : (fst✝, snd✝) ⟶ Y
⊢ ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
    ((fun X => eqToIso ⋯) (fst✝, snd✝)).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
tactic: cases X
state_before: case mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
Y : C × D
fst✝ : C
snd✝ : D
f : (fst✝, snd✝) ⟶ Y
⊢ ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
    ((fun X => eqToIso ⋯) (fst✝, snd✝)).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
state_after: case mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝¹ : C
snd✝¹ : D
fst✝ : C
snd✝ : D
f : (fst✝¹, snd✝¹) ⟶ (fst✝, snd✝)
⊢ ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) (fst✝, snd✝)).hom =
    ((fun X => eqToIso ⋯) (fst✝¹, snd✝¹)).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
tactic: cases Y
state_before: case mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝¹ : C
snd✝¹ : D
fst✝ : C
snd✝ : D
f : (fst✝¹, snd✝¹) ⟶ (fst✝, snd✝)
⊢ ((curry ⋙ uncurry).obj F).map f ≫ ((fun X => eqToIso ⋯) (fst✝, snd✝)).hom =
    ((fun X => eqToIso ⋯) (fst✝¹, snd✝¹)).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map f
state_after: case mk.mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝² : C
snd✝² : D
fst✝¹ : C
snd✝¹ : D
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝¹, snd✝¹).2
⊢ ((curry ⋙ uncurry).obj F).map (fst✝, snd✝) ≫ ((fun X => eqToIso ⋯) (fst✝¹, snd✝¹)).hom =
    ((fun X => eqToIso ⋯) (fst✝², snd✝²)).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map (fst✝, snd✝)
tactic: cases f
state_before: case mk.mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝² : C
snd✝² : D
fst✝¹ : C
snd✝¹ : D
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝¹, snd✝¹).2
⊢ ((curry ⋙ uncurry).obj F).map (fst✝, snd✝) ≫ ((fun X => eqToIso ⋯) (fst✝¹, snd✝¹)).hom =
    ((fun X => eqToIso ⋯) (fst✝², snd✝²)).hom ≫ ((𝟭 (C × D ⥤ E)).obj F).map (fst✝, snd✝)
state_after: case mk.mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝² : C
snd✝² : D
fst✝¹ : C
snd✝¹ : D
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝¹, snd✝¹).2
⊢ (F.map (fst✝, 𝟙 snd✝²) ≫ F.map (𝟙 fst✝¹, snd✝)) ≫ 𝟙 (F.obj (fst✝¹, snd✝¹)) =
    𝟙 (F.obj (fst✝², snd✝²)) ≫ F.map (fst✝, snd✝)
tactic: dsimp at *
state_before: case mk.mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝² : C
snd✝² : D
fst✝¹ : C
snd✝¹ : D
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝¹, snd✝¹).2
⊢ (F.map (fst✝, 𝟙 snd✝²) ≫ F.map (𝟙 fst✝¹, snd✝)) ≫ 𝟙 (F.obj (fst✝¹, snd✝¹)) =
    𝟙 (F.obj (fst✝², snd✝²)) ≫ F.map (fst✝, snd✝)
state_after: case mk.mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝² : C
snd✝² : D
fst✝¹ : C
snd✝¹ : D
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝¹, snd✝¹).2
⊢ F.map ((fst✝, 𝟙 snd✝²) ≫ (𝟙 fst✝¹, snd✝)) ≫ 𝟙 (F.obj (fst✝¹, snd✝¹)) = 𝟙 (F.obj (fst✝², snd✝²)) ≫ F.map (fst✝, snd✝)
tactic: rw [← F.map_comp]
state_before: case mk.mk.mk
B : Type u₁
inst✝⁴ : Category.{v₁, u₁} B
C : Type u₂
inst✝³ : Category.{v₂, u₂} C
D : Type u₃
inst✝² : Category.{v₃, u₃} D
E : Type u₄
inst✝¹ : Category.{v₄, u₄} E
H : Type u₅
inst✝ : Category.{v₅, u₅} H
F : C × D ⥤ E
fst✝² : C
snd✝² : D
fst✝¹ : C
snd✝¹ : D
fst✝ : (fst✝², snd✝²).1 ⟶ (fst✝¹, snd✝¹).1
snd✝ : (fst✝², snd✝²).2 ⟶ (fst✝¹, snd✝¹).2
⊢ F.map ((fst✝, 𝟙 snd✝²) ≫ (𝟙 fst✝¹, snd✝)) ≫ 𝟙 (F.obj (fst✝¹, snd✝¹)) = 𝟙 (F.obj (fst✝², snd✝²)) ≫ F.map (fst✝, snd✝)
state_after: no goals
tactic: simp