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

tactic: rw [← Equiv.eq_symm_apply]
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
⊢ (transferNatTransSelf (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
⊢ frobeniusMorphism F h A =
    (transferNatTransSelf (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h)).symm (expComparison F A)

tactic: ext B : 2
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
⊢ frobeniusMorphism F h A =
    (transferNatTransSelf (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h)).symm (expComparison F A)
state_after: case 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
B : D
⊢ (frobeniusMorphism F h A).app B =
    ((transferNatTransSelf (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h)).symm
          (expComparison F A)).app
      B

tactic: dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
state_before: case 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
B : D
⊢ (frobeniusMorphism F h A).app B =
    ((transferNatTransSelf (h.comp (exp.adjunction A)) ((exp.adjunction (F.obj A)).comp h)).symm
          (expComparison F A)).app
      B
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    𝟙 (L.obj (F.obj A ⨯ B)) ≫
      (L.map
            (prod.map (𝟙 (F.obj A))
              ((h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B)) ≫ 𝟙 (F.obj (A ⟹ A ⨯ L.obj B))) ≫
                𝟙 (F.obj (A ⟹ A ⨯ L.obj B)) ≫
                  (expComparison F A).app (A ⨯ L.obj B) ≫ 𝟙 (F.obj A ⟹ F.obj (A ⨯ L.obj B)))) ≫
          𝟙 (L.obj (F.obj A ⨯ F.obj A ⟹ F.obj (A ⨯ L.obj B))) ≫
            L.map ((ihom.ev (F.obj A)).app (F.obj (A ⨯ L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
        𝟙 (A ⨯ L.obj B)

tactic: simp only [id_comp, comp_id]
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    𝟙 (L.obj (F.obj A ⨯ B)) ≫
      (L.map
            (prod.map (𝟙 (F.obj A))
              ((h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B)) ≫ 𝟙 (F.obj (A ⟹ A ⨯ L.obj B))) ≫
                𝟙 (F.obj (A ⟹ A ⨯ L.obj B)) ≫
                  (expComparison F A).app (A ⨯ L.obj B) ≫ 𝟙 (F.obj A ⟹ F.obj (A ⨯ L.obj B)))) ≫
          𝟙 (L.obj (F.obj A ⨯ F.obj A ⟹ F.obj (A ⨯ L.obj B))) ≫
            L.map ((ihom.ev (F.obj A)).app (F.obj (A ⨯ L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
        𝟙 (A ⨯ L.obj B)
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (𝟙 (F.obj A))
          ((h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B))) ≫ (expComparison F A).app (A ⨯ L.obj B))) ≫
      L.map ((ihom.ev (F.obj A)).app (F.obj (A ⨯ L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)

tactic: rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (𝟙 (F.obj A))
          ((h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B))) ≫ (expComparison F A).app (A ⨯ L.obj B))) ≫
      L.map ((ihom.ev (F.obj A)).app (F.obj (A ⨯ L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (𝟙 (F.obj A)) (h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B))) ≫
          prod.map (𝟙 (F.obj A)) ((expComparison F A).app (A ⨯ L.obj B)) ≫
            (ihom.ev (F.obj A)).app (F.obj (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)

tactic: erw [expComparison_ev]
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (𝟙 (F.obj A)) (h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B))) ≫
          prod.map (𝟙 (F.obj A)) ((expComparison F A).app (A ⨯ L.obj B)) ≫
            (ihom.ev (F.obj A)).app (F.obj (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (𝟙 (F.obj A)) (h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B))) ≫
          inv (prodComparison F A (A ⟹ A ⨯ L.obj B)) ≫ F.map ((exp.ev A).app (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)

tactic: rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (𝟙 (F.obj A)) (h.unit.app B ≫ F.map ((ihom.coev A).app (L.obj B))) ≫
          inv (prodComparison F A (A ⟹ A ⨯ L.obj B)) ≫ F.map ((exp.ev A).app (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫
          inv (prodComparison F A (L.obj B)) ≫
            F.map (prod.map (𝟙 A) ((ihom.coev A).app (L.obj B)) ≫ (exp.ev A).app (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)

tactic: erw [exp.ev_coev]
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map
        (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫
          inv (prodComparison F A (L.obj B)) ≫
            F.map (prod.map (𝟙 A) ((ihom.coev A).app (L.obj B)) ≫ (exp.ev A).app (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B)) ≫ F.map (𝟙 (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)

tactic: rw [F.map_id (A ⨯ L.obj B), comp_id]
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B)) ≫ F.map (𝟙 (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)
state_after: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)

tactic: ext
state_before: case 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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)
state_after: case w.h.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
B : D
⊢ (prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B))) ≫ prod.fst =
    (L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
      prod.fst

case w.h.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
B : D
⊢ (prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B))) ≫ prod.snd =
    (L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
      prod.snd

tactic: rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_fst]
state_before: case w.h.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
B : D
⊢ (prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B))) ≫ prod.fst =
    (L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
      prod.fst
state_after: case w.h.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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) ≫ prod.fst =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ prod.fst) ≫ h.counit.app A

tactic: simp
state_before: case w.h.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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) ≫ prod.fst =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ prod.fst) ≫ h.counit.app A
state_after: no goals

tactic: rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_snd]
state_before: case w.h.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
B : D
⊢ (prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B))) ≫ prod.snd =
    (L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ inv (prodComparison F A (L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
      prod.snd
state_after: case w.h.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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) ≫ prod.snd =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ prod.snd) ≫ h.counit.app (L.obj B)

tactic: simp
state_before: case w.h.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
B : D
⊢ prodComparison L (F.obj A) B ≫ prod.map (h.counit.app A) (𝟙 (L.obj B)) ≫ prod.snd =
    L.map (prod.map (F.map (𝟙 A)) (h.unit.app B) ≫ prod.snd) ≫ h.counit.app (L.obj B)
state_after: no goals