ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.ComposableArrows.isoMk₅_inv
@[simps]
def isoMk₅ {f g : ComposableArrows C 5}
    (app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
    (app₃ : f.obj' 3 ≅ g.obj' 3) (app₄ : f.obj' 4 ≅ g.obj' 4) (app₅ : f.obj' 5 ≅ g.obj' 5)
    (w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
    (w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4)
    (w₄ : f.map' 4 5 ≫ app₅.hom = app₄.hom ≫ g.map' 4 5) :
    f ≅ g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 5} (app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯) (app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯) (app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯) (app₅ : f.obj' 5 ⋯ ≅ g.obj' 5 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁.hom =
    CategoryTheory.CategoryStruct.comp app₀.hom (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂.hom =
    CategoryTheory.CategoryStruct.comp app₁.hom (g.map' 1 2 ⋯ ⋯)) (w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃.hom =
    CategoryTheory.CategoryStruct.comp app₂.hom (g.map' 2 3 ⋯ ⋯)) (w₃ :
  CategoryTheory.CategoryStruct.comp (f.map' 3 4 ⋯ ⋯) app₄.hom =
    CategoryTheory.CategoryStruct.comp app₃.hom (g.map' 3 4 ⋯ ⋯)) (w₄ :
  CategoryTheory.CategoryStruct.comp (f.map' 4 5 ⋯ ⋯) app₅.hom =
    CategoryTheory.CategoryStruct.comp app₄.hom (g.map' 4 5 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.isoMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).inv =
  CategoryTheory.ComposableArrows.homMk₅ app₀.inv app₁.inv app₂.inv app₃.inv app₄.inv app₅.inv ⋯ ⋯ ⋯ ⋯ ⋯
-- CategoryTheory.ComposableArrows.isoMk₅_hom
@[simps]
def isoMk₅ {f g : ComposableArrows C 5}
    (app₀ : f.obj' 0 ≅ g.obj' 0) (app₁ : f.obj' 1 ≅ g.obj' 1) (app₂ : f.obj' 2 ≅ g.obj' 2)
    (app₃ : f.obj' 3 ≅ g.obj' 3) (app₄ : f.obj' 4 ≅ g.obj' 4) (app₅ : f.obj' 5 ≅ g.obj' 5)
    (w₀ : f.map' 0 1 ≫ app₁.hom = app₀.hom ≫ g.map' 0 1)
    (w₁ : f.map' 1 2 ≫ app₂.hom = app₁.hom ≫ g.map' 1 2)
    (w₂ : f.map' 2 3 ≫ app₃.hom = app₂.hom ≫ g.map' 2 3)
    (w₃ : f.map' 3 4 ≫ app₄.hom = app₃.hom ≫ g.map' 3 4)
    (w₄ : f.map' 4 5 ≫ app₅.hom = app₄.hom ≫ g.map' 4 5) :
    f ≅ g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 5} (app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯) (app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯) (app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯) (app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯) (app₄ : f.obj' 4 ⋯ ≅ g.obj' 4 ⋯) (app₅ : f.obj' 5 ⋯ ≅ g.obj' 5 ⋯) (w₀ :
  CategoryTheory.CategoryStruct.comp (f.map' 0 1 ⋯ ⋯) app₁.hom =
    CategoryTheory.CategoryStruct.comp app₀.hom (g.map' 0 1 ⋯ ⋯)) (w₁ :
  CategoryTheory.CategoryStruct.comp (f.map' 1 2 ⋯ ⋯) app₂.hom =
    CategoryTheory.CategoryStruct.comp app₁.hom (g.map' 1 2 ⋯ ⋯)) (w₂ :
  CategoryTheory.CategoryStruct.comp (f.map' 2 3 ⋯ ⋯) app₃.hom =
    CategoryTheory.CategoryStruct.comp app₂.hom (g.map' 2 3 ⋯ ⋯)) (w₃ :
  CategoryTheory.CategoryStruct.comp (f.map' 3 4 ⋯ ⋯) app₄.hom =
    CategoryTheory.CategoryStruct.comp app₃.hom (g.map' 3 4 ⋯ ⋯)) (w₄ :
  CategoryTheory.CategoryStruct.comp (f.map' 4 5 ⋯ ⋯) app₅.hom =
    CategoryTheory.CategoryStruct.comp app₄.hom (g.map' 4 5 ⋯ ⋯))
Goal: (CategoryTheory.ComposableArrows.isoMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).hom =
  CategoryTheory.ComposableArrows.homMk₅ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom app₅.hom w₀ w₁ w₂ w₃ w₄
-- CategoryTheory.ComposableArrows.ext₅
lemma ext₅ {f g : ComposableArrows C 5}
    (h₀ : f.obj' 0 = g.obj' 0) (h₁ : f.obj' 1 = g.obj' 1) (h₂ : f.obj' 2 = g.obj' 2)
    (h₃ : f.obj' 3 = g.obj' 3) (h₄ : f.obj' 4 = g.obj' 4) (h₅ : f.obj' 5 = g.obj' 5)
    (w₀ : f.map' 0 1 = eqToHom h₀ ≫ g.map' 0 1 ≫ eqToHom h₁.symm)
    (w₁ : f.map' 1 2 = eqToHom h₁ ≫ g.map' 1 2 ≫ eqToHom h₂.symm)
    (w₂ : f.map' 2 3 = eqToHom h₂ ≫ g.map' 2 3 ≫ eqToHom h₃.symm)
    (w₃ : f.map' 3 4 = eqToHom h₃ ≫ g.map' 3 4 ≫ eqToHom h₄.symm)
    (w₄ : f.map' 4 5 = eqToHom h₄ ≫ g.map' 4 5 ≫ eqToHom h₅.symm) :
    f = g 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {f g : CategoryTheory.ComposableArrows C 5} (h₀ : f.obj' 0 ⋯ = g.obj' 0 ⋯) (h₁ : f.obj' 1 ⋯ = g.obj' 1 ⋯) (h₂ : f.obj' 2 ⋯ = g.obj' 2 ⋯) (h₃ : f.obj' 3 ⋯ = g.obj' 3 ⋯) (h₄ : f.obj' 4 ⋯ = g.obj' 4 ⋯) (h₅ : f.obj' 5 ⋯ = g.obj' 5 ⋯) (w₀ :
  f.map' 0 1 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₀)
      (CategoryTheory.CategoryStruct.comp (g.map' 0 1 ⋯ ⋯) (CategoryTheory.eqToHom ⋯))) (w₁ :
  f.map' 1 2 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₁)
      (CategoryTheory.CategoryStruct.comp (g.map' 1 2 ⋯ ⋯) (CategoryTheory.eqToHom ⋯))) (w₂ :
  f.map' 2 3 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₂)
      (CategoryTheory.CategoryStruct.comp (g.map' 2 3 ⋯ ⋯) (CategoryTheory.eqToHom ⋯))) (w₃ :
  f.map' 3 4 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₃)
      (CategoryTheory.CategoryStruct.comp (g.map' 3 4 ⋯ ⋯) (CategoryTheory.eqToHom ⋯))) (w₄ :
  f.map' 4 5 ⋯ ⋯ =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h₄)
      (CategoryTheory.CategoryStruct.comp (g.map' 4 5 ⋯ ⋯) (CategoryTheory.eqToHom ⋯)))
Goal: f = g
-- CategoryTheory.ComposableArrows.mk₅_surjective
lemma mk₅_surjective (X : ComposableArrows C 5) :
    ∃ (X₀ X₁ X₂ X₃ X₄ X₅ : C) (f₀ : X₀ ⟶ X₁) (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃)
      (f₃ : X₃ ⟶ X₄) (f₄ : X₄ ⟶ X₅), X = mk₅ f₀ f₁ f₂ f₃ f₄ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] (X : CategoryTheory.ComposableArrows C 5)
Goal: ∃ X₀ X₁ X₂ X₃ X₄ X₅ f₀ f₁ f₂ f₃ f₄, X = CategoryTheory.ComposableArrows.mk₅ f₀ f₁ f₂ f₃ f₄
-- CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_exists
lemma mkOfObjOfMapSucc_exists : ∃ (F : ComposableArrows C n) (e : ∀ i, F.obj i ≅ obj i),
    ∀ (i : ℕ) (hi : i < n), mapSucc ⟨i, hi⟩ =
      (e ⟨i, _⟩).inv ≫ F.map' i (i + 1) ≫ (e ⟨i + 1, _⟩).hom 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (obj : Fin (n + 1) → C) (mapSucc : (i : Fin n) → obj i.castSucc ⟶ obj i.succ)
Goal: ∃ F e,
  ∀ (i : ℕ) (hi : i < n),
    mapSucc ⟨i, hi⟩ =
      CategoryTheory.CategoryStruct.comp (e ⟨i, ⋯⟩).inv
        (CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (e ⟨i + 1, ⋯⟩).hom)
-- CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_obj
@[simp]
lemma mkOfObjOfMapSucc_obj (i : Fin (n + 1)) :
    (mkOfObjOfMapSucc obj mapSucc).obj i = obj i 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (obj : Fin (n + 1) → C) (mapSucc : (i : Fin n) → obj i.castSucc ⟶ obj i.succ) (i : Fin (n + 1))
Goal: (CategoryTheory.ComposableArrows.mkOfObjOfMapSucc obj mapSucc).obj i = obj i
-- CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_map_succ
lemma mkOfObjOfMapSucc_map_succ (i : ℕ) (hi : i < n := by valid) :
    (mkOfObjOfMapSucc obj mapSucc).map' i (i + 1) = mapSucc ⟨i, hi⟩ 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (obj : Fin (n + 1) → C) (mapSucc : (i : Fin n) → obj i.castSucc ⟶ obj i.succ) (i : ℕ) (hi : i < n := by valid)
Goal: (CategoryTheory.ComposableArrows.mkOfObjOfMapSucc obj mapSucc).map' i (i + 1) ⋯ hi = mapSucc ⟨i, hi⟩
-- CategoryTheory.ComposableArrows.mkOfObjOfMapSucc_arrow
lemma mkOfObjOfMapSucc_arrow (i : ℕ) (hi : i < n := by valid) :
    (mkOfObjOfMapSucc obj mapSucc).arrow i = mk₁ (mapSucc ⟨i, hi⟩) 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {n : ℕ} (obj : Fin (n + 1) → C) (mapSucc : (i : Fin n) → obj i.castSucc ⟶ obj i.succ) (i : ℕ) (hi : i < n := by valid)
Goal: (CategoryTheory.ComposableArrows.mkOfObjOfMapSucc obj mapSucc).arrow i hi =
  CategoryTheory.ComposableArrows.mk₁ (mapSucc ⟨i, hi⟩)
-- CategoryTheory.ComposableArrows.opEquivalence_functor_obj_obj
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : (CategoryTheory.Functor (Fin (n + 1)) C)ᵒᵖ)
Goal: ∀ (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).functor.obj X).obj X_1 =
    Opposite.op ((Opposite.unop X).obj X_1.rev)
-- CategoryTheory.ComposableArrows.opEquivalence_inverse_map
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ)
Goal: ∀ {X Y : CategoryTheory.ComposableArrows Cᵒᵖ n} (f : X ⟶ Y),
  (CategoryTheory.ComposableArrows.opEquivalence C n).inverse.map f =
    (CategoryTheory.whiskerLeft (⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor)
        (CategoryTheory.NatTrans.leftOp f)).op
-- CategoryTheory.ComposableArrows.opEquivalence_unitIso_inv_app
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : (CategoryTheory.Functor (Fin (n + 1)) C)ᵒᵖ)
Goal: (CategoryTheory.ComposableArrows.opEquivalence C n).unitIso.inv.app X =
  CategoryTheory.CategoryStruct.comp
    (CategoryTheory.whiskerLeft (⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor)
        (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).inverse.comp ⋯.functor).comp
              (Opposite.unop X)).rightOpLeftOpIso.inv).op
    ((CategoryTheory.Equivalence.adjointifyη
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                            Fin.revOrderIso.equivalence).symm.funInvIdAssoc
                      F).symm)
                ⋯)
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  ((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                          Fin.revOrderIso.equivalence).symm.invFunIdAssoc
                    F)
                ⋯)).hom.app
        (Opposite.unop X)).op
-- CategoryTheory.ComposableArrows.opEquivalence_functor_obj_map
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : (CategoryTheory.Functor (Fin (n + 1)) C)ᵒᵖ)
Goal: ∀ {X_1 Y : Fin (n + 1)} (f : X_1 ⟶ Y),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).functor.obj X).map f =
    ((Opposite.unop X).map (⋯.functor.map (CategoryTheory.homOfLE ⋯))).op
-- CategoryTheory.ComposableArrows.opEquivalence_inverse_obj
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : CategoryTheory.ComposableArrows Cᵒᵖ n)
Goal: (CategoryTheory.ComposableArrows.opEquivalence C n).inverse.obj X =
  Opposite.op
    ((⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor).comp
      (CategoryTheory.Functor.leftOp X))
-- CategoryTheory.ComposableArrows.opEquivalence_counitIso_hom_app_app
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : CategoryTheory.ComposableArrows Cᵒᵖ n)
Goal: ∀ (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).counitIso.hom.app X).app X_1 =
    X.map
      (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans Fin.revOrderIso.equivalence).symm.counitInv.app
          (Opposite.op X_1)).unop
-- CategoryTheory.ComposableArrows.opEquivalence_unitIso_hom_app
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : (CategoryTheory.Functor (Fin (n + 1)) C)ᵒᵖ)
Goal: (CategoryTheory.ComposableArrows.opEquivalence C n).unitIso.hom.app X =
  CategoryTheory.CategoryStruct.comp
    ((CategoryTheory.Equivalence.adjointifyη
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                            Fin.revOrderIso.equivalence).symm.funInvIdAssoc
                      F).symm)
                ⋯)
              (CategoryTheory.NatIso.ofComponents
                (fun F =>
                  ((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans
                          Fin.revOrderIso.equivalence).symm.invFunIdAssoc
                    F)
                ⋯)).inv.app
        (Opposite.unop X)).op
    (CategoryTheory.whiskerLeft (⋯.functor.comp (CategoryTheory.orderDualEquivalence (Fin (n + 1))).functor)
        (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).inverse.comp ⋯.functor).comp
              (Opposite.unop X)).rightOpLeftOpIso.hom).op
-- CategoryTheory.ComposableArrows.opEquivalence_functor_map_app
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ)
Goal: ∀ {X Y : (CategoryTheory.Functor (Fin (n + 1)) C)ᵒᵖ} (f : X ⟶ Y) (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).functor.map f).app X_1 = (f.unop.app X_1.rev).op
-- CategoryTheory.ComposableArrows.opEquivalence_counitIso_inv_app_app
@[simps!]
def opEquivalence : (ComposableArrows C n)ᵒᵖ ≌ ComposableArrows Cᵒᵖ n 
Arguments: (C : Type u_1) [CategoryTheory.Category.{u_2, u_1} C] (n : ℕ) (X : CategoryTheory.ComposableArrows Cᵒᵖ n)
Goal: ∀ (X_1 : Fin (n + 1)),
  ((CategoryTheory.ComposableArrows.opEquivalence C n).counitIso.inv.app X).app X_1 =
    X.map
      (((CategoryTheory.orderDualEquivalence (Fin (n + 1))).symm.trans Fin.revOrderIso.equivalence).symm.counit.app
          (Opposite.op X_1)).unop
-- CategoryTheory.Functor.mapComposableArrows_map_app
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D) (n : ℕ)
Goal: ∀ {X Y : CategoryTheory.Functor (Fin (n + 1)) C} (α : X ⟶ Y) (X_1 : Fin (n + 1)),
  ((G.mapComposableArrows n).map α).app X_1 = G.map (α.app X_1)
-- CategoryTheory.Functor.mapComposableArrows_obj_map
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D) (n : ℕ) (F : CategoryTheory.Functor (Fin (n + 1)) C)
Goal: ∀ {X Y : Fin (n + 1)} (f : X ⟶ Y), ((G.mapComposableArrows n).obj F).map f = G.map (F.map f)
-- CategoryTheory.Functor.mapComposableArrows_obj_obj
@[simps!]
def Functor.mapComposableArrows :
    ComposableArrows C n ⥤ ComposableArrows D n 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_3, u_1} C] {D : Type u_2} [CategoryTheory.Category.{u_4, u_2} D] (G : CategoryTheory.Functor C D) (n : ℕ) (F : CategoryTheory.Functor (Fin (n + 1)) C) (X : Fin (n + 1))
Goal: ((G.mapComposableArrows n).obj F).obj X = G.obj (F.obj X)
-- Cubic.C_mul_prod_X_sub_C_eq
theorem C_mul_prod_X_sub_C_eq [CommRing S] {w x y z : S} :
    C w * (X - C x) * (X - C y) * (X - C z) =
      toPoly ⟨w, w * -(x + y + z), w * (x * y + x * z + y * z), w * -(x * y * z)⟩ 
Arguments: {S : Type u_2} [CommRing S] {w x y z : S}
Goal: Polynomial.C w * (Polynomial.X - Polynomial.C x) * (Polynomial.X - Polynomial.C y) * (Polynomial.X - Polynomial.C z) =
  { a := w, b := w * -(x + y + z), c := w * (x * y + x * z + y * z), d := w * -(x * y * z) }.toPoly
-- Cubic.prod_X_sub_C_eq
theorem prod_X_sub_C_eq [CommRing S] {x y z : S} :
    (X - C x) * (X - C y) * (X - C z) =
      toPoly ⟨1, -(x + y + z), x * y + x * z + y * z, -(x * y * z)⟩ 
Arguments: {S : Type u_2} [CommRing S] {x y z : S}
Goal: (Polynomial.X - Polynomial.C x) * (Polynomial.X - Polynomial.C y) * (Polynomial.X - Polynomial.C z) =
  { a := 1, b := -(x + y + z), c := x * y + x * z + y * z, d := -(x * y * z) }.toPoly
-- _private.Mathlib.Algebra.CubicDiscriminant.0.Cubic.coeffs
private theorem coeffs : (∀ n > 3, P.toPoly.coeff n = 0) ∧ P.toPoly.coeff 3 = P.a ∧
    P.toPoly.coeff 2 = P.b ∧ P.toPoly.coeff 1 = P.c ∧ P.toPoly.coeff 0 = P.d 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R]
Goal: (∀ n > 3, P.toPoly.coeff n = 0) ∧
  P.toPoly.coeff 3 = P.a ∧ P.toPoly.coeff 2 = P.b ∧ P.toPoly.coeff 1 = P.c ∧ P.toPoly.coeff 0 = P.d
-- Cubic.coeff_eq_zero
@[simp]
theorem coeff_eq_zero {n : ℕ} (hn : 3 < n) : P.toPoly.coeff n = 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] {n : ℕ} (hn : 3 < n)
Goal: P.toPoly.coeff n = 0
-- Cubic.coeff_eq_a
@[simp]
theorem coeff_eq_a : P.toPoly.coeff 3 = P.a 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R]
Goal: P.toPoly.coeff 3 = P.a
-- Cubic.coeff_eq_b
@[simp]
theorem coeff_eq_b : P.toPoly.coeff 2 = P.b 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R]
Goal: P.toPoly.coeff 2 = P.b
-- Cubic.coeff_eq_c
@[simp]
theorem coeff_eq_c : P.toPoly.coeff 1 = P.c 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R]
Goal: P.toPoly.coeff 1 = P.c
-- Cubic.coeff_eq_d
@[simp]
theorem coeff_eq_d : P.toPoly.coeff 0 = P.d 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R]
Goal: P.toPoly.coeff 0 = P.d
-- Cubic.a_of_eq
theorem a_of_eq (h : P.toPoly = Q.toPoly) : P.a = Q.a 
Arguments: {R : Type u_1} {P Q : Cubic R} [Semiring R] (h : P.toPoly = Q.toPoly)
Goal: P.a = Q.a
-- Cubic.b_of_eq
theorem b_of_eq (h : P.toPoly = Q.toPoly) : P.b = Q.b 
Arguments: {R : Type u_1} {P Q : Cubic R} [Semiring R] (h : P.toPoly = Q.toPoly)
Goal: P.b = Q.b
-- Cubic.c_of_eq
theorem c_of_eq (h : P.toPoly = Q.toPoly) : P.c = Q.c 
Arguments: {R : Type u_1} {P Q : Cubic R} [Semiring R] (h : P.toPoly = Q.toPoly)
Goal: P.c = Q.c
-- Cubic.d_of_eq
theorem d_of_eq (h : P.toPoly = Q.toPoly) : P.d = Q.d 
Arguments: {R : Type u_1} {P Q : Cubic R} [Semiring R] (h : P.toPoly = Q.toPoly)
Goal: P.d = Q.d
-- Cubic.toPoly_injective
theorem toPoly_injective (P Q : Cubic R) : P.toPoly = Q.toPoly ↔ P = Q 
Arguments: {R : Type u_1} [Semiring R] (P Q : Cubic R)
Goal: P.toPoly = Q.toPoly ↔ P = Q
-- Cubic.of_a_eq_zero
theorem of_a_eq_zero (ha : P.a = 0) : P.toPoly = C P.b * X ^ 2 + C P.c * X + C P.d 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0)
Goal: P.toPoly = Polynomial.C P.b * Polynomial.X ^ 2 + Polynomial.C P.c * Polynomial.X + Polynomial.C P.d
-- Cubic.of_a_eq_zero'
theorem of_a_eq_zero' : toPoly ⟨0, b, c, d⟩ = C b * X ^ 2 + C c * X + C d 
Arguments: {R : Type u_1} {b c d : R} [Semiring R]
Goal: { a := 0, b := b, c := c, d := d }.toPoly =
  Polynomial.C b * Polynomial.X ^ 2 + Polynomial.C c * Polynomial.X + Polynomial.C d
-- Cubic.of_b_eq_zero
theorem of_b_eq_zero (ha : P.a = 0) (hb : P.b = 0) : P.toPoly = C P.c * X + C P.d 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 0)
Goal: P.toPoly = Polynomial.C P.c * Polynomial.X + Polynomial.C P.d
-- Cubic.of_b_eq_zero'
theorem of_b_eq_zero' : toPoly ⟨0, 0, c, d⟩ = C c * X + C d 
Arguments: {R : Type u_1} {c d : R} [Semiring R]
Goal: { a := 0, b := 0, c := c, d := d }.toPoly = Polynomial.C c * Polynomial.X + Polynomial.C d
-- Cubic.of_c_eq_zero
theorem of_c_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) : P.toPoly = C P.d 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0)
Goal: P.toPoly = Polynomial.C P.d
-- Cubic.of_c_eq_zero'
theorem of_c_eq_zero' : toPoly ⟨0, 0, 0, d⟩ = C d 
Arguments: {R : Type u_1} {d : R} [Semiring R]
Goal: { a := 0, b := 0, c := 0, d := d }.toPoly = Polynomial.C d
-- Cubic.of_d_eq_zero
theorem of_d_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) (hd : P.d = 0) :
    P.toPoly = 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) (hd : P.d = 0)
Goal: P.toPoly = 0
-- Cubic.of_d_eq_zero'
theorem of_d_eq_zero' : (⟨0, 0, 0, 0⟩ : Cubic R).toPoly = 0 
Arguments: {R : Type u_1} [Semiring R]
Goal: { a := 0, b := 0, c := 0, d := 0 }.toPoly = 0
-- Cubic.zero
theorem zero : (0 : Cubic R).toPoly = 0 
Arguments: {R : Type u_1} [Semiring R]
Goal: Cubic.toPoly 0 = 0
-- Cubic.toPoly_eq_zero_iff
theorem toPoly_eq_zero_iff (P : Cubic R) : P.toPoly = 0 ↔ P = 0 
Arguments: {R : Type u_1} [Semiring R] (P : Cubic R)
Goal: P.toPoly = 0 ↔ P = 0
-- _private.Mathlib.Algebra.CubicDiscriminant.0.Cubic.ne_zero
private theorem ne_zero (h0 : P.a ≠ 0 ∨ P.b ≠ 0 ∨ P.c ≠ 0 ∨ P.d ≠ 0) : P.toPoly ≠ 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (h0 : P.a ≠ 0 ∨ P.b ≠ 0 ∨ P.c ≠ 0 ∨ P.d ≠ 0)
Goal: P.toPoly ≠ 0
-- Cubic.ne_zero_of_a_ne_zero
theorem ne_zero_of_a_ne_zero (ha : P.a ≠ 0) : P.toPoly ≠ 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a ≠ 0)
Goal: P.toPoly ≠ 0
-- Cubic.ne_zero_of_b_ne_zero
theorem ne_zero_of_b_ne_zero (hb : P.b ≠ 0) : P.toPoly ≠ 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (hb : P.b ≠ 0)
Goal: P.toPoly ≠ 0
-- Cubic.ne_zero_of_c_ne_zero
theorem ne_zero_of_c_ne_zero (hc : P.c ≠ 0) : P.toPoly ≠ 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (hc : P.c ≠ 0)
Goal: P.toPoly ≠ 0
-- Cubic.ne_zero_of_d_ne_zero
theorem ne_zero_of_d_ne_zero (hd : P.d ≠ 0) : P.toPoly ≠ 0 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (hd : P.d ≠ 0)
Goal: P.toPoly ≠ 0
-- Cubic.leadingCoeff_of_a_ne_zero
@[simp]
theorem leadingCoeff_of_a_ne_zero (ha : P.a ≠ 0) : P.toPoly.leadingCoeff = P.a 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a ≠ 0)
Goal: P.toPoly.leadingCoeff = P.a
-- Cubic.leadingCoeff_of_a_ne_zero'
@[simp]
theorem leadingCoeff_of_a_ne_zero' (ha : a ≠ 0) : (toPoly ⟨a, b, c, d⟩).leadingCoeff = a 
Arguments: {R : Type u_1} {a b c d : R} [Semiring R] (ha : a ≠ 0)
Goal: { a := a, b := b, c := c, d := d }.toPoly.leadingCoeff = a
-- Cubic.leadingCoeff_of_b_ne_zero
@[simp]
theorem leadingCoeff_of_b_ne_zero (ha : P.a = 0) (hb : P.b ≠ 0) : P.toPoly.leadingCoeff = P.b 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b ≠ 0)
Goal: P.toPoly.leadingCoeff = P.b
-- Cubic.leadingCoeff_of_b_ne_zero'
@[simp]
theorem leadingCoeff_of_b_ne_zero' (hb : b ≠ 0) : (toPoly ⟨0, b, c, d⟩).leadingCoeff = b 
Arguments: {R : Type u_1} {b c d : R} [Semiring R] (hb : b ≠ 0)
Goal: { a := 0, b := b, c := c, d := d }.toPoly.leadingCoeff = b
-- Cubic.leadingCoeff_of_c_ne_zero
@[simp]
theorem leadingCoeff_of_c_ne_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c ≠ 0) :
    P.toPoly.leadingCoeff = P.c 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 0) (hc : P.c ≠ 0)
Goal: P.toPoly.leadingCoeff = P.c
-- Cubic.leadingCoeff_of_c_ne_zero'
@[simp]
theorem leadingCoeff_of_c_ne_zero' (hc : c ≠ 0) : (toPoly ⟨0, 0, c, d⟩).leadingCoeff = c 
Arguments: {R : Type u_1} {c d : R} [Semiring R] (hc : c ≠ 0)
Goal: { a := 0, b := 0, c := c, d := d }.toPoly.leadingCoeff = c
-- Cubic.leadingCoeff_of_c_eq_zero
@[simp]
theorem leadingCoeff_of_c_eq_zero (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0) :
    P.toPoly.leadingCoeff = P.d 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 0)
Goal: P.toPoly.leadingCoeff = P.d
-- Cubic.leadingCoeff_of_c_eq_zero'
theorem leadingCoeff_of_c_eq_zero' : (toPoly ⟨0, 0, 0, d⟩).leadingCoeff = d 
Arguments: {R : Type u_1} {d : R} [Semiring R]
Goal: { a := 0, b := 0, c := 0, d := d }.toPoly.leadingCoeff = d
-- Cubic.monic_of_a_eq_one
theorem monic_of_a_eq_one (ha : P.a = 1) : P.toPoly.Monic 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 1)
Goal: P.toPoly.Monic
-- Cubic.monic_of_a_eq_one'
theorem monic_of_a_eq_one' : (toPoly ⟨1, b, c, d⟩).Monic 
Arguments: {R : Type u_1} {b c d : R} [Semiring R]
Goal: { a := 1, b := b, c := c, d := d }.toPoly.Monic
-- Cubic.monic_of_b_eq_one
theorem monic_of_b_eq_one (ha : P.a = 0) (hb : P.b = 1) : P.toPoly.Monic 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 1)
Goal: P.toPoly.Monic
-- Cubic.monic_of_b_eq_one'
theorem monic_of_b_eq_one' : (toPoly ⟨0, 1, c, d⟩).Monic 
Arguments: {R : Type u_1} {c d : R} [Semiring R]
Goal: { a := 0, b := 1, c := c, d := d }.toPoly.Monic
-- Cubic.monic_of_c_eq_one
theorem monic_of_c_eq_one (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 1) : P.toPoly.Monic 
Arguments: {R : Type u_1} {P : Cubic R} [Semiring R] (ha : P.a = 0) (hb : P.b = 0) (hc : P.c = 1)
Goal: P.toPoly.Monic