ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Polynomial.natDegree_mul_leadingCoeff_self_inv
theorem natDegree_mul_leadingCoeff_self_inv (p : K[X]) :
    natDegree (p * C (leadingCoeff p)⁻¹) = natDegree p 
Arguments: {K : Type u_1} [DivisionRing K] (p : K[X])
Goal: (p * Polynomial.C p.leadingCoeff⁻¹).natDegree = p.natDegree
-- Polynomial.degree_add_degree_leadingCoeff_inv
@[simp] lemma degree_add_degree_leadingCoeff_inv (p : K[X]) :
    degree p + degree (C (leadingCoeff p)⁻¹) = degree p 
Arguments: {K : Type u_1} [DivisionRing K] (p : K[X])
Goal: p.degree + (Polynomial.C p.leadingCoeff⁻¹).degree = p.degree
-- Polynomial.coeff_divX
@[simp]
theorem coeff_divX : (divX p).coeff n = p.coeff (n + 1) 
Arguments: {R : Type u} {n : ℕ} [Semiring R] {p : R[X]}
Goal: p.divX.coeff n = p.coeff (n + 1)
-- Polynomial.divX_mul_X_add
theorem divX_mul_X_add (p : R[X]) : divX p * X + C (p.coeff 0) = p 
Arguments: {R : Type u} [Semiring R] (p : R[X])
Goal: p.divX * Polynomial.X + Polynomial.C (p.coeff 0) = p
-- Polynomial.X_mul_divX_add
@[simp]
theorem X_mul_divX_add (p : R[X]) : X * divX p + C (p.coeff 0) = p 
Arguments: {R : Type u} [Semiring R] (p : R[X])
Goal: Polynomial.X * p.divX + Polynomial.C (p.coeff 0) = p
-- Polynomial.divX_C
@[simp]
theorem divX_C (a : R) : divX (C a) = 0 
Arguments: {R : Type u} [Semiring R] (a : R)
Goal: (Polynomial.C a).divX = 0
-- Polynomial.divX_eq_zero_iff
theorem divX_eq_zero_iff : divX p = 0 ↔ p = C (p.coeff 0) 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.divX = 0 ↔ p = Polynomial.C (p.coeff 0)
-- Polynomial.divX_add
theorem divX_add : divX (p + q) = divX p + divX q 
Arguments: {R : Type u} [Semiring R] {p q : R[X]}
Goal: (p + q).divX = p.divX + q.divX
-- Polynomial.divX_zero
@[simp]
theorem divX_zero : divX (0 : R[X]) = 0 
Arguments: {R : Type u} [Semiring R]
Goal: Polynomial.divX 0 = 0
-- Polynomial.divX_one
@[simp]
theorem divX_one : divX (1 : R[X]) = 0 
Arguments: {R : Type u} [Semiring R]
Goal: Polynomial.divX 1 = 0
-- Polynomial.divX_C_mul
@[simp]
theorem divX_C_mul : divX (C a * p) = C a * divX p 
Arguments: {R : Type u} {a : R} [Semiring R] {p : R[X]}
Goal: (Polynomial.C a * p).divX = Polynomial.C a * p.divX
-- Polynomial.divX_X_pow
theorem divX_X_pow : divX (X ^ n : R[X]) = if (n = 0) then 0 else X ^ (n - 1) 
Arguments: {R : Type u} {n : ℕ} [Semiring R]
Goal: (Polynomial.X ^ n).divX = if n = 0 then 0 else Polynomial.X ^ (n - 1)
-- Polynomial.divX_hom_toFun
@[simp] theorem divX_hom_toFun : divX_hom p = divX p 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: Polynomial.divX_hom p = p.divX
-- Polynomial.natDegree_divX_eq_natDegree_tsub_one
theorem natDegree_divX_eq_natDegree_tsub_one : p.divX.natDegree = p.natDegree - 1 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.divX.natDegree = p.natDegree - 1
-- Polynomial.natDegree_divX_le
theorem natDegree_divX_le : p.divX.natDegree ≤ p.natDegree 
Arguments: {R : Type u} [Semiring R] {p : R[X]}
Goal: p.divX.natDegree ≤ p.natDegree
-- Polynomial.divX_C_mul_X_pow
theorem divX_C_mul_X_pow : divX (C a * X ^ n) = if n = 0 then 0 else C a * X ^ (n - 1) 
Arguments: {R : Type u} {a : R} {n : ℕ} [Semiring R]
Goal: (Polynomial.C a * Polynomial.X ^ n).divX = if n = 0 then 0 else Polynomial.C a * Polynomial.X ^ (n - 1)
-- Polynomial.degree_divX_lt
theorem degree_divX_lt (hp0 : p ≠ 0) : (divX p).degree < p.degree 
Arguments: {R : Type u} [Semiring R] {p : R[X]} (hp0 : p ≠ 0)
Goal: p.divX.degree < p.degree
-- Polynomial.degree_pos_induction_on
@[elab_as_elim]
theorem degree_pos_induction_on {P : R[X] → Prop} (p : R[X]) (h0 : 0 < degree p)
    (hC : ∀ {a}, a ≠ 0 → P (C a * X)) (hX : ∀ {p}, 0 < degree p → P p → P (p * X))
    (hadd : ∀ {p} {a}, 0 < degree p → P p → P (p + C a)) : P p 
Arguments: {R : Type u} [Semiring R] {P : R[X] → Prop} (p : R[X]) (h0 : 0 < p.degree) (hC : ∀ {a : R}, a ≠ 0 → P (Polynomial.C a * Polynomial.X)) (hX : ∀ {p : R[X]}, 0 < p.degree → P p → P (p * Polynomial.X)) (hadd : ∀ {p : R[X]} {a : R}, 0 < p.degree → P p → P (p + Polynomial.C a))
Goal: P p
-- Polynomial.natDegree_ne_zero_induction_on
@[elab_as_elim]
theorem natDegree_ne_zero_induction_on {M : R[X] → Prop} {f : R[X]} (f0 : f.natDegree ≠ 0)
    (h_C_add : ∀ {a p}, M p → M (C a + p)) (h_add : ∀ {p q}, M p → M q → M (p + q))
    (h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M (monomial n a)) : M f 
Arguments: {R : Type u} [Semiring R] {M : R[X] → Prop} {f : R[X]} (f0 : f.natDegree ≠ 0) (h_C_add : ∀ {a : R} {p : R[X]}, M p → M (Polynomial.C a + p)) (h_add : ∀ {p q : R[X]}, M p → M q → M (p + q)) (h_monomial : ∀ {n : ℕ} {a : R}, a ≠ 0 → n ≠ 0 → M ((Polynomial.monomial n) a))
Goal: M f
-- div_eq_quo_add_rem_div_add_rem_div
theorem div_eq_quo_add_rem_div_add_rem_div (f : R[X]) {g₁ g₂ : R[X]} (hg₁ : g₁.Monic)
    (hg₂ : g₂.Monic) (hcoprime : IsCoprime g₁ g₂) :
    ∃ q r₁ r₂ : R[X],
      r₁.degree < g₁.degree ∧
        r₂.degree < g₂.degree ∧ (f : K) / (↑g₁ * ↑g₂) = ↑q + ↑r₁ / ↑g₁ + ↑r₂ / ↑g₂ 
Arguments: (R : Type) [CommRing R] [IsDomain R] (K : Type) [Field K] [Algebra R[X] K] [IsFractionRing R[X] K] (f : R[X]) {g₁ g₂ : R[X]} (hg₁ : g₁.Monic) (hg₂ : g₂.Monic) (hcoprime : IsCoprime g₁ g₂)
Goal: ∃ q r₁ r₂, r₁.degree < g₁.degree ∧ r₂.degree < g₂.degree ∧ ↑f / (↑g₁ * ↑g₂) = ↑q + ↑r₁ / ↑g₁ + ↑r₂ / ↑g₂
-- div_eq_quo_add_sum_rem_div
theorem div_eq_quo_add_sum_rem_div (f : R[X]) {ι : Type*} {g : ι → R[X]} {s : Finset ι}
    (hg : ∀ i ∈ s, (g i).Monic) (hcop : Set.Pairwise ↑s fun i j => IsCoprime (g i) (g j)) :
    ∃ (q : R[X]) (r : ι → R[X]),
      (∀ i ∈ s, (r i).degree < (g i).degree) ∧
        ((↑f : K) / ∏ i ∈ s, ↑(g i)) = ↑q + ∑ i ∈ s, (r i : K) / (g i : K) 
Arguments: (R : Type) [CommRing R] [IsDomain R] (K : Type) [Field K] [Algebra R[X] K] [IsFractionRing R[X] K] (f : R[X]) {ι : Type u_1} {g : ι → R[X]} {s : Finset ι} (hg : ∀ i ∈ s, (g i).Monic) (hcop : (↑s).Pairwise fun i j => IsCoprime (g i) (g j))
Goal: ∃ q r, (∀ i ∈ s, (r i).degree < (g i).degree) ∧ ↑f / ∏ i ∈ s, ↑(g i) = ↑q + ∑ i ∈ s, ↑(r i) / ↑(g i)
-- CategoryTheory.Pi.id_apply
@[simp]
theorem id_apply (X : ∀ i, C i) (i) : (𝟙 X : ∀ i, X i ⟶ X i) i = 𝟙 (X i) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (X : (i : I) → C i) (i : I)
Goal: CategoryTheory.CategoryStruct.id X i = CategoryTheory.CategoryStruct.id (X i)
-- CategoryTheory.Pi.comp_apply
@[simp]
theorem comp_apply {X Y Z : ∀ i, C i} (f : X ⟶ Y) (g : Y ⟶ Z) (i) :
    (f ≫ g : ∀ i, X i ⟶ Z i) i = f i ≫ g i 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y Z : (i : I) → C i} (f : X ⟶ Y) (g : Y ⟶ Z) (i : I)
Goal: CategoryTheory.CategoryStruct.comp f g i = CategoryTheory.CategoryStruct.comp (f i) (g i)
-- CategoryTheory.Pi.ext
@[ext]
lemma ext {X Y : ∀ i, C i} {f g : X ⟶ Y} (w : ∀ i, f i = g i) : f = g 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i} {f g : X ⟶ Y} (w : ∀ (i : I), f i = g i)
Goal: f = g
-- CategoryTheory.Pi.eval_obj
@[simps]
def eval (i : I) : (∀ i, C i) ⥤ C i 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I) (f : (i : I) → C i)
Goal: (CategoryTheory.Pi.eval C i).obj f = f i
-- CategoryTheory.Pi.eval_map
@[simps]
def eval (i : I) : (∀ i, C i) ⥤ C i 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (i : I)
Goal: ∀ {X Y : (i : I) → C i} (α : X ⟶ Y), (CategoryTheory.Pi.eval C i).map α = α i
-- CategoryTheory.Pi.comap_map
@[simps]
def comap (h : J → I) : (∀ i, C i) ⥤ (∀ j, C (h j)) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₁} (h : J → I)
Goal: ∀ {X Y : (i : I) → C i} (α : X ⟶ Y) (i : J), (CategoryTheory.Pi.comap C h).map α i = α (h i)
-- CategoryTheory.Pi.comap_obj
@[simps]
def comap (h : J → I) : (∀ i, C i) ⥤ (∀ j, C (h j)) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₁} (h : J → I) (f : (i : I) → C i) (i : J)
Goal: (CategoryTheory.Pi.comap C h).obj f i = f (h i)
-- CategoryTheory.Pi.comapId_hom_app
@[simps]
def comapId : comap C (id : I → I) ≅ 𝟭 (∀ i, C i) 
Arguments: (I : Type w₀) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (X : (i : I) → C i) (i : I)
Goal: (CategoryTheory.Pi.comapId I C).hom.app X i = CategoryTheory.CategoryStruct.id X i
-- CategoryTheory.Pi.comapId_inv_app
@[simps]
def comapId : comap C (id : I → I) ≅ 𝟭 (∀ i, C i) 
Arguments: (I : Type w₀) (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (X : (i : I) → C i) (i : I)
Goal: (CategoryTheory.Pi.comapId I C).inv.app X i = CategoryTheory.CategoryStruct.id X i
-- CategoryTheory.Pi.comapComp_inv_app
@[simps!]
def comapComp (f : K → J) (g : J → I) : comap C g ⋙ comap (C ∘ g) f ≅ comap C (g ∘ f) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₁} {K : Type w₂} (f : K → J) (g : J → I) (X : (i : I) → C i) (b : K)
Goal: (CategoryTheory.Pi.comapComp C f g).inv.app X b = CategoryTheory.CategoryStruct.id (X (g (f b)))
-- CategoryTheory.Pi.comapComp_hom_app
@[simps!]
def comapComp (f : K → J) (g : J → I) : comap C g ⋙ comap (C ∘ g) f ≅ comap C (g ∘ f) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₁} {K : Type w₂} (f : K → J) (g : J → I) (X : (i : I) → C i) (b : K)
Goal: (CategoryTheory.Pi.comapComp C f g).hom.app X b = CategoryTheory.CategoryStruct.id (X (g (f b)))
-- CategoryTheory.Pi.comapEvalIsoEval_inv_app
@[simps!]
def comapEvalIsoEval (h : J → I) (j : J) : comap C h ⋙ eval (C ∘ h) j ≅ eval C (h j) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₁} (h : J → I) (j : J) (X : (i : I) → C i)
Goal: (CategoryTheory.Pi.comapEvalIsoEval C h j).inv.app X = CategoryTheory.CategoryStruct.id (X (h j))
-- CategoryTheory.Pi.comapEvalIsoEval_hom_app
@[simps!]
def comapEvalIsoEval (h : J → I) (j : J) : comap C h ⋙ eval (C ∘ h) j ≅ eval C (h j) 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₁} (h : J → I) (j : J) (X : (i : I) → C i)
Goal: (CategoryTheory.Pi.comapEvalIsoEval C h j).hom.app X = CategoryTheory.CategoryStruct.id (X (h j))
-- CategoryTheory.Pi.sum_obj_map
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₀} {D : J → Type u₁} [(j : J) → CategoryTheory.Category.{v₁, u₁} (D j)] (X : (i : I) → C i) {Y Y' : (j : J) → D j} (f : Y ⟶ Y') (s : I ⊕ J)
Goal: ((CategoryTheory.Pi.sum C).obj X).map f s =
  match s with
  | Sum.inl i => CategoryTheory.CategoryStruct.id (X i)
  | Sum.inr j => f j
-- CategoryTheory.Pi.sum_obj_obj
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₀} {D : J → Type u₁} [(j : J) → CategoryTheory.Category.{v₁, u₁} (D j)] (X : (i : I) → C i) (Y : (j : J) → D j) (s : I ⊕ J)
Goal: ((CategoryTheory.Pi.sum C).obj X).obj Y s =
  match s with
  | Sum.inl i => X i
  | Sum.inr j => Y j
-- CategoryTheory.Pi.sum_map_app
@[simps]
def sum : (∀ i, C i) ⥤ (∀ j, D j) ⥤ ∀ s : I ⊕ J, Sum.elim C D s 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {J : Type w₀} {D : J → Type u₁} [(j : J) → CategoryTheory.Category.{v₁, u₁} (D j)] {X X' : (i : I) → C i} (f : X ⟶ X') (Y : (j : J) → D j) (s : I ⊕ J)
Goal: ((CategoryTheory.Pi.sum C).map f).app Y s =
  match s with
  | Sum.inl i => f i
  | Sum.inr j => CategoryTheory.CategoryStruct.id (Y j)
-- CategoryTheory.Pi.isoApp_inv
@[simps]
def isoApp {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : X i ≅ Y i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i} (f : X ≅ Y) (i : I)
Goal: (CategoryTheory.Pi.isoApp f i).inv = f.inv i
-- CategoryTheory.Pi.isoApp_hom
@[simps]
def isoApp {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : X i ≅ Y i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i} (f : X ≅ Y) (i : I)
Goal: (CategoryTheory.Pi.isoApp f i).hom = f.hom i
-- CategoryTheory.Pi.isoApp_refl
@[simp]
theorem isoApp_refl (X : ∀ i, C i) (i : I) : isoApp (Iso.refl X) i = Iso.refl (X i) 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (X : (i : I) → C i) (i : I)
Goal: CategoryTheory.Pi.isoApp (CategoryTheory.Iso.refl X) i = CategoryTheory.Iso.refl (X i)
-- CategoryTheory.Pi.isoApp_symm
@[simp]
theorem isoApp_symm {X Y : ∀ i, C i} (f : X ≅ Y) (i : I) : isoApp f.symm i = (isoApp f i).symm 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i} (f : X ≅ Y) (i : I)
Goal: CategoryTheory.Pi.isoApp f.symm i = (CategoryTheory.Pi.isoApp f i).symm
-- CategoryTheory.Pi.isoApp_trans
@[simp]
theorem isoApp_trans {X Y Z : ∀ i, C i} (f : X ≅ Y) (g : Y ≅ Z) (i : I) :
    isoApp (f ≪≫ g) i = isoApp f i ≪≫ isoApp g i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y Z : (i : I) → C i} (f : X ≅ Y) (g : Y ≅ Z) (i : I)
Goal: CategoryTheory.Pi.isoApp (f ≪≫ g) i = CategoryTheory.Pi.isoApp f i ≪≫ CategoryTheory.Pi.isoApp g i
-- CategoryTheory.Functor.pi_map
@[simps]
def pi (F : ∀ i, C i ⥤ D i) : (∀ i, C i) ⥤ ∀ i, D i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₂} [(i : I) → CategoryTheory.Category.{v₂, u₂} (D i)] (F : (i : I) → CategoryTheory.Functor (C i) (D i))
Goal: ∀ {X Y : (i : I) → C i} (α : X ⟶ Y) (i : I), (CategoryTheory.Functor.pi F).map α i = (F i).map (α i)
-- CategoryTheory.Functor.pi_obj
@[simps]
def pi (F : ∀ i, C i ⥤ D i) : (∀ i, C i) ⥤ ∀ i, D i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₂} [(i : I) → CategoryTheory.Category.{v₂, u₂} (D i)] (F : (i : I) → CategoryTheory.Functor (C i) (D i)) (f : (i : I) → C i) (i : I)
Goal: (CategoryTheory.Functor.pi F).obj f i = (F i).obj (f i)
-- CategoryTheory.Functor.pi'_obj
@[simps]
def pi' (f : ∀ i, A ⥤ C i) : A ⥤ ∀ i, C i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] (f : (i : I) → CategoryTheory.Functor A (C i)) (a : A) (i : I)
Goal: (CategoryTheory.Functor.pi' f).obj a i = (f i).obj a
-- CategoryTheory.Functor.pi'_map
@[simps]
def pi' (f : ∀ i, A ⥤ C i) : A ⥤ ∀ i, C i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] (f : (i : I) → CategoryTheory.Functor A (C i))
Goal: ∀ {X Y : A} (h : X ⟶ Y) (i : I), (CategoryTheory.Functor.pi' f).map h i = (f i).map h
-- CategoryTheory.Functor.pi'CompEval_hom_app
@[simps!]
def pi'CompEval {A : Type*} [Category A] (F : ∀ i, A ⥤ C i) (i : I) :
    pi' F ⋙ Pi.eval C i ≅ F i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] (F : (i : I) → CategoryTheory.Functor A (C i)) (i : I) (X : A)
Goal: (CategoryTheory.Functor.pi'CompEval F i).hom.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)
-- CategoryTheory.Functor.pi'CompEval_inv_app
@[simps!]
def pi'CompEval {A : Type*} [Category A] (F : ∀ i, A ⥤ C i) (i : I) :
    pi' F ⋙ Pi.eval C i ≅ F i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {A : Type u_1} [CategoryTheory.Category.{u_2, u_1} A] (F : (i : I) → CategoryTheory.Functor A (C i)) (i : I) (X : A)
Goal: (CategoryTheory.Functor.pi'CompEval F i).inv.app X = CategoryTheory.CategoryStruct.id ((F i).obj X)
-- CategoryTheory.Functor.eqToHom_proj
@[simp]
theorem eqToHom_proj {x x' : ∀ i, C i} (h : x = x') (i : I) :
    (eqToHom h : x ⟶ x') i = eqToHom (Function.funext_iff.mp h i) 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {x x' : (i : I) → C i} (h : x = x') (i : I)
Goal: CategoryTheory.eqToHom h i = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Functor.pi'_eval
@[simp]
theorem pi'_eval (f : ∀ i, A ⥤ C i) (i : I) : pi' f ⋙ Pi.eval C i = f i 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] (f : (i : I) → CategoryTheory.Functor A (C i)) (i : I)
Goal: (CategoryTheory.Functor.pi' f).comp (CategoryTheory.Pi.eval C i) = f i
-- CategoryTheory.Functor.pi_ext
theorem pi_ext (f f' : A ⥤ ∀ i, C i) (h : ∀ i, f ⋙ (Pi.eval C i) = f' ⋙ (Pi.eval C i)) :
    f = f' 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {A : Type u₃} [CategoryTheory.Category.{v₃, u₃} A] (f f' : CategoryTheory.Functor A ((i : I) → C i)) (h : ∀ (i : I), f.comp (CategoryTheory.Pi.eval C i) = f'.comp (CategoryTheory.Pi.eval C i))
Goal: f = f'
-- CategoryTheory.NatTrans.pi_app
@[simps!]
def pi (α : ∀ i, F i ⟶ G i) : Functor.pi F ⟶ Functor.pi G 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₂} [(i : I) → CategoryTheory.Category.{v₂, u₂} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)} (α : (i : I) → F i ⟶ G i) (f : (i : I) → C i) (i : I)
Goal: (CategoryTheory.NatTrans.pi α).app f i = (α i).app (f i)
-- CategoryTheory.NatTrans.pi'_app
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (τ : ∀ i, F ⋙ Pi.eval C i ⟶ G ⋙ Pi.eval C i) : F ⟶ G 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F G : CategoryTheory.Functor E ((i : I) → C i)} (τ : (i : I) → F.comp (CategoryTheory.Pi.eval C i) ⟶ G.comp (CategoryTheory.Pi.eval C i)) (X : E) (i : I)
Goal: (CategoryTheory.NatTrans.pi' τ).app X i = (τ i).app X
-- CategoryTheory.NatIso.pi_hom
@[simps]
def pi (e : ∀ i, F i ≅ G i) : Functor.pi F ≅ Functor.pi G 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₂} [(i : I) → CategoryTheory.Category.{v₂, u₂} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)} (e : (i : I) → F i ≅ G i)
Goal: (CategoryTheory.NatIso.pi e).hom = CategoryTheory.NatTrans.pi fun i => (e i).hom
-- CategoryTheory.NatIso.pi_inv
@[simps]
def pi (e : ∀ i, F i ≅ G i) : Functor.pi F ≅ Functor.pi G 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : I → Type u₂} [(i : I) → CategoryTheory.Category.{v₂, u₂} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)} (e : (i : I) → F i ≅ G i)
Goal: (CategoryTheory.NatIso.pi e).inv = CategoryTheory.NatTrans.pi fun i => (e i).inv
-- CategoryTheory.NatIso.pi'_hom
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (e : ∀ i, F ⋙ Pi.eval C i ≅ G ⋙ Pi.eval C i) : F ≅ G 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F G : CategoryTheory.Functor E ((i : I) → C i)} (e : (i : I) → F.comp (CategoryTheory.Pi.eval C i) ≅ G.comp (CategoryTheory.Pi.eval C i))
Goal: (CategoryTheory.NatIso.pi' e).hom = CategoryTheory.NatTrans.pi' fun i => (e i).hom
-- CategoryTheory.NatIso.pi'_inv
@[simps]
def pi' {E : Type*} [Category E] {F G : E ⥤ ∀ i, C i}
    (e : ∀ i, F ⋙ Pi.eval C i ≅ G ⋙ Pi.eval C i) : F ≅ G 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {E : Type u_1} [CategoryTheory.Category.{u_2, u_1} E] {F G : CategoryTheory.Functor E ((i : I) → C i)} (e : (i : I) → F.comp (CategoryTheory.Pi.eval C i) ≅ G.comp (CategoryTheory.Pi.eval C i))
Goal: (CategoryTheory.NatIso.pi' e).inv = CategoryTheory.NatTrans.pi' fun i => (e i).inv
-- CategoryTheory.isIso_pi_iff
lemma isIso_pi_iff {X Y : ∀ i, C i} (f : X ⟶ Y) :
    IsIso f ↔ ∀ i, IsIso (f i) 
Arguments: {I : Type w₀} {C : I → Type u₁} [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i} (f : X ⟶ Y)
Goal: CategoryTheory.IsIso f ↔ ∀ (i : I), CategoryTheory.IsIso (f i)
-- CategoryTheory.Pi.evalCompEqToEquivalenceFunctor_inv
@[simps!]
def Pi.evalCompEqToEquivalenceFunctor {i j : I} (h : i = j) :
    Pi.eval C i ⋙ (Pi.eqToEquivalence C h).functor ≅
      Pi.eval C j 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {i j : I} (h : i = j)
Goal: (CategoryTheory.Pi.evalCompEqToEquivalenceFunctor C h).inv = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Pi.evalCompEqToEquivalenceFunctor_hom
@[simps!]
def Pi.evalCompEqToEquivalenceFunctor {i j : I} (h : i = j) :
    Pi.eval C i ⋙ (Pi.eqToEquivalence C h).functor ≅
      Pi.eval C j 
Arguments: {I : Type w₀} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {i j : I} (h : i = j)
Goal: (CategoryTheory.Pi.evalCompEqToEquivalenceFunctor C h).hom = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Pi.eqToEquivalenceFunctorIso_inv
@[simps!]
def Pi.eqToEquivalenceFunctorIso (f : J → I) {i' j' : J} (h : i' = j') :
    (Pi.eqToEquivalence C (congr_arg f h)).functor ≅
      (Pi.eqToEquivalence (fun i' => C (f i')) h).functor 
Arguments: {I : Type w₀} {J : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (f : J → I) {i' j' : J} (h : i' = j')
Goal: (CategoryTheory.Pi.eqToEquivalenceFunctorIso C f h).inv = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Pi.eqToEquivalenceFunctorIso_hom
@[simps!]
def Pi.eqToEquivalenceFunctorIso (f : J → I) {i' j' : J} (h : i' = j') :
    (Pi.eqToEquivalence C (congr_arg f h)).functor ≅
      (Pi.eqToEquivalence (fun i' => C (f i')) h).functor 
Arguments: {I : Type w₀} {J : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (f : J → I) {i' j' : J} (h : i' = j')
Goal: (CategoryTheory.Pi.eqToEquivalenceFunctorIso C f h).hom = CategoryTheory.eqToHom ⋯
-- CategoryTheory.Pi.equivalenceOfEquiv_counitIso
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
Arguments: {I : Type w₀} {J : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (e : J ≃ I)
Goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).counitIso =
  CategoryTheory.NatIso.pi' fun i =>
    ((CategoryTheory.Functor.pi' fun i' => CategoryTheory.Pi.eval C (e i')).associator
          (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm i))
          (CategoryTheory.Pi.eqToEquivalence C ⋯).functor).symm ≪≫
      CategoryTheory.isoWhiskerRight
          (CategoryTheory.Functor.pi'CompEval (fun i' => CategoryTheory.Pi.eval C (e i')) (e.symm i))
          (CategoryTheory.Pi.eqToEquivalence C ⋯).functor ≪≫
        CategoryTheory.Pi.evalCompEqToEquivalenceFunctor C ⋯ ≪≫ (CategoryTheory.Pi.eval C i).leftUnitor.symm
-- CategoryTheory.Pi.equivalenceOfEquiv_inverse
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
Arguments: {I : Type w₀} {J : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (e : J ≃ I)
Goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).inverse =
  CategoryTheory.Functor.pi' fun i' => CategoryTheory.Pi.eval C (e i')
-- CategoryTheory.Pi.equivalenceOfEquiv_functor
@[simps]
noncomputable def Pi.equivalenceOfEquiv (e : J ≃ I) :
    (∀ j, C (e j)) ≌ (∀ i, C i) 
Arguments: {I : Type w₀} {J : Type w₁} (C : I → Type u₁) [(i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] (e : J ≃ I)
Goal: (CategoryTheory.Pi.equivalenceOfEquiv C e).functor =
  CategoryTheory.Functor.pi' fun i =>
    (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm i)).comp (CategoryTheory.Pi.eqToEquivalence C ⋯).functor