ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Pi.equivalenceOfEquiv_unitIso
@[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).unitIso =
  CategoryTheory.NatIso.pi' fun i' =>
    (CategoryTheory.Pi.eval (fun i => C (e i)) i').leftUnitor ≪≫
      (CategoryTheory.Pi.evalCompEqToEquivalenceFunctor (fun j => C (e j)) ⋯).symm ≪≫
        CategoryTheory.isoWhiskerLeft (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i')))
            (CategoryTheory.Pi.eqToEquivalenceFunctorIso C ⇑e ⋯).symm ≪≫
          (CategoryTheory.Functor.pi'CompEval (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i'))).comp
                (CategoryTheory.Pi.eqToEquivalence C ⋯).functor).symm ≪≫
            CategoryTheory.isoWhiskerLeft
                (CategoryTheory.Functor.pi' (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i'))).comp)
                (CategoryTheory.Functor.pi'CompEval (CategoryTheory.Pi.eval fun i => C (e i'))
                    (CategoryTheory.Pi.eqToEquivalence C ⋯).functor).symm ≪≫
              ((CategoryTheory.Functor.pi' (CategoryTheory.Pi.eval (fun j => C (e j)) (e.symm (e i'))).comp).associator
                  (CategoryTheory.Functor.pi' (CategoryTheory.Pi.eval fun i => C (e i')))
                  (CategoryTheory.Pi.eval (fun i => C (e i')) (CategoryTheory.Pi.eqToEquivalence C ⋯).functor)).symm
-- CategoryTheory.Pi.optionEquivalence_unitIso
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
Arguments: {J : Type w₁} (C' : Option J → Type u₁) [(i : Option J) → CategoryTheory.Category.{v₁, u₁} (C' i)]
Goal: (CategoryTheory.Pi.optionEquivalence C').unitIso =
  CategoryTheory.NatIso.pi' fun i =>
    match i with
    | none =>
      CategoryTheory.Iso.refl
        ((CategoryTheory.Functor.id ((i : Option J) → C' i)).comp (CategoryTheory.Pi.eval C' none))
    | some i =>
      CategoryTheory.Iso.refl
        ((CategoryTheory.Functor.id ((i : Option J) → C' i)).comp (CategoryTheory.Pi.eval C' (some i)))
-- CategoryTheory.Pi.optionEquivalence_functor
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
Arguments: {J : Type w₁} (C' : Option J → Type u₁) [(i : Option J) → CategoryTheory.Category.{v₁, u₁} (C' i)]
Goal: (CategoryTheory.Pi.optionEquivalence C').functor =
  (CategoryTheory.Pi.eval C' none).prod' (CategoryTheory.Functor.pi' fun i => CategoryTheory.Pi.eval C' (some i))
-- CategoryTheory.Pi.optionEquivalence_counitIso
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
Arguments: {J : Type w₁} (C' : Option J → Type u₁) [(i : Option J) → CategoryTheory.Category.{v₁, u₁} (C' i)]
Goal: (CategoryTheory.Pi.optionEquivalence C').counitIso =
  CategoryTheory.Iso.refl
    ((CategoryTheory.Functor.pi' fun i =>
          match i with
          | none => CategoryTheory.Prod.fst (C' none) ((j : J) → C' (some j))
          | some i =>
            (CategoryTheory.Prod.snd (C' none) ((j : J) → C' (some j))).comp
              (CategoryTheory.Pi.eval (fun j => C' (some j)) i)).comp
      ((CategoryTheory.Pi.eval C' none).prod' (CategoryTheory.Functor.pi' fun i => CategoryTheory.Pi.eval C' (some i))))
-- CategoryTheory.Pi.optionEquivalence_inverse
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j)) 
Arguments: {J : Type w₁} (C' : Option J → Type u₁) [(i : Option J) → CategoryTheory.Category.{v₁, u₁} (C' i)]
Goal: (CategoryTheory.Pi.optionEquivalence C').inverse =
  CategoryTheory.Functor.pi' fun i =>
    match i with
    | none => CategoryTheory.Prod.fst (C' none) ((j : J) → C' (some j))
    | some i =>
      (CategoryTheory.Prod.snd (C' none) ((j : J) → C' (some j))).comp (CategoryTheory.Pi.eval (fun j => C' (some j)) i)
-- CategoryTheory.Equivalence.pi_counitIso
@[simps]
def pi (E : ∀ 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)] (E : (i : I) → C i ≌ D i)
Goal: (CategoryTheory.Equivalence.pi E).counitIso = CategoryTheory.NatIso.pi fun i => (E i).counitIso
-- CategoryTheory.Equivalence.pi_functor
@[simps]
def pi (E : ∀ 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)] (E : (i : I) → C i ≌ D i)
Goal: (CategoryTheory.Equivalence.pi E).functor = CategoryTheory.Functor.pi fun i => (E i).functor
-- CategoryTheory.Equivalence.pi_unitIso
@[simps]
def pi (E : ∀ 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)] (E : (i : I) → C i ≌ D i)
Goal: (CategoryTheory.Equivalence.pi E).unitIso = CategoryTheory.NatIso.pi fun i => (E i).unitIso
-- CategoryTheory.Equivalence.pi_inverse
@[simps]
def pi (E : ∀ 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)] (E : (i : I) → C i ≌ D i)
Goal: (CategoryTheory.Equivalence.pi E).inverse = CategoryTheory.Functor.pi fun i => (E i).inverse
-- Polynomial.evalEval_C
lemma evalEval_C (x y : R) (p : R[X]) : (C p).evalEval x y = p.eval x 
Arguments: {R : Type u_1} [Semiring R] (x y : R) (p : R[X])
Goal: Polynomial.evalEval x y (Polynomial.C p) = Polynomial.eval x p
-- Polynomial.evalEval_X
lemma evalEval_X (x y : R) : X.evalEval x y = y 
Arguments: {R : Type u_1} [Semiring R] (x y : R)
Goal: Polynomial.evalEval x y Y = y
-- Polynomial.coe_algebraMap_eq_CC
lemma coe_algebraMap_eq_CC : algebraMap R R[X][Y] = CC (R := R) 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: ⇑(algebraMap R R[X][Y]) = Polynomial.CC
-- Polynomial.evalEvalRingHom_apply
@[simps!] abbrev evalEvalRingHom (x y : R) : R[X][Y] →+* R 
Arguments: {R : Type u_1} [CommSemiring R] (x y : R)
Goal: ∀ (a : R[X][Y]), (Polynomial.evalEvalRingHom x y) a = Polynomial.eval x (Polynomial.eval (Polynomial.C y) a)
-- Polynomial.coe_evalEvalRingHom
lemma coe_evalEvalRingHom (x y : R) : evalEvalRingHom x y = evalEval x y 
Arguments: {R : Type u_1} [CommSemiring R] (x y : R)
Goal: ⇑(Polynomial.evalEvalRingHom x y) = Polynomial.evalEval x y
-- Polynomial.evalEvalRingHom_eq
lemma evalEvalRingHom_eq (x : R) :
    evalEvalRingHom x = eval₂RingHom (evalRingHom x) 
Arguments: {R : Type u_1} [CommSemiring R] (x : R)
Goal: Polynomial.evalEvalRingHom x = Polynomial.eval₂RingHom (Polynomial.evalRingHom x)
-- Polynomial.eval₂_evalRingHom
lemma eval₂_evalRingHom (x : R) :
    eval₂ (evalRingHom x) = evalEval x 
Arguments: {R : Type u_1} [CommSemiring R] (x : R)
Goal: Polynomial.eval₂ (Polynomial.evalRingHom x) = Polynomial.evalEval x
-- Polynomial.map_evalRingHom_eval
lemma map_evalRingHom_eval (x y : R) (p : R[X][Y]) :
    (p.map <| evalRingHom x).eval y = p.evalEval x y 
Arguments: {R : Type u_1} [CommSemiring R] (x y : R) (p : R[X][Y])
Goal: Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p
-- Polynomial.map_mapRingHom_eval_map
lemma map_mapRingHom_eval_map : (p.map <| mapRingHom f).eval (q.map f) = (p.eval q).map f 
Arguments: {R : Type u_1} {S : Type u_2} [Semiring R] [Semiring S] (f : R →+* S) (p : R[X][Y]) (q : R[X])
Goal: Polynomial.eval (Polynomial.map f q) (Polynomial.map (Polynomial.mapRingHom f) p) =
  Polynomial.map f (Polynomial.eval q p)
-- Polynomial.map_mapRingHom_eval_map_eval
lemma map_mapRingHom_eval_map_eval (r : R) :
    ((p.map <| mapRingHom f).eval <| q.map f).eval (f r) = f ((p.eval q).eval r) 
Arguments: {R : Type u_1} {S : Type u_2} [Semiring R] [Semiring S] (f : R →+* S) (p : R[X][Y]) (q : R[X]) (r : R)
Goal: Polynomial.eval (f r) (Polynomial.eval (Polynomial.map f q) (Polynomial.map (Polynomial.mapRingHom f) p)) =
  f (Polynomial.eval r (Polynomial.eval q p))
-- Polynomial.map_mapRingHom_evalEval
lemma map_mapRingHom_evalEval (x y : R) :
    (p.map <| mapRingHom f).evalEval (f x) (f y) = f (p.evalEval x y) 
Arguments: {R : Type u_1} {S : Type u_2} [Semiring R] [Semiring S] (f : R →+* S) (p : R[X][Y]) (x y : R)
Goal: Polynomial.evalEval (f x) (f y) (Polynomial.map (Polynomial.mapRingHom f) p) = f (Polynomial.evalEval x y p)
-- Polynomial.eval₂RingHom_eval₂RingHom
lemma eval₂RingHom_eval₂RingHom (f : R →+* S) (x y : S) :
    eval₂RingHom (eval₂RingHom f x) y =
      (evalEvalRingHom x y).comp (mapRingHom <| mapRingHom f) 
Arguments: {R : Type u_1} {S : Type u_2} [CommSemiring R] [CommSemiring S] (f : R →+* S) (x y : S)
Goal: Polynomial.eval₂RingHom (Polynomial.eval₂RingHom f x) y =
  (Polynomial.evalEvalRingHom x y).comp (Polynomial.mapRingHom (Polynomial.mapRingHom f))
-- Polynomial.eval₂_eval₂RingHom_apply
lemma eval₂_eval₂RingHom_apply (f : R →+* S) (x y : S) (p : R[X][Y]) :
    eval₂ (eval₂RingHom f x) y p = (p.map <| mapRingHom f).evalEval x y 
Arguments: {R : Type u_1} {S : Type u_2} [CommSemiring R] [CommSemiring S] (f : R →+* S) (x y : S) (p : R[X][Y])
Goal: Polynomial.eval₂ (Polynomial.eval₂RingHom f x) y p =
  Polynomial.evalEval x y (Polynomial.map (Polynomial.mapRingHom f) p)
-- Polynomial.eval_C_X_comp_eval₂_map_C_X
lemma eval_C_X_comp_eval₂_map_C_X :
    (evalRingHom (C X : R[X][Y])).comp (eval₂RingHom (mapRingHom <| algebraMap R R[X][Y]) (C Y)) =
      .id _ 
Arguments: {R : Type u_1} [CommSemiring R]
Goal: (Polynomial.evalRingHom (Polynomial.C Polynomial.X)).comp
    (Polynomial.eval₂RingHom (Polynomial.mapRingHom (algebraMap R R[X][Y])) (Polynomial.C Y)) =
  RingHom.id R[X][Y]
-- Polynomial.eval_C_X_eval₂_map_C_X
lemma eval_C_X_eval₂_map_C_X {p : R[X][Y]} :
    eval (C X) (eval₂ (mapRingHom <| algebraMap R R[X][Y]) (C Y) p) = p 
Arguments: {R : Type u_1} [CommSemiring R] {p : R[X][Y]}
Goal: Polynomial.eval (Polynomial.C Polynomial.X)
    (Polynomial.eval₂ (Polynomial.mapRingHom (algebraMap R R[X][Y])) (Polynomial.C Y) p) =
  p
-- AdjoinRoot.evalEval_apply
@[simps!] def evalEval : AdjoinRoot p →+* R 
Arguments: {R : Type u_1} [CommRing R] {x y : R} {p : R[X][Y]} (h : Polynomial.evalEval x y p = 0)
Goal: ∀ (a : R[X][Y] ⧸ Submodule.toAddSubgroup (Ideal.span {p})),
  (AdjoinRoot.evalEval h) a =
    (QuotientAddGroup.lift (Submodule.toAddSubgroup (Ideal.span {p}))
        ↑(Polynomial.eval₂RingHom (Polynomial.evalRingHom x) y) ⋯)
      a
-- AdjoinRoot.evalEval_mk
lemma evalEval_mk (g : R[X][Y]) : evalEval h (mk p g) = g.evalEval x y 
Arguments: {R : Type u_1} [CommRing R] {x y : R} {p : R[X][Y]} (h : Polynomial.evalEval x y p = 0) (g : R[X][Y])
Goal: (AdjoinRoot.evalEval h) ((AdjoinRoot.mk p) g) = Polynomial.evalEval x y g
-- Polynomial.algebraMap_apply
@[simp]
theorem algebraMap_apply (r : R) : algebraMap R A[X] r = C (algebraMap R A r) 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (r : R)
Goal: (algebraMap R A[X]) r = Polynomial.C ((algebraMap R A) r)
-- Polynomial.toFinsupp_algebraMap
@[simp]
theorem toFinsupp_algebraMap (r : R) : (algebraMap R A[X] r).toFinsupp = algebraMap R _ r 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (r : R)
Goal: ((algebraMap R A[X]) r).toFinsupp = (algebraMap R (AddMonoidAlgebra A ℕ)) r
-- Polynomial.ofFinsupp_algebraMap
theorem ofFinsupp_algebraMap (r : R) : (⟨algebraMap R _ r⟩ : A[X]) = algebraMap R A[X] r 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (r : R)
Goal: { toFinsupp := (algebraMap R (AddMonoidAlgebra A ℕ)) r } = (algebraMap R A[X]) r
-- Polynomial.C_eq_algebraMap
theorem C_eq_algebraMap (r : R) : C r = algebraMap R R[X] r 
Arguments: {R : Type u} [CommSemiring R] (r : R)
Goal: Polynomial.C r = (algebraMap R R[X]) r
-- Polynomial.algebraMap_eq
@[simp]
theorem algebraMap_eq : algebraMap R R[X] = C 
Arguments: {R : Type u} [CommSemiring R]
Goal: algebraMap R R[X] = Polynomial.C
-- Polynomial.CAlgHom_apply
@[simps! apply]
def CAlgHom : A →ₐ[R] A[X] 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A]
Goal: ∀ (a : A), Polynomial.CAlgHom a = Polynomial.C a
-- Polynomial.algHom_ext'
@[ext 1100]
theorem algHom_ext' {f g : A[X] →ₐ[R] B}
    (hC : f.comp CAlgHom = g.comp CAlgHom)
    (hX : f X = g X) : f = g 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] {f g : A[X] →ₐ[R] B} (hC : f.comp Polynomial.CAlgHom = g.comp Polynomial.CAlgHom) (hX : f Polynomial.X = g Polynomial.X)
Goal: f = g
-- Polynomial.toFinsuppIsoAlg_symm_apply_toFinsupp
@[simps!]
def toFinsuppIsoAlg : R[X] ≃ₐ[R] R[ℕ] 
Arguments: (R : Type u) [CommSemiring R] (toFinsupp : AddMonoidAlgebra R ℕ)
Goal: ((Polynomial.toFinsuppIsoAlg R).symm toFinsupp).toFinsupp = toFinsupp
-- Polynomial.toFinsuppIsoAlg_apply
@[simps!]
def toFinsuppIsoAlg : R[X] ≃ₐ[R] R[ℕ] 
Arguments: (R : Type u) [CommSemiring R] (self : R[X])
Goal: (Polynomial.toFinsuppIsoAlg R) self = self.toFinsupp
-- Polynomial.algHom_eval₂_algebraMap
@[simp]
theorem algHom_eval₂_algebraMap {R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
    [Algebra R A] [Algebra R B] (p : R[X]) (f : A →ₐ[R] B) (a : A) :
    f (eval₂ (algebraMap R A) a p) = eval₂ (algebraMap R B) (f a) p 
Arguments: {R : Type u_3} {A : Type u_4} {B : Type u_5} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (p : R[X]) (f : A →ₐ[R] B) (a : A)
Goal: f (Polynomial.eval₂ (algebraMap R A) a p) = Polynomial.eval₂ (algebraMap R B) (f a) p
-- Polynomial.eval₂_algebraMap_X
@[simp]
theorem eval₂_algebraMap_X {R A : Type*} [CommSemiring R] [Semiring A] [Algebra R A] (p : R[X])
    (f : R[X] →ₐ[R] A) : eval₂ (algebraMap R A) (f X) p = f p 
Arguments: {R : Type u_3} {A : Type u_4} [CommSemiring R] [Semiring A] [Algebra R A] (p : R[X]) (f : R[X] →ₐ[R] A)
Goal: Polynomial.eval₂ (algebraMap R A) (f Polynomial.X) p = f p
-- Polynomial.ringHom_eval₂_intCastRingHom
@[simp]
theorem ringHom_eval₂_intCastRingHom {R S : Type*} [Ring R] [Ring S] (p : ℤ[X]) (f : R →+* S)
    (r : R) : f (eval₂ (Int.castRingHom R) r p) = eval₂ (Int.castRingHom S) (f r) p 
Arguments: {R : Type u_3} {S : Type u_4} [Ring R] [Ring S] (p : ℤ[X]) (f : R →+* S) (r : R)
Goal: f (Polynomial.eval₂ (Int.castRingHom R) r p) = Polynomial.eval₂ (Int.castRingHom S) (f r) p
-- Polynomial.eval₂_intCastRingHom_X
@[simp]
theorem eval₂_intCastRingHom_X {R : Type*} [Ring R] (p : ℤ[X]) (f : ℤ[X] →+* R) :
    eval₂ (Int.castRingHom R) (f X) p = f p 
Arguments: {R : Type u_3} [Ring R] (p : ℤ[X]) (f : ℤ[X] →+* R)
Goal: Polynomial.eval₂ (Int.castRingHom R) (f Polynomial.X) p = f p
-- Polynomial.eval₂AlgHom'_apply
@[simps!]
def eval₂AlgHom' (f : A →ₐ[R] B) (b : B) (hf : ∀ a, Commute (f a) b) : A[X] →ₐ[R] B 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B) (b : B) (hf : ∀ (a : A), Commute (f a) b) (p : A[X])
Goal: (Polynomial.eval₂AlgHom' f b hf) p = Polynomial.eval₂ (↑f) b p
-- Polynomial.coe_mapAlgHom
@[simp]
theorem coe_mapAlgHom (f : A →ₐ[R] B) : ⇑(mapAlgHom f) = map f 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B)
Goal: ⇑(Polynomial.mapAlgHom f) = Polynomial.map ↑f
-- Polynomial.mapAlgHom_id
@[simp]
theorem mapAlgHom_id : mapAlgHom (AlgHom.id R A) = AlgHom.id R (Polynomial A) 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A]
Goal: Polynomial.mapAlgHom (AlgHom.id R A) = AlgHom.id R A[X]
-- Polynomial.mapAlgHom_coe_ringHom
@[simp]
theorem mapAlgHom_coe_ringHom (f : A →ₐ[R] B) :
    ↑(mapAlgHom f : _ →ₐ[R] Polynomial B) = (mapRingHom ↑f : Polynomial A →+* Polynomial B) 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B)
Goal: ↑(Polynomial.mapAlgHom f) = Polynomial.mapRingHom ↑f
-- Polynomial.mapAlgHom_comp
@[simp]
theorem mapAlgHom_comp (C : Type z) [Semiring C] [Algebra R C] (f : B →ₐ[R] C) (g : A →ₐ[R] B) :
    (mapAlgHom f).comp (mapAlgHom g) = mapAlgHom (f.comp g) 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (C : Type z) [Semiring C] [Algebra R C] (f : B →ₐ[R] C) (g : A →ₐ[R] B)
Goal: (Polynomial.mapAlgHom f).comp (Polynomial.mapAlgHom g) = Polynomial.mapAlgHom (f.comp g)
-- Polynomial.mapAlgHom_eq_eval₂AlgHom'_CAlgHom
theorem mapAlgHom_eq_eval₂AlgHom'_CAlgHom (f : A →ₐ[R] B) : mapAlgHom f = eval₂AlgHom'
    (CAlgHom.comp f) X (fun a => (commute_X (C (f a))).symm) 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B)
Goal: Polynomial.mapAlgHom f = Polynomial.eval₂AlgHom' (Polynomial.CAlgHom.comp f) Polynomial.X ⋯
-- Polynomial.coe_mapAlgEquiv
@[simp]
theorem coe_mapAlgEquiv (f : A ≃ₐ[R] B) : ⇑(mapAlgEquiv f) = map f 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A ≃ₐ[R] B)
Goal: ⇑(Polynomial.mapAlgEquiv f) = Polynomial.map ↑f
-- Polynomial.mapAlgEquiv_id
@[simp]
theorem mapAlgEquiv_id : mapAlgEquiv (@AlgEquiv.refl R A _ _ _) = AlgEquiv.refl 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A]
Goal: Polynomial.mapAlgEquiv AlgEquiv.refl = AlgEquiv.refl
-- Polynomial.mapAlgEquiv_coe_ringHom
@[simp]
theorem mapAlgEquiv_coe_ringHom (f : A ≃ₐ[R] B) :
    ↑(mapAlgEquiv f : _ ≃ₐ[R] Polynomial B) = (mapRingHom ↑f : Polynomial A →+* Polynomial B) 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A ≃ₐ[R] B)
Goal: ↑(Polynomial.mapAlgEquiv f) = Polynomial.mapRingHom ↑f
-- Polynomial.mapAlgEquiv_comp
@[simp]
theorem mapAlgEquiv_comp (C : Type z) [Semiring C] [Algebra R C] (f : A ≃ₐ[R] B) (g : B ≃ₐ[R] C) :
    (mapAlgEquiv f).trans (mapAlgEquiv g) = mapAlgEquiv (f.trans g) 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (C : Type z) [Semiring C] [Algebra R C] (f : A ≃ₐ[R] B) (g : B ≃ₐ[R] C)
Goal: (Polynomial.mapAlgEquiv f).trans (Polynomial.mapAlgEquiv g) = Polynomial.mapAlgEquiv (f.trans g)
-- Polynomial.adjoin_X
@[simp]
theorem adjoin_X : Algebra.adjoin R ({X} : Set R[X]) = ⊤ 
Arguments: {R : Type u} [CommSemiring R]
Goal: Algebra.adjoin R {Polynomial.X} = ⊤
-- Polynomial.algHom_ext
@[ext 1200]
theorem algHom_ext {f g : R[X] →ₐ[R] B} (hX : f X = g X) :
    f = g 
Arguments: {R : Type u} {B : Type u_2} [CommSemiring R] [Semiring B] [Algebra R B] {f g : R[X] →ₐ[R] B} (hX : f Polynomial.X = g Polynomial.X)
Goal: f = g
-- Polynomial.aeval_def
theorem aeval_def (p : R[X]) : aeval x p = eval₂ (algebraMap R A) x p 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A) (p : R[X])
Goal: (Polynomial.aeval x) p = Polynomial.eval₂ (algebraMap R A) x p
-- Polynomial.aeval_zero
theorem aeval_zero : aeval x (0 : R[X]) = 0 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A)
Goal: (Polynomial.aeval x) 0 = 0
-- Polynomial.aeval_X
@[simp]
theorem aeval_X : aeval x (X : R[X]) = x 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A)
Goal: (Polynomial.aeval x) Polynomial.X = x
-- Polynomial.aeval_C
@[simp]
theorem aeval_C (r : R) : aeval x (C r) = algebraMap R A r 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A) (r : R)
Goal: (Polynomial.aeval x) (Polynomial.C r) = (algebraMap R A) r
-- Polynomial.aeval_monomial
@[simp]
theorem aeval_monomial {n : ℕ} {r : R} : aeval x (monomial n r) = algebraMap _ _ r * x ^ n 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A) {n : ℕ} {r : R}
Goal: (Polynomial.aeval x) ((Polynomial.monomial n) r) = (algebraMap R A) r * x ^ n
-- Polynomial.aeval_X_pow
theorem aeval_X_pow {n : ℕ} : aeval x ((X : R[X]) ^ n) = x ^ n 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A) {n : ℕ}
Goal: (Polynomial.aeval x) (Polynomial.X ^ n) = x ^ n
-- Polynomial.aeval_add
theorem aeval_add : aeval x (p + q) = aeval x p + aeval x q 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] {p q : R[X]} (x : A)
Goal: (Polynomial.aeval x) (p + q) = (Polynomial.aeval x) p + (Polynomial.aeval x) q
-- Polynomial.aeval_one
theorem aeval_one : aeval x (1 : R[X]) = 1 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A)
Goal: (Polynomial.aeval x) 1 = 1
-- Polynomial.aeval_natCast
theorem aeval_natCast (n : ℕ) : aeval x (n : R[X]) = n 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (x : A) (n : ℕ)
Goal: (Polynomial.aeval x) ↑n = ↑n
-- Polynomial.aeval_mul
theorem aeval_mul : aeval x (p * q) = aeval x p * aeval x q 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] {p q : R[X]} (x : A)
Goal: (Polynomial.aeval x) (p * q) = (Polynomial.aeval x) p * (Polynomial.aeval x) q
-- Polynomial.comp_eq_aeval
theorem comp_eq_aeval : p.comp q = aeval q p 
Arguments: {R : Type u} [CommSemiring R] {p q : R[X]}
Goal: p.comp q = (Polynomial.aeval q) p
-- Polynomial.aeval_comp
theorem aeval_comp {A : Type*} [Semiring A] [Algebra R A] (x : A) :
    aeval x (p.comp q) = aeval (aeval x q) p 
Arguments: {R : Type u} [CommSemiring R] {p q : R[X]} {A : Type u_3} [Semiring A] [Algebra R A] (x : A)
Goal: (Polynomial.aeval x) (p.comp q) = (Polynomial.aeval ((Polynomial.aeval x) q)) p
-- Polynomial.algEquivOfCompEqX_symm_apply
@[simps!]
def algEquivOfCompEqX (p q : R[X]) (hpq : p.comp q = X) (hqp : q.comp p = X) : R[X] ≃ₐ[R] R[X] 
Arguments: {R : Type u} [CommSemiring R] (p q : R[X]) (hpq : p.comp q = Polynomial.X) (hqp : q.comp p = Polynomial.X) (a : R[X])
Goal: (p.algEquivOfCompEqX q hpq hqp).symm a = (Polynomial.aeval q) a
-- Polynomial.algEquivOfCompEqX_apply
@[simps!]
def algEquivOfCompEqX (p q : R[X]) (hpq : p.comp q = X) (hqp : q.comp p = X) : R[X] ≃ₐ[R] R[X] 
Arguments: {R : Type u} [CommSemiring R] (p q : R[X]) (hpq : p.comp q = Polynomial.X) (hqp : q.comp p = Polynomial.X) (a : R[X])
Goal: (p.algEquivOfCompEqX q hpq hqp) a = (Polynomial.aeval p) a
-- Polynomial.algEquivAevalXAddC_symm_apply
@[simps!]
def algEquivAevalXAddC {R} [CommRing R] (t : R) : R[X] ≃ₐ[R] R[X] 
Arguments: {R : Type u_3} [CommRing R] (t : R) (a : R[X])
Goal: (Polynomial.algEquivAevalXAddC t).symm a = (Polynomial.aeval (Polynomial.X - Polynomial.C t)) a
-- Polynomial.algEquivAevalXAddC_apply
@[simps!]
def algEquivAevalXAddC {R} [CommRing R] (t : R) : R[X] ≃ₐ[R] R[X] 
Arguments: {R : Type u_3} [CommRing R] (t : R) (a : R[X])
Goal: (Polynomial.algEquivAevalXAddC t) a = (Polynomial.aeval (Polynomial.X + Polynomial.C t)) a
-- Polynomial.aeval_algHom
theorem aeval_algHom (f : A →ₐ[R] B) (x : A) : aeval (f x) = f.comp (aeval x) 
Arguments: {R : Type u} {A : Type z} {B : Type u_2} [CommSemiring R] [Semiring A] [Semiring B] [Algebra R A] [Algebra R B] (f : A →ₐ[R] B) (x : A)
Goal: Polynomial.aeval (f x) = f.comp (Polynomial.aeval x)
-- Polynomial.aeval_X_left
@[simp]
theorem aeval_X_left : aeval (X : R[X]) = AlgHom.id R R[X] 
Arguments: {R : Type u} [CommSemiring R]
Goal: Polynomial.aeval Polynomial.X = AlgHom.id R R[X]
-- Polynomial.aeval_X_left_apply
theorem aeval_X_left_apply (p : R[X]) : aeval X p = p 
Arguments: {R : Type u} [CommSemiring R] (p : R[X])
Goal: (Polynomial.aeval Polynomial.X) p = p
-- Polynomial.eval_unique
theorem eval_unique (φ : R[X] →ₐ[R] A) (p) : φ p = eval₂ (algebraMap R A) (φ X) p 
Arguments: {R : Type u} {A : Type z} [CommSemiring R] [Semiring A] [Algebra R A] (φ : R[X] →ₐ[R] A) (p : R[X])
Goal: φ p = Polynomial.eval₂ (algebraMap R A) (φ Polynomial.X) p