ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- isSolvable_of_isScalarTower
theorem isSolvable_of_isScalarTower [Normal F K₁] [h1 : IsSolvable (K₁ ≃ₐ[F] K₁)]
    [h2 : IsSolvable (E ≃ₐ[K₁] E)] : IsSolvable (E ≃ₐ[F] E) 
Arguments: (F : Type u_1) (K₁ : Type u_3) [Field F] [Field K₁] [Algebra F K₁] (E : Type u_6) [Field E] [Algebra F E] [Algebra K₁ E] [IsScalarTower F K₁ E] [Normal F K₁] [h1 : IsSolvable (K₁ ≃ₐ[F] K₁)] [h2 : IsSolvable (E ≃ₐ[K₁] E)]
Goal: IsSolvable (E ≃ₐ[F] E)
-- minpoly.exists_algEquiv_of_root
theorem exists_algEquiv_of_root [Normal K L] {x y : L} (hy : IsAlgebraic K y)
    (h_ev : (Polynomial.aeval x) (minpoly K y) = 0) : ∃ σ : L ≃ₐ[K] L, σ x = y 
Arguments: {K : Type u_6} {L : Type u_7} [Field K] [Field L] [Algebra K L] [Normal K L] {x y : L} (hy : IsAlgebraic K y) (h_ev : (Polynomial.aeval x) (minpoly K y) = 0)
Goal: ∃ σ, σ x = y
-- minpoly.exists_algEquiv_of_root'
theorem exists_algEquiv_of_root' [Normal K L]{x y : L} (hy : IsAlgebraic K y)
    (h_ev : (Polynomial.aeval x) (minpoly K y) = 0) : ∃ σ : L ≃ₐ[K] L, σ y = x 
Arguments: {K : Type u_6} {L : Type u_7} [Field K] [Field L] [Algebra K L] [Normal K L] {x y : L} (hy : IsAlgebraic K y) (h_ev : (Polynomial.aeval x) (minpoly K y) = 0)
Goal: ∃ σ, σ y = x
-- IntermediateField.Lifts.exists_upper_bound
theorem Lifts.exists_upper_bound (c : Set (Lifts F E K)) (hc : IsChain (· ≤ ·) c) :
    ∃ ub, ∀ a ∈ c, a ≤ ub 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] (c : Set (IntermediateField.Lifts F E K)) (hc : IsChain (fun x x_1 => x ≤ x_1) c)
Goal: ∃ ub, ∀ a ∈ c, a ≤ ub
-- IntermediateField.Lifts.exists_lift_of_splits'
theorem Lifts.exists_lift_of_splits' (x : Lifts F E K) {s : E} (h1 : IsIntegral x.carrier s)
    (h2 : (minpoly x.carrier s).Splits x.emb.toRingHom) : ∃ y, x ≤ y ∧ s ∈ y.carrier 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] (x : IntermediateField.Lifts F E K) {s : E} (h1 : IsIntegral (↥x.carrier) s) (h2 : Polynomial.Splits x.emb.toRingHom (minpoly (↥x.carrier) s))
Goal: ∃ y, x ≤ y ∧ s ∈ y.carrier
-- IntermediateField.Lifts.exists_lift_of_splits
theorem Lifts.exists_lift_of_splits (x : Lifts F E K) {s : E} (h1 : IsIntegral F s)
    (h2 : (minpoly F s).Splits (algebraMap F K)) : ∃ y, x ≤ y ∧ s ∈ y.carrier 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] (x : IntermediateField.Lifts F E K) {s : E} (h1 : IsIntegral F s) (h2 : Polynomial.Splits (algebraMap F K) (minpoly F s))
Goal: ∃ y, x ≤ y ∧ s ∈ y.carrier
-- _private.Mathlib.FieldTheory.Extension.0.IntermediateField.exists_algHom_adjoin_of_splits''
private theorem exists_algHom_adjoin_of_splits'' {L : IntermediateField F E}
    (f : L →ₐ[F] K) (hK : ∀ s ∈ S, IsIntegral L s ∧ (minpoly L s).Splits f.toRingHom) :
    ∃ φ : adjoin L S →ₐ[F] K, φ.comp (IsScalarTower.toAlgHom F L _) = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} {L : IntermediateField F E} (f : ↥L →ₐ[F] K) (hK : ∀ s ∈ S, IsIntegral (↥L) s ∧ Polynomial.Splits f.toRingHom (minpoly (↥L) s))
Goal: ∃ φ, φ.comp (IsScalarTower.toAlgHom F ↥L ↥(IntermediateField.adjoin (↥L) S)) = f
-- IntermediateField.exists_algHom_adjoin_of_splits'
theorem exists_algHom_adjoin_of_splits' :
    ∃ φ : adjoin L S →ₐ[F] K, φ.comp (IsScalarTower.toAlgHom F L _) = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} {L : Type u_4} [Field L] [Algebra F L] [Algebra L E] [IsScalarTower F L E] (f : L →ₐ[F] K) (hK : ∀ s ∈ S, IsIntegral L s ∧ Polynomial.Splits f.toRingHom (minpoly L s))
Goal: ∃ φ, φ.comp (IsScalarTower.toAlgHom F L ↥(IntermediateField.adjoin L S)) = f
-- IntermediateField.exists_algHom_of_adjoin_splits'
theorem exists_algHom_of_adjoin_splits' (hS : adjoin L S = ⊤) :
    ∃ φ : E →ₐ[F] K, φ.comp (IsScalarTower.toAlgHom F L E) = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} {L : Type u_4} [Field L] [Algebra F L] [Algebra L E] [IsScalarTower F L E] (f : L →ₐ[F] K) (hK : ∀ s ∈ S, IsIntegral L s ∧ Polynomial.Splits f.toRingHom (minpoly L s)) (hS : IntermediateField.adjoin L S = ⊤)
Goal: ∃ φ, φ.comp (IsScalarTower.toAlgHom F L E) = f
-- IntermediateField.exists_algHom_of_splits'
theorem exists_algHom_of_splits' (hK : ∀ s : E, IsIntegral L s ∧ (minpoly L s).Splits f.toRingHom) :
    ∃ φ : E →ₐ[F] K, φ.comp (IsScalarTower.toAlgHom F L E) = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {L : Type u_4} [Field L] [Algebra F L] [Algebra L E] [IsScalarTower F L E] (f : L →ₐ[F] K) (hK : ∀ (s : E), IsIntegral L s ∧ Polynomial.Splits f.toRingHom (minpoly L s))
Goal: ∃ φ, φ.comp (IsScalarTower.toAlgHom F L E) = f
-- IntermediateField.exists_algHom_adjoin_of_splits
theorem exists_algHom_adjoin_of_splits : ∃ φ : adjoin F S →ₐ[F] K, φ.comp (inclusion hL) = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} (hK : ∀ s ∈ S, IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) {L : IntermediateField F E} (f : ↥L →ₐ[F] K) (hL : L ≤ IntermediateField.adjoin F S)
Goal: ∃ φ, φ.comp (IntermediateField.inclusion hL) = f
-- IntermediateField.nonempty_algHom_adjoin_of_splits
theorem nonempty_algHom_adjoin_of_splits : Nonempty (adjoin F S →ₐ[F] K) 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} (hK : ∀ s ∈ S, IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s))
Goal: Nonempty (↥(IntermediateField.adjoin F S) →ₐ[F] K)
-- IntermediateField.exists_algHom_of_adjoin_splits
theorem exists_algHom_of_adjoin_splits : ∃ φ : E →ₐ[F] K, φ.comp L.val = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} (hK : ∀ s ∈ S, IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) {L : IntermediateField F E} (f : ↥L →ₐ[F] K) (hS : IntermediateField.adjoin F S = ⊤)
Goal: ∃ φ, φ.comp L.val = f
-- IntermediateField.nonempty_algHom_of_adjoin_splits
theorem nonempty_algHom_of_adjoin_splits : Nonempty (E →ₐ[F] K) 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} (hK : ∀ s ∈ S, IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) (hS : IntermediateField.adjoin F S = ⊤)
Goal: Nonempty (E →ₐ[F] K)
-- IntermediateField.exists_algHom_adjoin_of_splits_of_aeval
theorem exists_algHom_adjoin_of_splits_of_aeval : ∃ φ : adjoin F S →ₐ[F] K, φ ⟨x, hx⟩ = y 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} (hK : ∀ s ∈ S, IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) {x : E} (hx : x ∈ IntermediateField.adjoin F S) {y : K} (hy : (Polynomial.aeval y) (minpoly F x) = 0)
Goal: ∃ φ, φ ⟨x, hx⟩ = y
-- IntermediateField.exists_algHom_of_adjoin_splits_of_aeval
theorem exists_algHom_of_adjoin_splits_of_aeval : ∃ φ : E →ₐ[F] K, φ x = y 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] {S : Set E} (hK : ∀ s ∈ S, IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) (hS : IntermediateField.adjoin F S = ⊤) {x : E} {y : K} (hy : (Polynomial.aeval y) (minpoly F x) = 0)
Goal: ∃ φ, φ x = y
-- IntermediateField.exists_algHom_of_splits
theorem exists_algHom_of_splits : ∃ φ : E →ₐ[F] K, φ.comp L.val = f 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] (hK' : ∀ (s : E), IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) {L : IntermediateField F E} (f : ↥L →ₐ[F] K)
Goal: ∃ φ, φ.comp L.val = f
-- IntermediateField.nonempty_algHom_of_splits
theorem nonempty_algHom_of_splits : Nonempty (E →ₐ[F] K) 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] (hK' : ∀ (s : E), IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s))
Goal: Nonempty (E →ₐ[F] K)
-- IntermediateField.exists_algHom_of_splits_of_aeval
theorem exists_algHom_of_splits_of_aeval : ∃ φ : E →ₐ[F] K, φ x = y 
Arguments: {F : Type u_1} {E : Type u_2} {K : Type u_3} [Field F] [Field E] [Field K] [Algebra F E] [Algebra F K] (hK' : ∀ (s : E), IsIntegral F s ∧ Polynomial.Splits (algebraMap F K) (minpoly F s)) {x : E} {y : K} (hy : (Polynomial.aeval y) (minpoly F x) = 0)
Goal: ∃ φ, φ x = y
-- Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits
theorem Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits {F K : Type*} (L : Type*)
    [Field F] [Field K] [Field L] [Algebra F L] [Algebra F K]
    (hA : ∀ x : K, (minpoly F x).Splits (algebraMap F L))
    [Algebra.IsAlgebraic F K] (x : K) :
    (Set.range fun (ψ : K →ₐ[F] L) => ψ x) = (minpoly F x).rootSet L 
Arguments: {F : Type u_1} {K : Type u_2} (L : Type u_3) [Field F] [Field K] [Field L] [Algebra F L] [Algebra F K] (hA : ∀ (x : K), Polynomial.Splits (algebraMap F L) (minpoly F x)) [Algebra.IsAlgebraic F K] (x : K)
Goal: (Set.range fun ψ => ψ x) = (minpoly F x).rootSet L
-- CategoryTheory.ihom.ihom_adjunction_counit
@[simp]
theorem ihom_adjunction_counit : (ihom.adjunction A).counit = ev A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A : C) [CategoryTheory.Closed A]
Goal: (CategoryTheory.ihom.adjunction A).counit = CategoryTheory.ihom.ev A
-- CategoryTheory.ihom.ihom_adjunction_unit
@[simp]
theorem ihom_adjunction_unit : (ihom.adjunction A).unit = coev A 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A : C) [CategoryTheory.Closed A]
Goal: (CategoryTheory.ihom.adjunction A).unit = CategoryTheory.ihom.coev A
-- CategoryTheory.ihom.ev_naturality
@[reassoc (attr := simp)]
theorem ev_naturality {X Y : C} (f : X ⟶ Y) :
    A ◁ (ihom A).map f ≫ (ev A).app Y = (ev A).app X ≫ f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A : C) [CategoryTheory.Closed A] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A ((CategoryTheory.ihom A).map f))
    ((CategoryTheory.ihom.ev A).app Y) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.ev A).app X) f
-- CategoryTheory.ihom.coev_naturality
@[reassoc (attr := simp)]
theorem coev_naturality {X Y : C} (f : X ⟶ Y) :
    f ≫ (coev A).app Y = (coev A).app X ≫ (ihom A).map (A ◁ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A : C) [CategoryTheory.Closed A] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp f ((CategoryTheory.ihom.coev A).app Y) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.coev A).app X)
    ((CategoryTheory.ihom A).map (CategoryTheory.MonoidalCategory.whiskerLeft A f))
-- CategoryTheory.ihom.ev_coev
@[reassoc (attr := simp)]
theorem ev_coev : (A ◁ (coev A).app B) ≫ (ev A).app (A ⊗ B) = 𝟙 (A ⊗ B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A B : C) [CategoryTheory.Closed A]
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A ((CategoryTheory.ihom.coev A).app B))
    ((CategoryTheory.ihom.ev A).app (CategoryTheory.MonoidalCategory.tensorObj A B)) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.tensorObj A B)
-- CategoryTheory.ihom.coev_ev
@[reassoc (attr := simp)]
theorem coev_ev : (coev A).app (A ⟶[C] B) ≫ (ihom A).map ((ev A).app B) = 𝟙 (A ⟶[C] B) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A B : C) [CategoryTheory.Closed A]
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.coev A).app ((CategoryTheory.ihom A).obj B))
    ((CategoryTheory.ihom A).map ((CategoryTheory.ihom.ev A).app B)) =
  CategoryTheory.CategoryStruct.id ((CategoryTheory.ihom A).obj B)
-- CategoryTheory.MonoidalClosed.homEquiv_apply_eq
@[simp, nolint simpNF]
theorem homEquiv_apply_eq (f : A ⊗ Y ⟶ X) : (ihom.adjunction A).homEquiv _ _ f = curry f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (f : CategoryTheory.MonoidalCategory.tensorObj A Y ⟶ X)
Goal: ((CategoryTheory.ihom.adjunction A).homEquiv Y X) f = CategoryTheory.MonoidalClosed.curry f
-- CategoryTheory.MonoidalClosed.homEquiv_symm_apply_eq
@[simp, nolint simpNF]
theorem homEquiv_symm_apply_eq (f : Y ⟶ A ⟶[C] X) :
    ((ihom.adjunction A).homEquiv _ _).symm f = uncurry f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (f : Y ⟶ (CategoryTheory.ihom A).obj X)
Goal: ((CategoryTheory.ihom.adjunction A).homEquiv Y X).symm f = CategoryTheory.MonoidalClosed.uncurry f
-- CategoryTheory.MonoidalClosed.curry_natural_left
@[reassoc]
theorem curry_natural_left (f : X ⟶ X') (g : A ⊗ X' ⟶ Y) : curry (_ ◁ f ≫ g) = f ≫ curry g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X X' Y : C} [CategoryTheory.Closed A] (f : X ⟶ X') (g : CategoryTheory.MonoidalCategory.tensorObj A X' ⟶ Y)
Goal: CategoryTheory.MonoidalClosed.curry
    (CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A f) g) =
  CategoryTheory.CategoryStruct.comp f (CategoryTheory.MonoidalClosed.curry g)
-- CategoryTheory.MonoidalClosed.curry_natural_right
@[reassoc]
theorem curry_natural_right (f : A ⊗ X ⟶ Y) (g : Y ⟶ Y') :
    curry (f ≫ g) = curry f ≫ (ihom _).map g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y Y' : C} [CategoryTheory.Closed A] (f : CategoryTheory.MonoidalCategory.tensorObj A X ⟶ Y) (g : Y ⟶ Y')
Goal: CategoryTheory.MonoidalClosed.curry (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.curry f) ((CategoryTheory.ihom A).map g)
-- CategoryTheory.MonoidalClosed.uncurry_natural_right
@[reassoc]
theorem uncurry_natural_right (f : X ⟶ A ⟶[C] Y) (g : Y ⟶ Y') :
    uncurry (f ≫ (ihom _).map g) = uncurry f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y Y' : C} [CategoryTheory.Closed A] (f : X ⟶ (CategoryTheory.ihom A).obj Y) (g : Y ⟶ Y')
Goal: CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.CategoryStruct.comp f ((CategoryTheory.ihom A).map g)) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.uncurry f) g
-- CategoryTheory.MonoidalClosed.uncurry_natural_left
@[reassoc]
theorem uncurry_natural_left (f : X ⟶ X') (g : X' ⟶ A ⟶[C] Y) :
    uncurry (f ≫ g) = _ ◁ f ≫ uncurry g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X X' Y : C} [CategoryTheory.Closed A] (f : X ⟶ X') (g : X' ⟶ (CategoryTheory.ihom A).obj Y)
Goal: CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A f)
    (CategoryTheory.MonoidalClosed.uncurry g)
-- CategoryTheory.MonoidalClosed.uncurry_curry
@[simp]
theorem uncurry_curry (f : A ⊗ X ⟶ Y) : uncurry (curry f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (f : CategoryTheory.MonoidalCategory.tensorObj A X ⟶ Y)
Goal: CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.MonoidalClosed.curry f) = f
-- CategoryTheory.MonoidalClosed.curry_uncurry
@[simp]
theorem curry_uncurry (f : X ⟶ A ⟶[C] Y) : curry (uncurry f) = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (f : X ⟶ (CategoryTheory.ihom A).obj Y)
Goal: CategoryTheory.MonoidalClosed.curry (CategoryTheory.MonoidalClosed.uncurry f) = f
-- CategoryTheory.MonoidalClosed.curry_eq_iff
theorem curry_eq_iff (f : A ⊗ Y ⟶ X) (g : Y ⟶ A ⟶[C] X) : curry f = g ↔ f = uncurry g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (f : CategoryTheory.MonoidalCategory.tensorObj A Y ⟶ X) (g : Y ⟶ (CategoryTheory.ihom A).obj X)
Goal: CategoryTheory.MonoidalClosed.curry f = g ↔ f = CategoryTheory.MonoidalClosed.uncurry g
-- CategoryTheory.MonoidalClosed.eq_curry_iff
theorem eq_curry_iff (f : A ⊗ Y ⟶ X) (g : Y ⟶ A ⟶[C] X) : g = curry f ↔ uncurry g = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (f : CategoryTheory.MonoidalCategory.tensorObj A Y ⟶ X) (g : Y ⟶ (CategoryTheory.ihom A).obj X)
Goal: g = CategoryTheory.MonoidalClosed.curry f ↔ CategoryTheory.MonoidalClosed.uncurry g = f
-- CategoryTheory.MonoidalClosed.uncurry_eq
theorem uncurry_eq (g : Y ⟶ A ⟶[C] X) : uncurry g = (A ◁ g) ≫ (ihom.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (g : Y ⟶ (CategoryTheory.ihom A).obj X)
Goal: CategoryTheory.MonoidalClosed.uncurry g =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerLeft A g)
    ((CategoryTheory.ihom.ev A).app X)
-- CategoryTheory.MonoidalClosed.curry_eq
theorem curry_eq (g : A ⊗ Y ⟶ X) : curry g = (ihom.coev A).app Y ≫ (ihom A).map g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A] (g : CategoryTheory.MonoidalCategory.tensorObj A Y ⟶ X)
Goal: CategoryTheory.MonoidalClosed.curry g =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.coev A).app Y) ((CategoryTheory.ihom A).map g)
-- CategoryTheory.MonoidalClosed.curry_injective
theorem curry_injective : Function.Injective (curry : (A ⊗ Y ⟶ X) → (Y ⟶ A ⟶[C] X)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A]
Goal: Function.Injective CategoryTheory.MonoidalClosed.curry
-- CategoryTheory.MonoidalClosed.uncurry_injective
theorem uncurry_injective : Function.Injective (uncurry : (Y ⟶ A ⟶[C] X) → (A ⊗ Y ⟶ X)) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A X Y : C} [CategoryTheory.Closed A]
Goal: Function.Injective CategoryTheory.MonoidalClosed.uncurry
-- CategoryTheory.MonoidalClosed.uncurry_id_eq_ev
theorem uncurry_id_eq_ev : uncurry (𝟙 (A ⟶[C] X)) = (ihom.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A X : C) [CategoryTheory.Closed A]
Goal: CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.CategoryStruct.id ((CategoryTheory.ihom A).obj X)) =
  (CategoryTheory.ihom.ev A).app X
-- CategoryTheory.MonoidalClosed.curry_id_eq_coev
theorem curry_id_eq_coev : curry (𝟙 _) = (ihom.coev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A X : C) [CategoryTheory.Closed A]
Goal: CategoryTheory.MonoidalClosed.curry
    (CategoryTheory.CategoryStruct.id
      (CategoryTheory.MonoidalCategory.tensorObj A ((CategoryTheory.Functor.id C).obj X))) =
  (CategoryTheory.ihom.coev A).app X
-- CategoryTheory.MonoidalClosed.id_tensor_pre_app_comp_ev
@[reassoc (attr := simp)]
theorem id_tensor_pre_app_comp_ev (f : B ⟶ A) (X : C) :
    B ◁ (pre f).app X ≫ (ihom.ev B).app X = f ▷ (A ⟶[C] X) ≫ (ihom.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A B : C} [CategoryTheory.Closed A] [CategoryTheory.Closed B] (f : B ⟶ A) (X : C)
Goal: CategoryTheory.CategoryStruct.comp
    (CategoryTheory.MonoidalCategory.whiskerLeft B ((CategoryTheory.MonoidalClosed.pre f).app X))
    ((CategoryTheory.ihom.ev B).app X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f ((CategoryTheory.ihom A).obj X))
    ((CategoryTheory.ihom.ev A).app X)
-- CategoryTheory.MonoidalClosed.uncurry_pre
@[simp]
theorem uncurry_pre (f : B ⟶ A) (X : C) :
    MonoidalClosed.uncurry ((pre f).app X) = f ▷ _ ≫ (ihom.ev A).app X 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A B : C} [CategoryTheory.Closed A] [CategoryTheory.Closed B] (f : B ⟶ A) (X : C)
Goal: CategoryTheory.MonoidalClosed.uncurry ((CategoryTheory.MonoidalClosed.pre f).app X) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.whiskerRight f ((CategoryTheory.ihom A).obj X))
    ((CategoryTheory.ihom.ev A).app X)
-- CategoryTheory.MonoidalClosed.coev_app_comp_pre_app
@[reassoc (attr := simp)]
theorem coev_app_comp_pre_app (f : B ⟶ A) :
    (ihom.coev A).app X ≫ (pre f).app (A ⊗ X) = (ihom.coev B).app X ≫ (ihom B).map (f ▷ _) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A B : C} (X : C) [CategoryTheory.Closed A] [CategoryTheory.Closed B] (f : B ⟶ A)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.coev A).app X)
    ((CategoryTheory.MonoidalClosed.pre f).app (CategoryTheory.MonoidalCategory.tensorObj A X)) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom.coev B).app X)
    ((CategoryTheory.ihom B).map (CategoryTheory.MonoidalCategory.whiskerRight f X))
-- CategoryTheory.MonoidalClosed.pre_id
@[simp]
theorem pre_id (A : C) [Closed A] : pre (𝟙 A) = 𝟙 _ 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] (A : C) [CategoryTheory.Closed A]
Goal: CategoryTheory.MonoidalClosed.pre (CategoryTheory.CategoryStruct.id A) =
  CategoryTheory.CategoryStruct.id (CategoryTheory.ihom A)
-- CategoryTheory.MonoidalClosed.pre_map
@[simp]
theorem pre_map {A₁ A₂ A₃ : C} [Closed A₁] [Closed A₂] [Closed A₃] (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃) :
    pre (f ≫ g) = pre g ≫ pre f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {A₁ A₂ A₃ : C} [CategoryTheory.Closed A₁] [CategoryTheory.Closed A₂] [CategoryTheory.Closed A₃] (f : A₁ ⟶ A₂) (g : A₂ ⟶ A₃)
Goal: CategoryTheory.MonoidalClosed.pre (CategoryTheory.CategoryStruct.comp f g) =
  CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.pre g) (CategoryTheory.MonoidalClosed.pre f)
-- CategoryTheory.MonoidalClosed.pre_comm_ihom_map
theorem pre_comm_ihom_map {W X Y Z : C} [Closed W] [Closed X] (f : W ⟶ X) (g : Y ⟶ Z) :
    (pre f).app Y ≫ (ihom W).map g = (ihom X).map g ≫ (pre f).app Z 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] {W X Y Z : C} [CategoryTheory.Closed W] [CategoryTheory.Closed X] (f : W ⟶ X) (g : Y ⟶ Z)
Goal: CategoryTheory.CategoryStruct.comp ((CategoryTheory.MonoidalClosed.pre f).app Y) ((CategoryTheory.ihom W).map g) =
  CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom X).map g) ((CategoryTheory.MonoidalClosed.pre f).app Z)
-- CategoryTheory.MonoidalClosed.internalHom_map
@[simps]
def internalHom [MonoidalClosed C] : Cᵒᵖ ⥤ C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalClosed C]
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y), CategoryTheory.MonoidalClosed.internalHom.map f = CategoryTheory.MonoidalClosed.pre f.unop
-- CategoryTheory.MonoidalClosed.internalHom_obj
@[simps]
def internalHom [MonoidalClosed C] : Cᵒᵖ ⥤ C ⥤ C 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalClosed C] (X : Cᵒᵖ)
Goal: CategoryTheory.MonoidalClosed.internalHom.obj X = CategoryTheory.ihom (Opposite.unop X)