File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

full_name: tacticC_simp._@.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic._hyg.4
code: macro "C_simp" : tactic =>
  `(tactic| simp only [map_ofNat, C_0, C_1, C_neg, C_add, C_sub, C_mul, C_pow])
goal: Lean.ParserDescr

full_name: _aux_Mathlib_AlgebraicGeometry_EllipticCurve_DivisionPolynomial_Basic___macroRules_tacticC_simp_1
code: macro "C_simp" : tactic =>
  `(tactic| simp only [map_ofNat, C_0, C_1, C_neg, C_add, C_sub, C_mul, C_pow])
goal: Lean.Macro

full_name: tacticMap_simp._@.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic._hyg.423
code: macro "map_simp" : tactic =>
  `(tactic| simp only [map_ofNat, map_neg, map_add, map_sub, map_mul, map_pow, map_div₀,
    Polynomial.map_ofNat, Polynomial.map_one, map_C, map_X, Polynomial.map_neg, Polynomial.map_add,
    Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_pow, Polynomial.map_div, coe_mapRingHom,
    apply_ite <| mapRingHom _, WeierstrassCurve.map])
goal: Lean.ParserDescr

full_name: _aux_Mathlib_AlgebraicGeometry_EllipticCurve_DivisionPolynomial_Basic___macroRules_tacticMap_simp_1
code: macro "map_simp" : tactic =>
  `(tactic| simp only [map_ofNat, map_neg, map_add, map_sub, map_mul, map_pow, map_div₀,
    Polynomial.map_ofNat, Polynomial.map_one, map_C, map_X, Polynomial.map_neg, Polynomial.map_add,
    Polynomial.map_sub, Polynomial.map_mul, Polynomial.map_pow, Polynomial.map_div, coe_mapRingHom,
    apply_ite <| mapRingHom _, WeierstrassCurve.map])
goal: Lean.Macro

full_name: WeierstrassCurve.ψ₂
code: /-- The $2$-division polynomial $\psi_2 = \Psi_2$. -/
noncomputable def ψ₂ : R[X][Y] 
goal: R[X][Y]

full_name: WeierstrassCurve.Ψ₂Sq
code: /-- The univariate polynomial $\Psi_2^{[2]}$ congruent to $\psi_2^2$. -/
noncomputable def Ψ₂Sq : R[X] 
goal: R[X]

full_name: WeierstrassCurve.C_Ψ₂Sq
code: lemma C_Ψ₂Sq : C W.Ψ₂Sq = W.ψ₂ ^ 2 - 4 * W.toAffine.polynomial 
goal: Polynomial.C W.Ψ₂Sq = W.ψ₂ ^ 2 - 4 * W.toAffine.polynomial

full_name: WeierstrassCurve.ψ₂_sq
code: lemma ψ₂_sq : W.ψ₂ ^ 2 = C W.Ψ₂Sq + 4 * W.toAffine.polynomial 
goal: W.ψ₂ ^ 2 = Polynomial.C W.Ψ₂Sq + 4 * W.toAffine.polynomial

full_name: WeierstrassCurve.Affine.CoordinateRing.mk_ψ₂_sq
code: lemma Affine.CoordinateRing.mk_ψ₂_sq : mk W W.ψ₂ ^ 2 = mk W (C W.Ψ₂Sq) 
goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) W.ψ₂ ^ 2 =
  (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C W.Ψ₂Sq)

full_name: WeierstrassCurve.Ψ₂Sq_eq
code: lemma Ψ₂Sq_eq : W.Ψ₂Sq = W.twoTorsionPolynomial.toPoly 
goal: W.Ψ₂Sq = W.twoTorsionPolynomial.toPoly

full_name: WeierstrassCurve.Ψ₃
code: /-- The $3$-division polynomial $\psi_3 = \Psi_3$. -/
noncomputable def Ψ₃ : R[X] 
goal: R[X]

full_name: WeierstrassCurve.preΨ₄
code: /-- The univariate polynomial $\tilde{\Psi}_4$, which is auxiliary to the $4$-division polynomial
$\psi_4 = \Psi_4 = \tilde{\Psi}_4\psi_2$. -/
noncomputable def preΨ₄ : R[X] 
goal: R[X]

full_name: WeierstrassCurve.preΨ'
code: /-- The univariate polynomials $\tilde{\Psi}_n$ for $n \in \mathbb{N}$, which are auxiliary to the
bivariate polynomials $\Psi_n$ congruent to the bivariate $n$-division polynomials $\psi_n$. -/
noncomputable def preΨ' (n : ℕ) : R[X] 
goal: R[X]

full_name: WeierstrassCurve.preΨ'_zero
code: @[simp]
lemma preΨ'_zero : W.preΨ' 0 = 0 
goal: W.preΨ' 0 = 0

full_name: WeierstrassCurve.preΨ'_one
code: @[simp]
lemma preΨ'_one : W.preΨ' 1 = 1 
goal: W.preΨ' 1 = 1

full_name: WeierstrassCurve.preΨ'_two
code: @[simp]
lemma preΨ'_two : W.preΨ' 2 = 1 
goal: W.preΨ' 2 = 1

full_name: WeierstrassCurve.preΨ'_three
code: @[simp]
lemma preΨ'_three : W.preΨ' 3 = W.Ψ₃ 
goal: W.preΨ' 3 = W.Ψ₃

full_name: WeierstrassCurve.preΨ'_four
code: @[simp]
lemma preΨ'_four : W.preΨ' 4 = W.preΨ₄ 
goal: W.preΨ' 4 = W.preΨ₄

full_name: WeierstrassCurve.preΨ'_odd
code: lemma preΨ'_odd (m : ℕ) : W.preΨ' (2 * (m + 2) + 1) =
    W.preΨ' (m + 4) * W.preΨ' (m + 2) ^ 3 * (if Even m then W.Ψ₂Sq ^ 2 else 1) -
      W.preΨ' (m + 1) * W.preΨ' (m + 3) ^ 3 * (if Even m then 1 else W.Ψ₂Sq ^ 2) 
goal: W.preΨ' (2 * (m + 2) + 1) =
  (W.preΨ' (m + 4) * W.preΨ' (m + 2) ^ 3 * if Even m then W.Ψ₂Sq ^ 2 else 1) -
    W.preΨ' (m + 1) * W.preΨ' (m + 3) ^ 3 * if Even m then 1 else W.Ψ₂Sq ^ 2

full_name: WeierstrassCurve.preΨ'_even
code: lemma preΨ'_even (m : ℕ) : W.preΨ' (2 * (m + 3)) =
    W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) -
      W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2 
goal: W.preΨ' (2 * (m + 3)) =
  W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) - W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2

full_name: WeierstrassCurve.preΨ
code: /-- The univariate polynomials $\tilde{\Psi}_n$ for $n \in \mathbb{Z}$, which are auxiliary to the
bivariate polynomials $\Psi_n$ congruent to the bivariate $n$-division polynomials $\psi_n$. -/
noncomputable def preΨ (n : ℤ) : R[X] 
goal: R[X]

full_name: WeierstrassCurve.preΨ_ofNat
code: @[simp]
lemma preΨ_ofNat (n : ℕ) : W.preΨ n = W.preΨ' n 
goal: W.preΨ ↑n = W.preΨ' n

full_name: WeierstrassCurve.preΨ_zero
code: @[simp]
lemma preΨ_zero : W.preΨ 0 = 0 
goal: W.preΨ 0 = 0

full_name: WeierstrassCurve.preΨ_one
code: @[simp]
lemma preΨ_one : W.preΨ 1 = 1 
goal: W.preΨ 1 = 1

full_name: WeierstrassCurve.preΨ_two
code: @[simp]
lemma preΨ_two : W.preΨ 2 = 1 
goal: W.preΨ 2 = 1

full_name: WeierstrassCurve.preΨ_three
code: @[simp]
lemma preΨ_three : W.preΨ 3 = W.Ψ₃ 
goal: W.preΨ 3 = W.Ψ₃

full_name: WeierstrassCurve.preΨ_four
code: @[simp]
lemma preΨ_four : W.preΨ 4 = W.preΨ₄ 
goal: W.preΨ 4 = W.preΨ₄

full_name: WeierstrassCurve.preΨ_odd
code: lemma preΨ_odd (m : ℕ) : W.preΨ (2 * (m + 2) + 1) =
    W.preΨ (m + 4) * W.preΨ (m + 2) ^ 3 * (if Even m then W.Ψ₂Sq ^ 2 else 1) -
      W.preΨ (m + 1) * W.preΨ (m + 3) ^ 3 * (if Even m then 1 else W.Ψ₂Sq ^ 2) 
goal: W.preΨ (2 * (↑m + 2) + 1) =
  (W.preΨ (↑m + 4) * W.preΨ (↑m + 2) ^ 3 * if Even m then W.Ψ₂Sq ^ 2 else 1) -
    W.preΨ (↑m + 1) * W.preΨ (↑m + 3) ^ 3 * if Even m then 1 else W.Ψ₂Sq ^ 2

full_name: WeierstrassCurve.preΨ_even
code: lemma preΨ_even (m : ℕ) : W.preΨ (2 * (m + 3)) =
    W.preΨ (m + 2) ^ 2 * W.preΨ (m + 3) * W.preΨ (m + 5) -
      W.preΨ (m + 1) * W.preΨ (m + 3) * W.preΨ (m + 4) ^ 2 
goal: W.preΨ (2 * (↑m + 3)) =
  W.preΨ (↑m + 2) ^ 2 * W.preΨ (↑m + 3) * W.preΨ (↑m + 5) - W.preΨ (↑m + 1) * W.preΨ (↑m + 3) * W.preΨ (↑m + 4) ^ 2

full_name: WeierstrassCurve.preΨ_neg
code: @[simp]
lemma preΨ_neg (n : ℤ) : W.preΨ (-n) = -W.preΨ n 
goal: W.preΨ (-n) = -W.preΨ n

full_name: WeierstrassCurve.ΨSq
code: /-- The univariate polynomials $\Psi_n^{[2]}$ congruent to $\psi_n^2$. -/
noncomputable def ΨSq (n : ℤ) : R[X] 
goal: R[X]

full_name: WeierstrassCurve.ΨSq_ofNat
code: @[simp]
lemma ΨSq_ofNat (n : ℕ) : W.ΨSq n = W.preΨ' n ^ 2 * if Even n then W.Ψ₂Sq else 1 
goal: W.ΨSq ↑n = W.preΨ' n ^ 2 * if Even n then W.Ψ₂Sq else 1

full_name: WeierstrassCurve.ΨSq_zero
code: @[simp]
lemma ΨSq_zero : W.ΨSq 0 = 0 
goal: W.ΨSq 0 = 0

full_name: WeierstrassCurve.ΨSq_one
code: @[simp]
lemma ΨSq_one : W.ΨSq 1 = 1 
goal: W.ΨSq 1 = 1

full_name: WeierstrassCurve.ΨSq_two
code: @[simp]
lemma ΨSq_two : W.ΨSq 2 = W.Ψ₂Sq 
goal: W.ΨSq 2 = W.Ψ₂Sq

full_name: WeierstrassCurve.ΨSq_three
code: @[simp]
lemma ΨSq_three : W.ΨSq 3 = W.Ψ₃ ^ 2 
goal: W.ΨSq 3 = W.Ψ₃ ^ 2

full_name: WeierstrassCurve.ΨSq_four
code: @[simp]
lemma ΨSq_four : W.ΨSq 4 = W.preΨ₄ ^ 2 * W.Ψ₂Sq 
goal: W.ΨSq 4 = W.preΨ₄ ^ 2 * W.Ψ₂Sq

full_name: WeierstrassCurve.ΨSq_odd
code: lemma ΨSq_odd (m : ℕ) : W.ΨSq (2 * (m + 2) + 1) =
    (W.preΨ' (m + 4) * W.preΨ' (m + 2) ^ 3 * (if Even m then W.Ψ₂Sq ^ 2 else 1) -
      W.preΨ' (m + 1) * W.preΨ' (m + 3) ^ 3 * (if Even m then 1 else W.Ψ₂Sq ^ 2)) ^ 2 
goal: W.ΨSq (2 * (↑m + 2) + 1) =
  ((W.preΨ' (m + 4) * W.preΨ' (m + 2) ^ 3 * if Even m then W.Ψ₂Sq ^ 2 else 1) -
      W.preΨ' (m + 1) * W.preΨ' (m + 3) ^ 3 * if Even m then 1 else W.Ψ₂Sq ^ 2) ^
    2

full_name: WeierstrassCurve.ΨSq_even
code: lemma ΨSq_even (m : ℕ) : W.ΨSq (2 * (m + 3)) =
    (W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) -
      W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2) ^ 2 * W.Ψ₂Sq 
goal: W.ΨSq (2 * (↑m + 3)) =
  (W.preΨ' (m + 2) ^ 2 * W.preΨ' (m + 3) * W.preΨ' (m + 5) - W.preΨ' (m + 1) * W.preΨ' (m + 3) * W.preΨ' (m + 4) ^ 2) ^
      2 *
    W.Ψ₂Sq

full_name: WeierstrassCurve.ΨSq_neg
code: @[simp]
lemma ΨSq_neg (n : ℤ) : W.ΨSq (-n) = W.ΨSq n 
goal: W.ΨSq (-n) = W.ΨSq n

full_name: WeierstrassCurve.Ψ
code: /-- The bivariate polynomials $\Psi_n$ congruent to the $n$-division polynomials $\psi_n$. -/
protected noncomputable def Ψ (n : ℤ) : R[X][Y] 
goal: R[X][Y]

full_name: WeierstrassCurve.Ψ_ofNat
code: @[simp]
lemma Ψ_ofNat (n : ℕ) : W.Ψ n = C (W.preΨ' n) * if Even n then W.ψ₂ else 1 
goal: W.Ψ ↑n = Polynomial.C (W.preΨ' n) * if Even n then W.ψ₂ else 1

full_name: WeierstrassCurve.Ψ_zero
code: @[simp]
lemma Ψ_zero : W.Ψ 0 = 0 
goal: W.Ψ 0 = 0

full_name: WeierstrassCurve.Ψ_one
code: @[simp]
lemma Ψ_one : W.Ψ 1 = 1 
goal: W.Ψ 1 = 1

full_name: WeierstrassCurve.Ψ_two
code: @[simp]
lemma Ψ_two : W.Ψ 2 = W.ψ₂ 
goal: W.Ψ 2 = W.ψ₂

full_name: WeierstrassCurve.Ψ_three
code: @[simp]
lemma Ψ_three : W.Ψ 3 = C W.Ψ₃ 
goal: W.Ψ 3 = Polynomial.C W.Ψ₃

full_name: WeierstrassCurve.Ψ_four
code: @[simp]
lemma Ψ_four : W.Ψ 4 = C W.preΨ₄ * W.ψ₂ 
goal: W.Ψ 4 = Polynomial.C W.preΨ₄ * W.ψ₂

full_name: WeierstrassCurve.Ψ_odd
code: lemma Ψ_odd (m : ℕ) : W.Ψ (2 * (m + 2) + 1) =
    W.Ψ (m + 4) * W.Ψ (m + 2) ^ 3 - W.Ψ (m + 1) * W.Ψ (m + 3) ^ 3 +
      W.toAffine.polynomial * (16 * W.toAffine.polynomial - 8 * W.ψ₂ ^ 2) * C
        (if Even m then W.preΨ' (m + 4) * W.preΨ' (m + 2) ^ 3
          else -W.preΨ' (m + 1) * W.preΨ' (m + 3) ^ 3) 
goal: W.Ψ (2 * (↑m + 2) + 1) =
  W.Ψ (↑m + 4) * W.Ψ (↑m + 2) ^ 3 - W.Ψ (↑m + 1) * W.Ψ (↑m + 3) ^ 3 +
    W.toAffine.polynomial * (16 * W.toAffine.polynomial - 8 * W.ψ₂ ^ 2) *
      Polynomial.C (if Even m then W.preΨ' (m + 4) * W.preΨ' (m + 2) ^ 3 else -W.preΨ' (m + 1) * W.preΨ' (m + 3) ^ 3)

full_name: WeierstrassCurve.Ψ_even
code: lemma Ψ_even (m : ℕ) : W.Ψ (2 * (m + 3)) * W.ψ₂ =
    W.Ψ (m + 2) ^ 2 * W.Ψ (m + 3) * W.Ψ (m + 5) - W.Ψ (m + 1) * W.Ψ (m + 3) * W.Ψ (m + 4) ^ 2 
goal: W.Ψ (2 * (↑m + 3)) * W.ψ₂ =
  W.Ψ (↑m + 2) ^ 2 * W.Ψ (↑m + 3) * W.Ψ (↑m + 5) - W.Ψ (↑m + 1) * W.Ψ (↑m + 3) * W.Ψ (↑m + 4) ^ 2

full_name: WeierstrassCurve.Ψ_neg
code: @[simp]
lemma Ψ_neg (n : ℤ) : W.Ψ (-n) = -W.Ψ n 
goal: W.Ψ (-n) = -W.Ψ n

full_name: WeierstrassCurve.Affine.CoordinateRing.mk_Ψ_sq
code: lemma Affine.CoordinateRing.mk_Ψ_sq (n : ℤ) : mk W (W.Ψ n) ^ 2 = mk W (C <| W.ΨSq n) 
goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) (W.Ψ n) ^ 2 =
  (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C (W.ΨSq n))

full_name: WeierstrassCurve.Φ
code: /-- The univariate polynomials $\Phi_n$ congruent to $\phi_n$. -/
protected noncomputable def Φ (n : ℤ) : R[X] 
goal: R[X]

full_name: WeierstrassCurve.Φ_ofNat
code: @[simp]
lemma Φ_ofNat (n : ℕ) : W.Φ (n + 1) =
    X * W.preΨ' (n + 1) ^ 2 * (if Even n then 1 else W.Ψ₂Sq) -
      W.preΨ' (n + 2) * W.preΨ' n * (if Even n then W.Ψ₂Sq else 1) 
goal: W.Φ (↑n + 1) =
  (Polynomial.X * W.preΨ' (n + 1) ^ 2 * if Even n then 1 else W.Ψ₂Sq) -
    W.preΨ' (n + 2) * W.preΨ' n * if Even n then W.Ψ₂Sq else 1

full_name: WeierstrassCurve.Φ_zero
code: @[simp]
lemma Φ_zero : W.Φ 0 = 1 
goal: W.Φ 0 = 1

full_name: WeierstrassCurve.Φ_one
code: @[simp]
lemma Φ_one : W.Φ 1 = X 
goal: W.Φ 1 = Polynomial.X

full_name: WeierstrassCurve.Φ_two
code: @[simp]
lemma Φ_two : W.Φ 2 = X ^ 4 - C W.b₄ * X ^ 2 - C (2 * W.b₆) * X - C W.b₈ 
goal: W.Φ 2 =
  Polynomial.X ^ 4 - Polynomial.C W.b₄ * Polynomial.X ^ 2 - Polynomial.C (2 * W.b₆) * Polynomial.X - Polynomial.C W.b₈

full_name: WeierstrassCurve.Φ_three
code: @[simp]
lemma Φ_three : W.Φ 3 = X * W.Ψ₃ ^ 2 - W.preΨ₄ * W.Ψ₂Sq 
goal: W.Φ 3 = Polynomial.X * W.Ψ₃ ^ 2 - W.preΨ₄ * W.Ψ₂Sq

full_name: WeierstrassCurve.Φ_four
code: @[simp]
lemma Φ_four : W.Φ 4 = X * W.preΨ₄ ^ 2 * W.Ψ₂Sq - W.Ψ₃ * (W.preΨ₄ * W.Ψ₂Sq ^ 2 - W.Ψ₃ ^ 3) 
goal: W.Φ 4 = Polynomial.X * W.preΨ₄ ^ 2 * W.Ψ₂Sq - W.Ψ₃ * (W.preΨ₄ * W.Ψ₂Sq ^ 2 - W.Ψ₃ ^ 3)

full_name: WeierstrassCurve.Φ_neg
code: @[simp]
lemma Φ_neg (n : ℤ) : W.Φ (-n) = W.Φ n 
goal: W.Φ (-n) = W.Φ n

full_name: WeierstrassCurve.ψ
code: /-- The bivariate $n$-division polynomials $\psi_n$. -/
protected noncomputable def ψ (n : ℤ) : R[X][Y] 
goal: R[X][Y]

full_name: WeierstrassCurve.ψ_zero
code: @[simp]
lemma ψ_zero : W.ψ 0 = 0 
goal: W.ψ 0 = 0

full_name: WeierstrassCurve.ψ_one
code: @[simp]
lemma ψ_one : W.ψ 1 = 1 
goal: W.ψ 1 = 1

full_name: WeierstrassCurve.ψ_two
code: @[simp]
lemma ψ_two : W.ψ 2 = W.ψ₂ 
goal: W.ψ 2 = W.ψ₂

full_name: WeierstrassCurve.ψ_three
code: @[simp]
lemma ψ_three : W.ψ 3 = C W.Ψ₃ 
goal: W.ψ 3 = Polynomial.C W.Ψ₃

full_name: WeierstrassCurve.ψ_four
code: @[simp]
lemma ψ_four : W.ψ 4 = C W.preΨ₄ * W.ψ₂ 
goal: W.ψ 4 = Polynomial.C W.preΨ₄ * W.ψ₂

full_name: WeierstrassCurve.ψ_odd
code: lemma ψ_odd (m : ℕ) : W.ψ (2 * (m + 2) + 1) =
    W.ψ (m + 4) * W.ψ (m + 2) ^ 3 - W.ψ (m + 1) * W.ψ (m + 3) ^ 3 
goal: W.ψ (2 * (↑m + 2) + 1) = W.ψ (↑m + 4) * W.ψ (↑m + 2) ^ 3 - W.ψ (↑m + 1) * W.ψ (↑m + 3) ^ 3

full_name: WeierstrassCurve.ψ_even
code: lemma ψ_even (m : ℕ) : W.ψ (2 * (m + 3)) * W.ψ₂ =
    W.ψ (m + 2) ^ 2 * W.ψ (m + 3) * W.ψ (m + 5) - W.ψ (m + 1) * W.ψ (m + 3) * W.ψ (m + 4) ^ 2 
goal: W.ψ (2 * (↑m + 3)) * W.ψ₂ =
  W.ψ (↑m + 2) ^ 2 * W.ψ (↑m + 3) * W.ψ (↑m + 5) - W.ψ (↑m + 1) * W.ψ (↑m + 3) * W.ψ (↑m + 4) ^ 2

full_name: WeierstrassCurve.ψ_neg
code: @[simp]
lemma ψ_neg (n : ℤ) : W.ψ (-n) = -W.ψ n 
goal: W.ψ (-n) = -W.ψ n

full_name: WeierstrassCurve.Affine.CoordinateRing.mk_ψ
code: lemma Affine.CoordinateRing.mk_ψ (n : ℤ) : mk W (W.ψ n) = mk W (W.Ψ n) 
goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) (W.ψ n) = (WeierstrassCurve.Affine.CoordinateRing.mk W) (W.Ψ n)

full_name: WeierstrassCurve.φ
code: /-- The bivariate polynomials $\phi_n$. -/
protected noncomputable def φ (n : ℤ) : R[X][Y] 
goal: R[X][Y]

full_name: WeierstrassCurve.φ_zero
code: @[simp]
lemma φ_zero : W.φ 0 = 1 
goal: W.φ 0 = 1

full_name: WeierstrassCurve.φ_one
code: @[simp]
lemma φ_one : W.φ 1 = C X 
goal: W.φ 1 = Polynomial.C Polynomial.X

full_name: WeierstrassCurve.φ_two
code: @[simp]
lemma φ_two : W.φ 2 = C X * W.ψ₂ ^ 2 - C W.Ψ₃ 
goal: W.φ 2 = Polynomial.C Polynomial.X * W.ψ₂ ^ 2 - Polynomial.C W.Ψ₃

full_name: WeierstrassCurve.φ_three
code: @[simp]
lemma φ_three : W.φ 3 = C X * C W.Ψ₃ ^ 2 - C W.preΨ₄ * W.ψ₂ ^ 2 
goal: W.φ 3 = Polynomial.C Polynomial.X * Polynomial.C W.Ψ₃ ^ 2 - Polynomial.C W.preΨ₄ * W.ψ₂ ^ 2

full_name: WeierstrassCurve.φ_four
code: @[simp]
lemma φ_four :
    W.φ 4 = C X * C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 - C W.preΨ₄ * W.ψ₂ ^ 4 * C W.Ψ₃ + C W.Ψ₃ ^ 4 
goal: W.φ 4 =
  Polynomial.C Polynomial.X * Polynomial.C W.preΨ₄ ^ 2 * W.ψ₂ ^ 2 -
      Polynomial.C W.preΨ₄ * W.ψ₂ ^ 4 * Polynomial.C W.Ψ₃ +
    Polynomial.C W.Ψ₃ ^ 4

full_name: WeierstrassCurve.φ_neg
code: @[simp]
lemma φ_neg (n : ℤ) : W.φ (-n) = W.φ n 
goal: W.φ (-n) = W.φ n

full_name: WeierstrassCurve.Affine.CoordinateRing.mk_φ
code: lemma Affine.CoordinateRing.mk_φ (n : ℤ) : mk W (W.φ n) = mk W (C <| W.Φ n) 
goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) (W.φ n) =
  (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C (W.Φ n))

full_name: WeierstrassCurve.map_ψ₂
code: lemma map_ψ₂ : (W.map f).ψ₂ = W.ψ₂.map (mapRingHom f) 
goal: (W.map f).ψ₂ = Polynomial.map (Polynomial.mapRingHom f) W.ψ₂

full_name: WeierstrassCurve.map_Ψ₂Sq
code: lemma map_Ψ₂Sq : (W.map f).Ψ₂Sq = W.Ψ₂Sq.map f 
goal: (W.map f).Ψ₂Sq = Polynomial.map f W.Ψ₂Sq

full_name: WeierstrassCurve.map_Ψ₃
code: lemma map_Ψ₃ : (W.map f).Ψ₃ = W.Ψ₃.map f 
goal: (W.map f).Ψ₃ = Polynomial.map f W.Ψ₃

full_name: WeierstrassCurve.map_preΨ₄
code: lemma map_preΨ₄ : (W.map f).preΨ₄ = W.preΨ₄.map f 
goal: (W.map f).preΨ₄ = Polynomial.map f W.preΨ₄

full_name: WeierstrassCurve.map_preΨ'
code: lemma map_preΨ' (n : ℕ) : (W.map f).preΨ' n = (W.preΨ' n).map f 
goal: (W.map f).preΨ' n = Polynomial.map f (W.preΨ' n)

full_name: WeierstrassCurve.map_preΨ
code: lemma map_preΨ (n : ℤ) : (W.map f).preΨ n = (W.preΨ n).map f 
goal: (W.map f).preΨ n = Polynomial.map f (W.preΨ n)

full_name: WeierstrassCurve.map_ΨSq
code: lemma map_ΨSq (n : ℤ) : (W.map f).ΨSq n = (W.ΨSq n).map f 
goal: (W.map f).ΨSq n = Polynomial.map f (W.ΨSq n)

full_name: WeierstrassCurve.map_Ψ
code: lemma map_Ψ (n : ℤ) : (W.map f).Ψ n = (W.Ψ n).map (mapRingHom f) 
goal: (W.map f).Ψ n = Polynomial.map (Polynomial.mapRingHom f) (W.Ψ n)

full_name: WeierstrassCurve.map_Φ
code: lemma map_Φ (n : ℤ) : (W.map f).Φ n = (W.Φ n).map f 
goal: (W.map f).Φ n = Polynomial.map f (W.Φ n)

full_name: WeierstrassCurve.map_ψ
code: lemma map_ψ (n : ℤ) : (W.map f).ψ n = (W.ψ n).map (mapRingHom f) 
goal: (W.map f).ψ n = Polynomial.map (Polynomial.mapRingHom f) (W.ψ n)

full_name: WeierstrassCurve.map_φ
code: lemma map_φ (n : ℤ) : (W.map f).φ n = (W.φ n).map (mapRingHom f) 
goal: (W.map f).φ n = Polynomial.map (Polynomial.mapRingHom f) (W.φ n)

full_name: WeierstrassCurve.baseChange_ψ₂
code: lemma baseChange_ψ₂ : (W.baseChange B).ψ₂ = (W.baseChange A).ψ₂.map (mapRingHom f) 
goal: (W.baseChange B).ψ₂ = Polynomial.map (Polynomial.mapRingHom ↑f) (W.baseChange A).ψ₂

full_name: WeierstrassCurve.baseChange_Ψ₂Sq
code: lemma baseChange_Ψ₂Sq : (W.baseChange B).Ψ₂Sq = (W.baseChange A).Ψ₂Sq.map f 
goal: (W.baseChange B).Ψ₂Sq = Polynomial.map (↑f) (W.baseChange A).Ψ₂Sq

full_name: WeierstrassCurve.baseChange_Ψ₃
code: lemma baseChange_Ψ₃ : (W.baseChange B).Ψ₃ = (W.baseChange A).Ψ₃.map f 
goal: (W.baseChange B).Ψ₃ = Polynomial.map (↑f) (W.baseChange A).Ψ₃

full_name: WeierstrassCurve.baseChange_preΨ₄
code: lemma baseChange_preΨ₄ : (W.baseChange B).preΨ₄ = (W.baseChange A).preΨ₄.map f 
goal: (W.baseChange B).preΨ₄ = Polynomial.map (↑f) (W.baseChange A).preΨ₄

full_name: WeierstrassCurve.baseChange_preΨ'
code: lemma baseChange_preΨ' (n : ℕ) : (W.baseChange B).preΨ' n = ((W.baseChange A).preΨ' n).map f 
goal: (W.baseChange B).preΨ' n = Polynomial.map (↑f) ((W.baseChange A).preΨ' n)

full_name: WeierstrassCurve.baseChange_preΨ
code: lemma baseChange_preΨ (n : ℤ) : (W.baseChange B).preΨ n = ((W.baseChange A).preΨ n).map f 
goal: (W.baseChange B).preΨ n = Polynomial.map (↑f) ((W.baseChange A).preΨ n)

full_name: WeierstrassCurve.baseChange_ΨSq
code: lemma baseChange_ΨSq (n : ℤ) : (W.baseChange B).ΨSq n = ((W.baseChange A).ΨSq n).map f 
goal: (W.baseChange B).ΨSq n = Polynomial.map (↑f) ((W.baseChange A).ΨSq n)

full_name: WeierstrassCurve.baseChange_Ψ
code: lemma baseChange_Ψ (n : ℤ) : (W.baseChange B).Ψ n = ((W.baseChange A).Ψ n).map (mapRingHom f) 
goal: (W.baseChange B).Ψ n = Polynomial.map (Polynomial.mapRingHom ↑f) ((W.baseChange A).Ψ n)

full_name: WeierstrassCurve.baseChange_Φ
code: lemma baseChange_Φ (n : ℤ) : (W.baseChange B).Φ n = ((W.baseChange A).Φ n).map f 
goal: (W.baseChange B).Φ n = Polynomial.map (↑f) ((W.baseChange A).Φ n)

full_name: WeierstrassCurve.baseChange_ψ
code: lemma baseChange_ψ (n : ℤ) : (W.baseChange B).ψ n = ((W.baseChange A).ψ n).map (mapRingHom f) 
goal: (W.baseChange B).ψ n = Polynomial.map (Polynomial.mapRingHom ↑f) ((W.baseChange A).ψ n)

full_name: WeierstrassCurve.baseChange_φ
code: lemma baseChange_φ (n : ℤ) : (W.baseChange B).φ n = ((W.baseChange A).φ n).map (mapRingHom f) 
goal: (W.baseChange B).φ n = Polynomial.map (Polynomial.mapRingHom ↑f) ((W.baseChange A).φ n)