ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Polynomial.natTrailingDegree_le_of_ne_zero
theorem natTrailingDegree_le_of_ne_zero (h : coeff p n ≠ 0) : natTrailingDegree p ≤ n 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p : R[X]} (h : p.coeff n ≠ 0)
Goal: p.natTrailingDegree ≤ n
-- Polynomial.coeff_natTrailingDegree_eq_zero
@[simp] lemma coeff_natTrailingDegree_eq_zero : coeff p p.natTrailingDegree = 0 ↔ p = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.coeff p.natTrailingDegree = 0 ↔ p = 0
-- Polynomial.coeff_natTrailingDegree_ne_zero
lemma coeff_natTrailingDegree_ne_zero : coeff p p.natTrailingDegree ≠ 0 ↔ p ≠ 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.coeff p.natTrailingDegree ≠ 0 ↔ p ≠ 0
-- Polynomial.trailingDegree_eq_zero
@[simp]
lemma trailingDegree_eq_zero : trailingDegree p = 0 ↔ coeff p 0 ≠ 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.trailingDegree = 0 ↔ p.coeff 0 ≠ 0
-- Polynomial.natTrailingDegree_eq_zero
@[simp] lemma natTrailingDegree_eq_zero : natTrailingDegree p = 0 ↔ p = 0 ∨ coeff p 0 ≠ 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.natTrailingDegree = 0 ↔ p = 0 ∨ p.coeff 0 ≠ 0
-- Polynomial.natTrailingDegree_ne_zero
lemma natTrailingDegree_ne_zero : natTrailingDegree p ≠ 0 ↔ p ≠ 0 ∧ coeff p 0 = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.natTrailingDegree ≠ 0 ↔ p ≠ 0 ∧ p.coeff 0 = 0
-- Polynomial.trailingDegree_ne_zero
lemma trailingDegree_ne_zero : trailingDegree p ≠ 0 ↔ coeff p 0 = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.trailingDegree ≠ 0 ↔ p.coeff 0 = 0
-- Polynomial.trailingDegree_le_trailingDegree
@[simp] theorem trailingDegree_le_trailingDegree (h : coeff q (natTrailingDegree p) ≠ 0) :
    trailingDegree q ≤ trailingDegree p 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (h : q.coeff p.natTrailingDegree ≠ 0)
Goal: q.trailingDegree ≤ p.trailingDegree
-- Polynomial.trailingDegree_ne_of_natTrailingDegree_ne
theorem trailingDegree_ne_of_natTrailingDegree_ne {n : ℕ} :
    p.natTrailingDegree ≠ n → trailingDegree p ≠ n 
Arguments: {R : Type u} [Semiring R] {p : R[X]} {n : ℕ}
Goal: p.natTrailingDegree ≠ n → p.trailingDegree ≠ ↑n
-- Polynomial.natTrailingDegree_le_of_trailingDegree_le
theorem natTrailingDegree_le_of_trailingDegree_le {n : ℕ} {hp : p ≠ 0}
    (H : (n : ℕ∞) ≤ trailingDegree p) : n ≤ natTrailingDegree p 
Arguments: {R : Type u} [Semiring R] {p : R[X]} {n : ℕ} {hp : p ≠ 0} (H : ↑n ≤ p.trailingDegree)
Goal: n ≤ p.natTrailingDegree
-- Polynomial.natTrailingDegree_le_natTrailingDegree
theorem natTrailingDegree_le_natTrailingDegree (hq : q ≠ 0)
    (hpq : p.trailingDegree ≤ q.trailingDegree) : p.natTrailingDegree ≤ q.natTrailingDegree 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (hq : q ≠ 0) (hpq : p.trailingDegree ≤ q.trailingDegree)
Goal: p.natTrailingDegree ≤ q.natTrailingDegree
-- Polynomial.trailingDegree_monomial
@[simp]
theorem trailingDegree_monomial (ha : a ≠ 0) : trailingDegree (monomial n a) = n 
Arguments: {R : Type u} {a : R} {n : ℕ} [Semiring R] (ha : a ≠ 0)
Goal: ((Polynomial.monomial n) a).trailingDegree = ↑n
-- Polynomial.natTrailingDegree_monomial
theorem natTrailingDegree_monomial (ha : a ≠ 0) : natTrailingDegree (monomial n a) = n 
Arguments: {R : Type u} {a : R} {n : ℕ} [Semiring R] (ha : a ≠ 0)
Goal: ((Polynomial.monomial n) a).natTrailingDegree = n
-- Polynomial.natTrailingDegree_monomial_le
theorem natTrailingDegree_monomial_le : natTrailingDegree (monomial n a) ≤ n 
Arguments: {R : Type u} {a : R} {n : ℕ} [Semiring R]
Goal: ((Polynomial.monomial n) a).natTrailingDegree ≤ n
-- Polynomial.le_trailingDegree_monomial
theorem le_trailingDegree_monomial : ↑n ≤ trailingDegree (monomial n a) 
Arguments: {R : Type u} {a : R} {n : ℕ} [Semiring R]
Goal: ↑n ≤ ((Polynomial.monomial n) a).trailingDegree
-- Polynomial.trailingDegree_C
@[simp]
theorem trailingDegree_C (ha : a ≠ 0) : trailingDegree (C a) = (0 : ℕ∞) 
Arguments: {R : Type u} {a : R} [Semiring R] (ha : a ≠ 0)
Goal: (Polynomial.C a).trailingDegree = 0
-- Polynomial.le_trailingDegree_C
theorem le_trailingDegree_C : (0 : ℕ∞) ≤ trailingDegree (C a) 
Arguments: {R : Type u} {a : R} [Semiring R]
Goal: 0 ≤ (Polynomial.C a).trailingDegree
-- Polynomial.trailingDegree_one_le
theorem trailingDegree_one_le : (0 : ℕ∞) ≤ trailingDegree (1 : R[X]) 
Arguments: {R : Type u} [Semiring R]
Goal: 0 ≤ Polynomial.trailingDegree 1
-- Polynomial.natTrailingDegree_C
@[simp]
theorem natTrailingDegree_C (a : R) : natTrailingDegree (C a) = 0 
Arguments: {R : Type u} [Semiring R] (a : R)
Goal: (Polynomial.C a).natTrailingDegree = 0
-- Polynomial.natTrailingDegree_one
@[simp]
theorem natTrailingDegree_one : natTrailingDegree (1 : R[X]) = 0 
Arguments: {R : Type u} [Semiring R]
Goal: Polynomial.natTrailingDegree 1 = 0
-- Polynomial.natTrailingDegree_natCast
@[simp]
theorem natTrailingDegree_natCast (n : ℕ) : natTrailingDegree (n : R[X]) = 0 
Arguments: {R : Type u} [Semiring R] (n : ℕ)
Goal: (↑n).natTrailingDegree = 0
-- Polynomial.trailingDegree_C_mul_X_pow
@[simp]
theorem trailingDegree_C_mul_X_pow (n : ℕ) (ha : a ≠ 0) : trailingDegree (C a * X ^ n) = n 
Arguments: {R : Type u} {a : R} [Semiring R] (n : ℕ) (ha : a ≠ 0)
Goal: (Polynomial.C a * Polynomial.X ^ n).trailingDegree = ↑n
-- Polynomial.le_trailingDegree_C_mul_X_pow
theorem le_trailingDegree_C_mul_X_pow (n : ℕ) (a : R) :
    (n : ℕ∞) ≤ trailingDegree (C a * X ^ n) 
Arguments: {R : Type u} [Semiring R] (n : ℕ) (a : R)
Goal: ↑n ≤ (Polynomial.C a * Polynomial.X ^ n).trailingDegree
-- Polynomial.coeff_eq_zero_of_lt_trailingDegree
theorem coeff_eq_zero_of_lt_trailingDegree (h : (n : ℕ∞) < trailingDegree p) : coeff p n = 0 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p : R[X]} (h : ↑n < p.trailingDegree)
Goal: p.coeff n = 0
-- Polynomial.coeff_eq_zero_of_lt_natTrailingDegree
theorem coeff_eq_zero_of_lt_natTrailingDegree {p : R[X]} {n : ℕ} (h : n < p.natTrailingDegree) :
    p.coeff n = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]} {n : ℕ} (h : n < p.natTrailingDegree)
Goal: p.coeff n = 0
-- Polynomial.coeff_natTrailingDegree_pred_eq_zero
@[simp]
theorem coeff_natTrailingDegree_pred_eq_zero {p : R[X]} {hp : (0 : ℕ∞) < natTrailingDegree p} :
    p.coeff (p.natTrailingDegree - 1) = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]} {hp : 0 < ↑p.natTrailingDegree}
Goal: p.coeff (p.natTrailingDegree - 1) = 0
-- Polynomial.le_trailingDegree_X_pow
theorem le_trailingDegree_X_pow (n : ℕ) : (n : ℕ∞) ≤ trailingDegree (X ^ n : R[X]) 
Arguments: {R : Type u} [Semiring R] (n : ℕ)
Goal: ↑n ≤ (Polynomial.X ^ n).trailingDegree
-- Polynomial.le_trailingDegree_X
theorem le_trailingDegree_X : (1 : ℕ∞) ≤ trailingDegree (X : R[X]) 
Arguments: {R : Type u} [Semiring R]
Goal: 1 ≤ Polynomial.X.trailingDegree
-- Polynomial.natTrailingDegree_X_le
theorem natTrailingDegree_X_le : (X : R[X]).natTrailingDegree ≤ 1 
Arguments: {R : Type u} [Semiring R]
Goal: Polynomial.X.natTrailingDegree ≤ 1
-- Polynomial.trailingCoeff_eq_zero
@[simp]
theorem trailingCoeff_eq_zero : trailingCoeff p = 0 ↔ p = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.trailingCoeff = 0 ↔ p = 0
-- Polynomial.trailingCoeff_nonzero_iff_nonzero
theorem trailingCoeff_nonzero_iff_nonzero : trailingCoeff p ≠ 0 ↔ p ≠ 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.trailingCoeff ≠ 0 ↔ p ≠ 0
-- Polynomial.natTrailingDegree_mem_support_of_nonzero
theorem natTrailingDegree_mem_support_of_nonzero : p ≠ 0 → natTrailingDegree p ∈ p.support 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p ≠ 0 → p.natTrailingDegree ∈ p.support
-- Polynomial.natTrailingDegree_le_of_mem_supp
theorem natTrailingDegree_le_of_mem_supp (a : ℕ) : a ∈ p.support → natTrailingDegree p ≤ a 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (a : ℕ)
Goal: a ∈ p.support → p.natTrailingDegree ≤ a
-- Polynomial.natTrailingDegree_eq_support_min'
theorem natTrailingDegree_eq_support_min' (h : p ≠ 0) :
    natTrailingDegree p = p.support.min' (nonempty_support_iff.mpr h) 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (h : p ≠ 0)
Goal: p.natTrailingDegree = p.support.min' ⋯
-- Polynomial.le_natTrailingDegree
theorem le_natTrailingDegree (hp : p ≠ 0) (hn : ∀ m < n, p.coeff m = 0) :
    n ≤ p.natTrailingDegree 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p : R[X]} (hp : p ≠ 0) (hn : ∀ m < n, p.coeff m = 0)
Goal: n ≤ p.natTrailingDegree
-- Polynomial.natTrailingDegree_le_natDegree
theorem natTrailingDegree_le_natDegree (p : R[X]) : p.natTrailingDegree ≤ p.natDegree 
Arguments: {R : Type u} [Semiring R] (p : R[X])
Goal: p.natTrailingDegree ≤ p.natDegree
-- Polynomial.natTrailingDegree_mul_X_pow
theorem natTrailingDegree_mul_X_pow {p : R[X]} (hp : p ≠ 0) (n : ℕ) :
    (p * X ^ n).natTrailingDegree = p.natTrailingDegree + n 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (hp : p ≠ 0) (n : ℕ)
Goal: (p * Polynomial.X ^ n).natTrailingDegree = p.natTrailingDegree + n
-- Polynomial.le_trailingDegree_mul
theorem le_trailingDegree_mul : p.trailingDegree + q.trailingDegree ≤ (p * q).trailingDegree 
Arguments: {R : Type u} [Semiring R] {p q : R[X]}
Goal: p.trailingDegree + q.trailingDegree ≤ (p * q).trailingDegree
-- Polynomial.le_natTrailingDegree_mul
theorem le_natTrailingDegree_mul (h : p * q ≠ 0) :
    p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (h : p * q ≠ 0)
Goal: p.natTrailingDegree + q.natTrailingDegree ≤ (p * q).natTrailingDegree
-- Polynomial.coeff_mul_natTrailingDegree_add_natTrailingDegree
theorem coeff_mul_natTrailingDegree_add_natTrailingDegree : (p * q).coeff
    (p.natTrailingDegree + q.natTrailingDegree) = p.trailingCoeff * q.trailingCoeff 
Arguments: {R : Type u} [Semiring R] {p q : R[X]}
Goal: (p * q).coeff (p.natTrailingDegree + q.natTrailingDegree) = p.trailingCoeff * q.trailingCoeff
-- Polynomial.trailingDegree_mul'
theorem trailingDegree_mul' (h : p.trailingCoeff * q.trailingCoeff ≠ 0) :
    (p * q).trailingDegree = p.trailingDegree + q.trailingDegree 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (h : p.trailingCoeff * q.trailingCoeff ≠ 0)
Goal: (p * q).trailingDegree = p.trailingDegree + q.trailingDegree
-- Polynomial.natTrailingDegree_mul'
theorem natTrailingDegree_mul' (h : p.trailingCoeff * q.trailingCoeff ≠ 0) :
    (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (h : p.trailingCoeff * q.trailingCoeff ≠ 0)
Goal: (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree
-- Polynomial.natTrailingDegree_mul
theorem natTrailingDegree_mul [NoZeroDivisors R] (hp : p ≠ 0) (hq : q ≠ 0) :
    (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} [NoZeroDivisors R] (hp : p ≠ 0) (hq : q ≠ 0)
Goal: (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree
-- Polynomial.trailingDegree_one
@[simp]
theorem trailingDegree_one : trailingDegree (1 : R[X]) = (0 : ℕ∞) 
Arguments: {R : Type u} [Semiring R] [Nontrivial R]
Goal: Polynomial.trailingDegree 1 = 0
-- Polynomial.trailingDegree_X
@[simp]
theorem trailingDegree_X : trailingDegree (X : R[X]) = 1 
Arguments: {R : Type u} [Semiring R] [Nontrivial R]
Goal: Polynomial.X.trailingDegree = 1
-- Polynomial.natTrailingDegree_X
@[simp]
theorem natTrailingDegree_X : (X : R[X]).natTrailingDegree = 1 
Arguments: {R : Type u} [Semiring R] [Nontrivial R]
Goal: Polynomial.X.natTrailingDegree = 1
-- Polynomial.trailingDegree_X_pow
@[simp]
lemma trailingDegree_X_pow (n : ℕ) :
    (X ^ n : R[X]).trailingDegree = n 
Arguments: {R : Type u} [Semiring R] [Nontrivial R] (n : ℕ)
Goal: (Polynomial.X ^ n).trailingDegree = ↑n
-- Polynomial.natTrailingDegree_X_pow
@[simp]
lemma natTrailingDegree_X_pow (n : ℕ) :
    (X ^ n : R[X]).natTrailingDegree = n 
Arguments: {R : Type u} [Semiring R] [Nontrivial R] (n : ℕ)
Goal: (Polynomial.X ^ n).natTrailingDegree = n
-- Polynomial.trailingDegree_neg
@[simp]
theorem trailingDegree_neg (p : R[X]) : trailingDegree (-p) = trailingDegree p 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: (-p).trailingDegree = p.trailingDegree
-- Polynomial.natTrailingDegree_neg
@[simp]
theorem natTrailingDegree_neg (p : R[X]) : natTrailingDegree (-p) = natTrailingDegree p 
Arguments: {R : Type u} [Ring R] (p : R[X])
Goal: (-p).natTrailingDegree = p.natTrailingDegree
-- Polynomial.natTrailingDegree_intCast
@[simp]
theorem natTrailingDegree_intCast (n : ℤ) : natTrailingDegree (n : R[X]) = 0 
Arguments: {R : Type u} [Ring R] (n : ℤ)
Goal: (↑n).natTrailingDegree = 0
-- Polynomial.nextCoeffUp_zero
@[simp] lemma nextCoeffUp_zero : nextCoeffUp (0 : R[X]) = 0 
Arguments: {R : Type u} [Semiring R]
Goal: Polynomial.nextCoeffUp 0 = 0
-- Polynomial.nextCoeffUp_C_eq_zero
@[simp]
theorem nextCoeffUp_C_eq_zero (c : R) : nextCoeffUp (C c) = 0 
Arguments: {R : Type u} [Semiring R] (c : R)
Goal: (Polynomial.C c).nextCoeffUp = 0
-- Polynomial.nextCoeffUp_of_constantCoeff_eq_zero
theorem nextCoeffUp_of_constantCoeff_eq_zero (p : R[X]) (hp : coeff p 0 = 0) :
    nextCoeffUp p = p.coeff (p.natTrailingDegree + 1) 
Arguments: {R : Type u} [Semiring R] (p : R[X]) (hp : p.coeff 0 = 0)
Goal: p.nextCoeffUp = p.coeff (p.natTrailingDegree + 1)
-- Polynomial.coeff_natTrailingDegree_eq_zero_of_trailingDegree_lt
theorem coeff_natTrailingDegree_eq_zero_of_trailingDegree_lt
    (h : trailingDegree p < trailingDegree q) : coeff q (natTrailingDegree p) = 0 
Arguments: {R : Type u} [Semiring R] {p q : R[X]} (h : p.trailingDegree < q.trailingDegree)
Goal: q.coeff p.natTrailingDegree = 0
-- Polynomial.ne_zero_of_trailingDegree_lt
theorem ne_zero_of_trailingDegree_lt {n : ℕ∞} (h : trailingDegree p < n) : p ≠ 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]} {n : ℕ∞} (h : p.trailingDegree < n)
Goal: p ≠ 0
-- Polynomial.natTrailingDegree_eq_zero_of_constantCoeff_ne_zero
lemma natTrailingDegree_eq_zero_of_constantCoeff_ne_zero (h : constantCoeff p ≠ 0) :
    p.natTrailingDegree = 0 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (h : Polynomial.constantCoeff p ≠ 0)
Goal: p.natTrailingDegree = 0
-- Polynomial.Monic.eq_X_pow_iff_natDegree_le_natTrailingDegree
lemma eq_X_pow_iff_natDegree_le_natTrailingDegree (h₁ : p.Monic) :
    p = X ^ p.natDegree ↔ p.natDegree ≤ p.natTrailingDegree 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (h₁ : p.Monic)
Goal: p = Polynomial.X ^ p.natDegree ↔ p.natDegree ≤ p.natTrailingDegree
-- Polynomial.Monic.eq_X_pow_iff_natTrailingDegree_eq_natDegree
lemma eq_X_pow_iff_natTrailingDegree_eq_natDegree (h₁ : p.Monic) :
    p = X ^ p.natDegree ↔ p.natTrailingDegree = p.natDegree 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (h₁ : p.Monic)
Goal: p = Polynomial.X ^ p.natDegree ↔ p.natTrailingDegree = p.natDegree
-- CategoryTheory.uncurry_obj_obj
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (X : C × D)
Goal: (CategoryTheory.uncurry.obj F).obj X = (F.obj X.1).obj X.2
-- CategoryTheory.uncurry_obj_map
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) {X Y : C × D} (f : X ⟶ Y)
Goal: (CategoryTheory.uncurry.obj F).map f = CategoryTheory.CategoryStruct.comp ((F.map f.1).app X.2) ((F.obj Y.1).map f.2)
-- CategoryTheory.uncurry_map_app
@[simps]
def uncurry : (C ⥤ D ⥤ E) ⥤ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E]
Goal: ∀ {X Y : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (T : X ⟶ Y) (X_1 : C × D),
  (CategoryTheory.uncurry.map T).app X_1 = (T.app X_1.1).app X_1.2
-- CategoryTheory.curry_obj_map_app
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E)
Goal: ∀ {X Y : C} (f : X ⟶ Y) (Y_1 : D),
  ((CategoryTheory.curry.obj F).map f).app Y_1 = F.map (f, CategoryTheory.CategoryStruct.id Y_1)
-- CategoryTheory.curry_obj_obj_obj
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C) (Y : D)
Goal: ((CategoryTheory.curry.obj F).obj X).obj Y = F.obj (X, Y)
-- CategoryTheory.curry_obj_obj_map
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C)
Goal: ∀ {X_1 Y : D} (g : X_1 ⟶ Y), ((CategoryTheory.curry.obj F).obj X).map g = F.map (CategoryTheory.CategoryStruct.id X, g)
-- CategoryTheory.curry_map_app_app
@[simps! obj_obj_obj obj_obj_map obj_map_app map_app_app]
def curry : (C × D ⥤ E) ⥤ C ⥤ D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E]
Goal: ∀ {X Y : CategoryTheory.Functor (C × D) E} (T : X ⟶ Y) (X_1 : C) (Y_1 : D),
  ((CategoryTheory.curry.map T).app X_1).app Y_1 = T.app (X_1, Y_1)
-- CategoryTheory.currying_unitIso_hom_app_app_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ (X_1 : C) (X_2 : D),
  ((CategoryTheory.currying.unitIso.hom.app X).app X_1).app X_2 = CategoryTheory.CategoryStruct.id ((X.obj X_1).obj X_2)
-- CategoryTheory.currying_inverse_obj_map_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E)
Goal: ∀ {X Y : C} (f : X ⟶ Y) (Y_1 : D),
  ((CategoryTheory.currying.inverse.obj F).map f).app Y_1 = F.map (f, CategoryTheory.CategoryStruct.id Y_1)
-- CategoryTheory.currying_unitIso_inv_app_app_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor C (CategoryTheory.Functor D E))
Goal: ∀ (X_1 : C) (X_2 : D),
  ((CategoryTheory.currying.unitIso.inv.app X).app X_1).app X_2 = CategoryTheory.CategoryStruct.id ((X.obj X_1).obj X_2)
-- CategoryTheory.currying_functor_obj_obj
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (X : C × D)
Goal: (CategoryTheory.currying.functor.obj F).obj X = (F.obj X.1).obj X.2
-- CategoryTheory.currying_counitIso_inv_app_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor (C × D) E)
Goal: ∀ (X_1 : C × D),
  (CategoryTheory.currying.counitIso.inv.app X).app X_1 = CategoryTheory.CategoryStruct.id (X.obj (X_1.1, X_1.2))
-- CategoryTheory.currying_functor_obj_map
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) {X Y : C × D} (f : X ⟶ Y)
Goal: (CategoryTheory.currying.functor.obj F).map f =
  CategoryTheory.CategoryStruct.comp ((F.map f.1).app X.2) ((F.obj Y.1).map f.2)
-- CategoryTheory.currying_functor_map_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E]
Goal: ∀ {X Y : CategoryTheory.Functor C (CategoryTheory.Functor D E)} (T : X ⟶ Y) (X_1 : C × D),
  (CategoryTheory.currying.functor.map T).app X_1 = (T.app X_1.1).app X_1.2
-- CategoryTheory.currying_inverse_obj_obj_obj
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C) (Y : D)
Goal: ((CategoryTheory.currying.inverse.obj F).obj X).obj Y = F.obj (X, Y)
-- CategoryTheory.currying_inverse_obj_obj_map
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor (C × D) E) (X : C)
Goal: ∀ {X_1 Y : D} (g : X_1 ⟶ Y),
  ((CategoryTheory.currying.inverse.obj F).obj X).map g = F.map (CategoryTheory.CategoryStruct.id X, g)
-- CategoryTheory.currying_inverse_map_app_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E]
Goal: ∀ {X Y : CategoryTheory.Functor (C × D) E} (T : X ⟶ Y) (X_1 : C) (Y_1 : D),
  ((CategoryTheory.currying.inverse.map T).app X_1).app Y_1 = T.app (X_1, Y_1)
-- CategoryTheory.currying_counitIso_hom_app_app
@[simps!]
def currying : C ⥤ D ⥤ E ≌ C × D ⥤ E 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (X : CategoryTheory.Functor (C × D) E)
Goal: ∀ (X_1 : C × D),
  (CategoryTheory.currying.counitIso.hom.app X).app X_1 = CategoryTheory.CategoryStruct.id (X.obj (X_1.1, X_1.2))
-- CategoryTheory.flipIsoCurrySwapUncurry_hom_app_app
@[simps!]
def flipIsoCurrySwapUncurry (F : C ⥤ D ⥤ E) : F.flip ≅ curry.obj (Prod.swap _ _ ⋙ uncurry.obj F) 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (X : D)
Goal: ∀ (X_1 : C),
  ((CategoryTheory.flipIsoCurrySwapUncurry F).hom.app X).app X_1 = CategoryTheory.CategoryStruct.id ((F.obj X_1).obj X)
-- CategoryTheory.flipIsoCurrySwapUncurry_inv_app_app
@[simps!]
def flipIsoCurrySwapUncurry (F : C ⥤ D ⥤ E) : F.flip ≅ curry.obj (Prod.swap _ _ ⋙ uncurry.obj F) 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (X : D)
Goal: ∀ (X_1 : C),
  ((CategoryTheory.flipIsoCurrySwapUncurry F).inv.app X).app X_1 = CategoryTheory.CategoryStruct.id ((F.obj X_1).obj X)
-- CategoryTheory.uncurryObjFlip_hom_app
@[simps!]
def uncurryObjFlip (F : C ⥤ D ⥤ E) : uncurry.obj F.flip ≅ Prod.swap _ _ ⋙ uncurry.obj F 
Arguments: {C : Type u₂} [CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [CategoryTheory.Category.{v₃, u₃} D] {E : Type u₄} [CategoryTheory.Category.{v₄, u₄} E] (F : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (X : D × C)
Goal: (CategoryTheory.uncurryObjFlip F).hom.app X = CategoryTheory.CategoryStruct.id ((F.obj X.2).obj X.1)