Theorem: CategoryTheory.expComparison_whiskerLeft
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
A A' : C
f : A' ⟶ A
⊢ expComparison F A ≫ whiskerLeft F (pre (F.map f)) = whiskerRight (pre f) F ≫ 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
A A' : C
f : A' ⟶ A
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
tactic: unfold expComparison pre
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
A A' : C
f : A' ⟶ A
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointSquareConjugate.vcomp (prodComparisonNatIso F A).inv (prod.functor.map (F.map f))) =
    rightAdjointSquareConjugate.vcomp
      ((mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv)
      ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
tactic: have vcomp1 := mateEquiv_conjugateEquiv_vcomp
    (exp.adjunction A) (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))
    ((prodComparisonNatIso F A).inv) ((prod.functor.map (F.map f)))
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointSquareConjugate.vcomp (prodComparisonNatIso F A).inv (prod.functor.map (F.map f))) =
    rightAdjointSquareConjugate.vcomp
      ((mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv)
      ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointSquareConjugate.vcomp (prodComparisonNatIso F A).inv (prod.functor.map (F.map f))) =
    rightAdjointSquareConjugate.vcomp
      ((mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv)
      ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointConjugateSquare.vcomp (prod.functor.map f) (prodComparisonNatIso F A').inv) =
    rightAdjointConjugateSquare.vcomp ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f))
      ((mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv)
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
tactic: have vcomp2 := conjugateEquiv_mateEquiv_vcomp
    (exp.adjunction A) (exp.adjunction A') (exp.adjunction (F.obj A'))
    ((prod.functor.map f)) ((prodComparisonNatIso F A').inv)
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointSquareConjugate.vcomp (prodComparisonNatIso F A).inv (prod.functor.map (F.map f))) =
    rightAdjointSquareConjugate.vcomp
      ((mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv)
      ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointConjugateSquare.vcomp (prod.functor.map f) (prodComparisonNatIso F A').inv) =
    rightAdjointConjugateSquare.vcomp ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f))
      ((mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv)
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointConjugateSquare.vcomp (prod.functor.map f) (prodComparisonNatIso F A').inv) =
    rightAdjointConjugateSquare.vcomp ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f))
      ((mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv)
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
tactic: unfold leftAdjointSquareConjugate.vcomp rightAdjointSquareConjugate.vcomp at vcomp1
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (leftAdjointConjugateSquare.vcomp (prod.functor.map f) (prodComparisonNatIso F A').inv) =
    rightAdjointConjugateSquare.vcomp ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f))
      ((mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv)
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
tactic: unfold leftAdjointConjugateSquare.vcomp rightAdjointConjugateSquare.vcomp at vcomp2
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f))) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F)
tactic: rw [← vcomp1, ← vcomp2]
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
⊢ (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F)
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
⊢ whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv =
    (prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
⊢ whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv =
    (prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
B : C
⊢ (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv).app B =
    ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F).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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
B : C
⊢ (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv).app B =
    ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F).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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
B : C
⊢ prod.map (F.map f) (𝟙 (F.obj B)) ≫ inv (prodComparison F A B) = inv (prodComparison F A' B) ≫ F.map (prod.map f (𝟙 B))
tactic: simp only [Functor.comp_obj, prod.functor_obj_obj, prodComparisonNatIso_inv, asIso_inv,
    NatTrans.comp_app, whiskerLeft_app, prod.functor_map_app, NatIso.isIso_inv_app,
    whiskerRight_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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
B : C
⊢ prod.map (F.map f) (𝟙 (F.obj B)) ≫ inv (prodComparison F A B) = inv (prodComparison F A' B) ≫ F.map (prod.map f (𝟙 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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
B : C
⊢ prod.map (F.map f) (F.map (𝟙 B)) ≫ inv (prodComparison F A B) = inv (prodComparison F A' B) ≫ F.map (prod.map f (𝟙 B))
tactic: rw [← F.map_id]
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
A A' : C
f : A' ⟶ A
vcomp1 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      (whiskerLeft F (prod.functor.map (F.map f)) ≫ (prodComparisonNatIso F A).inv) =
    (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A))) (prodComparisonNatIso F A).inv ≫
      whiskerLeft F
        ((conjugateEquiv (exp.adjunction (F.obj A)) (exp.adjunction (F.obj A'))) (prod.functor.map (F.map f)))
vcomp2 :
  (mateEquiv (exp.adjunction A) (exp.adjunction (F.obj A')))
      ((prodComparisonNatIso F A').inv ≫ whiskerRight (prod.functor.map f) F) =
    whiskerRight ((conjugateEquiv (exp.adjunction A) (exp.adjunction A')) (prod.functor.map f)) F ≫
      (mateEquiv (exp.adjunction A') (exp.adjunction (F.obj A'))) (prodComparisonNatIso F A').inv
B : C
⊢ prod.map (F.map f) (F.map (𝟙 B)) ≫ inv (prodComparison F A B) = inv (prodComparison F A' B) ≫ F.map (prod.map f (𝟙 B))
state_after: no goals
tactic: exact (prodComparison_inv_natural F f (𝟙 B)).symm