Theorem: CategoryTheory.frobeniusMorphism_mate
File: Mathlib/CategoryTheory/Closed/Functor.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
⊢ (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h)) (frobeniusMorphism F h A) =
    expComparison F A
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
⊢ (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A))) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv
tactic: unfold expComparison frobeniusMorphism
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
⊢ (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A))) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
⊢ (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A))) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv
tactic: have conjeq := iterated_mateEquiv_conjugateEquiv h h
    (exp.adjunction (F.obj A)) (exp.adjunction A)
    (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
⊢ (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A))) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv
state_after: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv
tactic: rw [← conjeq]
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv
state_after: case h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
⊢ (mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A))) =
    (prodComparisonNatIso F A).inv
tactic: apply congr_arg
state_before: case h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
⊢ (mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A))) =
    (prodComparisonNatIso F A).inv
state_after: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))).app B =
    (prodComparisonNatIso F A).inv.app B
tactic: ext B
state_before: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))).app B =
    (prodComparisonNatIso F A).inv.app B
state_after: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ ({
            toFun := fun α =>
              whiskerLeft (F ⋙ prod.functor.obj (F.obj A)) h.unit ≫
                whiskerRight (whiskerLeft F α) F ≫ whiskerRight h.counit (prod.functor.obj A ⋙ F),
            invFun := fun β =>
              whiskerRight h.unit (prod.functor.obj (F.obj A) ⋙ L) ≫
                whiskerRight (whiskerLeft L β) L ≫ whiskerLeft (L ⋙ prod.functor.obj A) h.counit,
            left_inv := ⋯, right_inv := ⋯ }
          (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))).app
      B =
    (prodComparisonNatIso F A).inv.app B
tactic: unfold mateEquiv
state_before: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ ({
            toFun := fun α =>
              whiskerLeft (F ⋙ prod.functor.obj (F.obj A)) h.unit ≫
                whiskerRight (whiskerLeft F α) F ≫ whiskerRight h.counit (prod.functor.obj A ⋙ F),
            invFun := fun β =>
              whiskerRight h.unit (prod.functor.obj (F.obj A) ⋙ L) ≫
                whiskerRight (whiskerLeft L β) L ≫ whiskerLeft (L ⋙ prod.functor.obj A) h.counit,
            left_inv := ⋯, right_inv := ⋯ }
          (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))).app
      B =
    (prodComparisonNatIso F A).inv.app B
state_after: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map (prodComparison L (F.obj A) (F.obj B)) ≫
        F.map (prod.map (h.counit.app A) (𝟙 (L.obj (F.obj B)))) ≫ F.map (prod.map (𝟙 A) (h.counit.app B)) =
    inv (prodComparison F A B)
tactic: simp only [Functor.comp_obj, prod.functor_obj_obj, Functor.id_obj, Equiv.coe_fn_mk,
    whiskerLeft_comp, whiskerLeft_twice, whiskerRight_comp, assoc, NatTrans.comp_app,
    whiskerLeft_app, whiskerRight_app, prodComparisonNatTrans_app, prod.functor_map_app,
    Functor.comp_map, prod.functor_obj_map, prodComparisonNatIso_inv, asIso_inv,
    NatIso.isIso_inv_app]
state_before: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map (prodComparison L (F.obj A) (F.obj B)) ≫
        F.map (prod.map (h.counit.app A) (𝟙 (L.obj (F.obj B)))) ≫ F.map (prod.map (𝟙 A) (h.counit.app B)) =
    inv (prodComparison F A B)
state_after: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map
        (prodComparison L (F.obj A) (F.obj B) ≫
          prod.map (h.counit.app A) (𝟙 (L.obj (F.obj B))) ≫ prod.map (𝟙 A) (h.counit.app B)) =
    inv (prodComparison F A B)
tactic: rw [← F.map_comp, ← F.map_comp]
state_before: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map
        (prodComparison L (F.obj A) (F.obj B) ≫
          prod.map (h.counit.app A) (𝟙 (L.obj (F.obj B))) ≫ prod.map (𝟙 A) (h.counit.app B)) =
    inv (prodComparison F A B)
state_after: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map (prodComparison L (F.obj A) (F.obj B) ≫ prod.map (h.counit.app A) (h.counit.app B)) =
    inv (prodComparison F A B)
tactic: simp only [prod.map_map, comp_id, id_comp]
state_before: case h.w.h
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map (prodComparison L (F.obj A) (F.obj B) ≫ prod.map (h.counit.app A) (h.counit.app B)) =
    inv (prodComparison F A B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫
        F.map (prodComparison L (F.obj A) (F.obj B) ≫ prod.map (h.counit.app A) (h.counit.app B))) ≫
      prodComparison F A B =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: apply IsIso.eq_inv_of_inv_hom_id
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫
        F.map (prodComparison L (F.obj A) (F.obj B) ≫ prod.map (h.counit.app A) (h.counit.app B))) ≫
      prodComparison F A B =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map (prodComparison L (F.obj A) (F.obj B)) ≫
        prodComparison F (L.obj (F.obj A)) (L.obj (F.obj B)) ≫
          prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: rw [F.map_comp, assoc, assoc, prodComparison_natural]
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      F.map (prodComparison L (F.obj A) (F.obj B)) ≫
        prodComparison F (L.obj (F.obj A)) (L.obj (F.obj B)) ≫
          prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      prodComparison (L ⋙ F) (F.obj A) (F.obj B) ≫ prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: slice_lhs 2 3 =>
    {
      rw [← prodComparison_comp]
    }
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ h.unit.app (F.obj A ⨯ F.obj B) ≫
      prodComparison (L ⋙ F) (F.obj A) (F.obj B) ≫ prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫ prodComparison (L ⋙ F) (F.obj A) (F.obj B)) ≫
      prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: rw [← assoc]
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫ prodComparison (L ⋙ F) (F.obj A) (F.obj B)) ≫
      prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd)) ≫
      prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: unfold prodComparison
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd)) ≫
      prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
ηlemma :
  h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd) =
    prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B))
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd)) ≫
      prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: have ηlemma : (h.unit.app (F.obj A ⨯ F.obj B) ≫
    prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd)) =
    prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B)) := by
    ext <;> simp
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
ηlemma :
  h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd) =
    prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B))
⊢ (h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd)) ≫
      prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
ηlemma :
  h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd) =
    prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B))
⊢ prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B)) ≫ prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
tactic: rw [ηlemma]
state_before: case h.w.h.inv_hom_id
C : Type u
inst✝⁶ : Category.{v, u} C
D : Type u'
inst✝⁵ : Category.{v, u'} D
inst✝⁴ : HasFiniteProducts C
inst✝³ : HasFiniteProducts D
F : C ⥤ D
L : D ⥤ C
inst✝² : CartesianClosed C
inst✝¹ : CartesianClosed D
inst✝ : PreservesLimitsOfShape (Discrete WalkingPair) F
h : L ⊣ F
A : C
conjeq :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A)))
      ((mateEquiv h h) (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))) =
    (conjugateEquiv (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h))
      (prodComparisonNatTrans L (F.obj A) ≫ whiskerLeft L (prod.functor.map (h.counit.app A)))
B : C
ηlemma :
  h.unit.app (F.obj A ⨯ F.obj B) ≫ prod.lift ((L ⋙ F).map prod.fst) ((L ⋙ F).map prod.snd) =
    prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B))
⊢ prod.map (h.unit.app (F.obj A)) (h.unit.app (F.obj B)) ≫ prod.map (F.map (h.counit.app A)) (F.map (h.counit.app B)) =
    𝟙 (F.obj A ⨯ F.obj B)
state_after: no goals
tactic: simp only [Functor.id_obj, Functor.comp_obj, prod.map_map, Adjunction.right_triangle_components,
    prod.map_id_id]