File: Mathlib/Algebra/Polynomial/Bivariate.lean

full_name: Polynomial._aux_Mathlib_Algebra_Polynomial_Bivariate___macroRules_Polynomial_termY_1
code: /-- The notation `Y` for `X` in the `Polynomial` scope. -/
scoped[Polynomial] notation3:max "Y" => Polynomial.X (R := Polynomial _)
goal: Lean.Macro

full_name: Polynomial.«_aux_Mathlib_Algebra_Polynomial_Bivariate___macroRules_Polynomial_term_[X][Y]_1»
code: /-- The notation `R[X][Y]` for `R[X][X]` in the `Polynomial` scope. -/
scoped[Polynomial] notation3:max R "[X][Y]" => Polynomial (Polynomial R)
goal: Lean.Macro

full_name: Polynomial.evalEval
code: /-- `evalEval x y p` is the evaluation `p(x,y)` of a two-variable polynomial `p : R[X][Y]`. -/
abbrev evalEval (x y : R) (p : R[X][Y]) : R 
goal: R

full_name: Polynomial.CC
code: /-- A constant viewed as a polynomial in two variables. -/
abbrev CC (r : R) : R[X][Y] 
goal: R[X][Y]

full_name: Polynomial.evalEval_C
code: lemma evalEval_C (x y : R) (p : R[X]) : (C p).evalEval x y = p.eval x 
goal: Polynomial.evalEval x y (Polynomial.C p) = Polynomial.eval x p

full_name: Polynomial.evalEval_X
code: lemma evalEval_X (x y : R) : X.evalEval x y = y 
goal: Polynomial.evalEval x y Y = y

full_name: Polynomial.coe_algebraMap_eq_CC
code: lemma coe_algebraMap_eq_CC : algebraMap R R[X][Y] = CC (R := R) 
goal: ⇑(algebraMap R R[X][Y]) = Polynomial.CC

full_name: Polynomial.evalEvalRingHom_apply
code: /-- `evalEval x y` as a ring homomorphism. -/
@[simps!] abbrev evalEvalRingHom (x y : R) : R[X][Y] →+* R 
goal: ∀ (a : R[X][Y]), (Polynomial.evalEvalRingHom x y) a = Polynomial.eval x (Polynomial.eval (Polynomial.C y) a)

full_name: Polynomial.evalEvalRingHom
code: /-- `evalEval x y` as a ring homomorphism. -/
@[simps!] abbrev evalEvalRingHom (x y : R) : R[X][Y] →+* R 
goal: R[X][Y] →+* R

full_name: Polynomial.coe_evalEvalRingHom
code: lemma coe_evalEvalRingHom (x y : R) : evalEvalRingHom x y = evalEval x y 
goal: ⇑(Polynomial.evalEvalRingHom x y) = Polynomial.evalEval x y

full_name: Polynomial.evalEvalRingHom_eq
code: lemma evalEvalRingHom_eq (x : R) :
    evalEvalRingHom x = eval₂RingHom (evalRingHom x) 
goal: Polynomial.evalEvalRingHom x = Polynomial.eval₂RingHom (Polynomial.evalRingHom x)

full_name: Polynomial.eval₂_evalRingHom
code: lemma eval₂_evalRingHom (x : R) :
    eval₂ (evalRingHom x) = evalEval x 
goal: Polynomial.eval₂ (Polynomial.evalRingHom x) = Polynomial.evalEval x

full_name: Polynomial.map_evalRingHom_eval
code: lemma map_evalRingHom_eval (x y : R) (p : R[X][Y]) :
    (p.map <| evalRingHom x).eval y = p.evalEval x y 
goal: Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p

full_name: Polynomial.map_mapRingHom_eval_map
code: lemma map_mapRingHom_eval_map : (p.map <| mapRingHom f).eval (q.map f) = (p.eval q).map f 
goal: Polynomial.eval (Polynomial.map f q) (Polynomial.map (Polynomial.mapRingHom f) p) =
  Polynomial.map f (Polynomial.eval q p)

full_name: Polynomial.map_mapRingHom_eval_map_eval
code: 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) 
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))

full_name: Polynomial.map_mapRingHom_evalEval
code: lemma map_mapRingHom_evalEval (x y : R) :
    (p.map <| mapRingHom f).evalEval (f x) (f y) = f (p.evalEval x y) 
goal: Polynomial.evalEval (f x) (f y) (Polynomial.map (Polynomial.mapRingHom f) p) = f (Polynomial.evalEval x y p)

full_name: Polynomial.eval₂RingHom_eval₂RingHom
code: /-- Two equivalent ways to express the evaluation of a bivariate polynomial over `R`
at a point in the affine plane over an `R`-algebra `S`. -/
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) 
goal: Polynomial.eval₂RingHom (Polynomial.eval₂RingHom f x) y =
  (Polynomial.evalEvalRingHom x y).comp (Polynomial.mapRingHom (Polynomial.mapRingHom f))

full_name: Polynomial.eval₂_eval₂RingHom_apply
code: 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 
goal: Polynomial.eval₂ (Polynomial.eval₂RingHom f x) y p =
  Polynomial.evalEval x y (Polynomial.map (Polynomial.mapRingHom f) p)

full_name: Polynomial.eval_C_X_comp_eval₂_map_C_X
code: 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 _ 
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]

full_name: Polynomial.eval_C_X_eval₂_map_C_X
code: /-- Viewing `R[X,Y,X']` as an `R[X']`-algebra, a polynomial `p : R[X',Y']` can be evaluated at
`Y : R[X,Y,X']` (substitution of `Y'` by `Y`), obtaining another polynomial in `R[X,Y,X']`.
When this polynomial is then evaluated at `X' = X`, the original polynomial `p` is recovered. -/
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 
goal: Polynomial.eval (Polynomial.C Polynomial.X)
    (Polynomial.eval₂ (Polynomial.mapRingHom (algebraMap R R[X][Y])) (Polynomial.C Y) p) =
  p

full_name: AdjoinRoot.evalEval
code: /-- If the evaluation (`evalEval`) of a bivariate polynomial `p : R[X][Y]` at a point (x,y)
is zero, then `Polynomial.evalEval x y` factors through `AdjoinRoot.evalEval`, a ring homomorphism
from `AdjoinRoot p` to `R`. -/
@[simps!] def evalEval : AdjoinRoot p →+* R 
goal: AdjoinRoot p →+* R

full_name: AdjoinRoot.evalEval_apply
code: /-- If the evaluation (`evalEval`) of a bivariate polynomial `p : R[X][Y]` at a point (x,y)
is zero, then `Polynomial.evalEval x y` factors through `AdjoinRoot.evalEval`, a ring homomorphism
from `AdjoinRoot p` to `R`. -/
@[simps!] def evalEval : AdjoinRoot p →+* R 
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

full_name: AdjoinRoot.evalEval_mk
code: lemma evalEval_mk (g : R[X][Y]) : evalEval h (mk p g) = g.evalEval x y 
goal: (AdjoinRoot.evalEval h) ((AdjoinRoot.mk p) g) = Polynomial.evalEval x y g