l3lab/ntp-mathlib huggingface dataset:
/-- The exponential comparison map is natural in `A`. -/
theorem expComparison_whiskerLeft {A A' : C} (f : A' ⟶ A) :
    expComparison F A ≫ whiskerLeft _ (pre (F.map f)) =
      whiskerRight (pre f) _ ≫ expComparison F A' := by
  ext B
  

Proof state:
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
A A' : C
f : A' ⟶ A
B : C
⊢ (expComparison F A ≫ whiskerLeft F (pre (F.map f))).app B = (whiskerRight (pre f) F ≫ expComparison F A').app B

Next tactic:
dsimp
/-- The exponential comparison map is natural in `A`. -/
theorem expComparison_whiskerLeft {A A' : C} (f : A' ⟶ A) :
    expComparison F A ≫ whiskerLeft _ (pre (F.map f)) =
      whiskerRight (pre f) _ ≫ expComparison F A' := by
  ext B
  dsimp
  

Proof state:
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
A A' : C
f : A' ⟶ A
B : C
⊢ (expComparison F A).app B ≫ (pre (F.map f)).app (F.obj B) = F.map ((pre f).app B) ≫ (expComparison F A').app B

Next tactic:
apply uncurry_injective
/-- The exponential comparison map is natural in `A`. -/
theorem expComparison_whiskerLeft {A A' : C} (f : A' ⟶ A) :
    expComparison F A ≫ whiskerLeft _ (pre (F.map f)) =
      whiskerRight (pre f) _ ≫ expComparison F A' := by
  ext B
  dsimp
  apply uncurry_injective
  

Proof state:
case w.h.a
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
B : C
⊢ CartesianClosed.uncurry ((expComparison F A).app B ≫ (pre (F.map f)).app (F.obj B)) =
    CartesianClosed.uncurry (F.map ((pre f).app B) ≫ (expComparison F A').app B)

Next tactic:
rw [uncurry_natural_left, uncurry_natural_left, uncurry_expComparison, uncurry_pre,
    prod.map_swap_assoc, ← F.map_id, expComparison_ev, ← F.map_id, ←
    prodComparison_inv_natural_assoc, ← prodComparison_inv_natural_assoc, ← F.map_comp, ←
    F.map_comp, prod_map_pre_app_comp_ev]
theorem frobeniusMorphism_mate (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 := by
  

Proof state:
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 (Adjunction.comp h (exp.adjunction A)) (Adjunction.comp (exp.adjunction (F.obj A)) h))
      (frobeniusMorphism F h A) =
    expComparison F A

Next tactic:
rw [← Equiv.eq_symm_apply]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  

Proof state:
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 (Adjunction.comp h (exp.adjunction A)) (Adjunction.comp (exp.adjunction (F.obj A)) h)).symm
      (expComparison F A)

Next tactic:
ext B : 2
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  

Proof state:
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 (Adjunction.comp h (exp.adjunction A)) (Adjunction.comp (exp.adjunction (F.obj A)) h)).symm
          (expComparison F A)).app
      B

Next tactic:
dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  

Proof state:
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 ((exp.adjunction A).unit.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 ((exp.adjunction (F.obj A)).counit.app (F.obj (A ⨯ L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)) ≫
        𝟙 (A ⨯ L.obj B)

Next tactic:
simp only [id_comp, comp_id]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  

Proof state:
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 ((exp.adjunction A).unit.app (L.obj B))) ≫ (expComparison F A).app (A ⨯ L.obj B))) ≫
      L.map ((exp.adjunction (F.obj A)).counit.app (F.obj (A ⨯ L.obj B))) ≫ h.counit.app (A ⨯ L.obj B)

Next tactic:
rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  

Proof state:
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 ((exp.adjunction A).unit.app (L.obj B))) ≫
          prod.map (𝟙 (F.obj A)) ((expComparison F A).app (A ⨯ L.obj B)) ≫
            (exp.adjunction (F.obj A)).counit.app (F.obj (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)

Next tactic:
erw [expComparison_ev]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  

Proof state:
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 ((exp.adjunction A).unit.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)

Next tactic:
rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  

Proof state:
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) ((exp.adjunction A).unit.app (L.obj B)) ≫ (exp.ev A).app (A ⨯ L.obj B))) ≫
      h.counit.app (A ⨯ L.obj B)

Next tactic:
erw [exp.ev_coev]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [exp.ev_coev]
  

Proof state:
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)

Next tactic:
rw [F.map_id (A ⨯ L.obj B), comp_id]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [exp.ev_coev]
  rw [F.map_id (A ⨯ L.obj B), comp_id]
  

Proof state:
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)

Next tactic:
ext
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [exp.ev_coev]
  rw [F.map_id (A ⨯ L.obj B), comp_id]
  ext
  · 

Proof state:
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

Next tactic:
rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_fst]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [exp.ev_coev]
  rw [F.map_id (A ⨯ L.obj B), comp_id]
  ext
  · rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_fst]
    

Proof state:
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

Next tactic:
simp
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [exp.ev_coev]
  rw [F.map_id (A ⨯ L.obj B), comp_id]
  ext
  · rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_fst]
    simp
  · 

Proof state:
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

Next tactic:
rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_snd]
theorem frobeniusMorphism_mate (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 := by
  rw [← Equiv.eq_symm_apply]
  ext B : 2
  dsimp [frobeniusMorphism, transferNatTransSelf, transferNatTrans, Adjunction.comp]
  simp only [id_comp, comp_id]
  rw [← L.map_comp_assoc, prod.map_id_comp, assoc]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [expComparison_ev]
  rw [prod.map_id_comp, assoc, ← F.map_id, ← prodComparison_inv_natural_assoc, ← F.map_comp]
  -- Porting note: need to use `erw` here.
  -- https://github.com/leanprover-community/mathlib4/issues/5164
  erw [exp.ev_coev]
  rw [F.map_id (A ⨯ L.obj B), comp_id]
  ext
  · rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_fst]
    simp
  · rw [assoc, assoc, ← h.counit_naturality, ← L.map_comp_assoc, assoc, inv_prodComparison_map_snd]
    

Proof state:
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)

Next tactic:
simp
/--
If the exponential comparison transformation (at `A`) is an isomorphism, then the Frobenius morphism
at `A` is an isomorphism.
-/
theorem frobeniusMorphism_iso_of_expComparison_iso (h : L ⊣ F) (A : C)
    [i : IsIso (expComparison F A)] : IsIso (frobeniusMorphism F h A) := by
  

Proof state:
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
i : IsIso (expComparison F A)
⊢ IsIso (frobeniusMorphism F h A)

Next tactic:
rw [← frobeniusMorphism_mate F h] at i
/--
If the exponential comparison transformation (at `A`) is an isomorphism, then the Frobenius morphism
at `A` is an isomorphism.
-/
theorem frobeniusMorphism_iso_of_expComparison_iso (h : L ⊣ F) (A : C)
    [i : IsIso (expComparison F A)] : IsIso (frobeniusMorphism F h A) := by
  rw [← frobeniusMorphism_mate F h] at i
  

Proof state:
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
i :
  IsIso
    ((transferNatTransSelf (Adjunction.comp h (exp.adjunction A)) (Adjunction.comp (exp.adjunction (F.obj A)) h))
      (frobeniusMorphism F h A))
⊢ IsIso (frobeniusMorphism F h A)

Next tactic:
exact @transferNatTransSelf_of_iso _ _ _ _ _ _ _ _ _ _ _ i
/--
If the Frobenius morphism at `A` is an isomorphism, then the exponential comparison transformation
(at `A`) is an isomorphism.
-/
theorem expComparison_iso_of_frobeniusMorphism_iso (h : L ⊣ F) (A : C)
    [i : IsIso (frobeniusMorphism F h A)] : IsIso (expComparison F A) := by
  

Proof state:
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
i : IsIso (frobeniusMorphism F h A)
⊢ IsIso (expComparison F A)

Next tactic:
rw [← frobeniusMorphism_mate F h]
/--
If the Frobenius morphism at `A` is an isomorphism, then the exponential comparison transformation
(at `A`) is an isomorphism.
-/
theorem expComparison_iso_of_frobeniusMorphism_iso (h : L ⊣ F) (A : C)
    [i : IsIso (frobeniusMorphism F h A)] : IsIso (expComparison F A) := by
  rw [← frobeniusMorphism_mate F h]; 

Proof state:
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
i : IsIso (frobeniusMorphism F h A)
⊢ IsIso
    ((transferNatTransSelf (Adjunction.comp h (exp.adjunction A)) (Adjunction.comp (exp.adjunction (F.obj A)) h))
      (frobeniusMorphism F h A))

Next tactic:
infer_instance
instance : FunLike (MultilinearMap R M₁ M₂) (∀ i, M₁ i) (fun _ ↦ M₂) where
  coe f := f.toFun
  coe_injective' := fun f g h ↦ by 

Proof state:
R : Type uR
S : Type uS
ι : Type uι
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁰ : Semiring R
inst✝⁹ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝⁸ : (i : ι) → AddCommMonoid (M₁ i)
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : AddCommMonoid M₃
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝³ : (i : ι) → Module R (M₁ i)
inst✝² : Module R M₂
inst✝¹ : Module R M₃
inst✝ : Module R M'
f✝ f' f g : MultilinearMap R M₁ M₂
h : (fun f => f.toFun) f = (fun f => f.toFun) g
⊢ f = g

Next tactic:
cases f