File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

full_name: tacticC_simp._@.Mathlib.AlgebraicGeometry.EllipticCurve.Group._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_Group___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: _aux_Mathlib_AlgebraicGeometry_EllipticCurve_Group___macroRules_tacticEval_simp_1
code: macro "eval_simp" : tactic =>
  `(tactic| simp only [eval_C, eval_X, eval_neg, eval_add, eval_sub, eval_mul, eval_pow])
goal: Lean.Macro

full_name: tacticEval_simp._@.Mathlib.AlgebraicGeometry.EllipticCurve.Group._hyg.419
code: macro "eval_simp" : tactic =>
  `(tactic| simp only [eval_C, eval_X, eval_neg, eval_add, eval_sub, eval_mul, eval_pow])
goal: Lean.ParserDescr

full_name: WeierstrassCurve.Affine.CoordinateRing
code: /-- The coordinate ring $R[W] := R[X, Y] / \langle W(X, Y) \rangle$ of `W`. -/
abbrev CoordinateRing : Type u 
goal: Type u

full_name: WeierstrassCurve.Affine.FunctionField
code: /-- The function field $R(W) := \mathrm{Frac}(R[W])$ of `W`. -/
abbrev FunctionField : Type u 
goal: Type u

full_name: WeierstrassCurve.Affine.CoordinateRing.instAlgebra
code: noncomputable instance : Algebra R W.CoordinateRing 
goal: Algebra R W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.instAlgebraPolynomial
code: noncomputable instance : Algebra R[X] W.CoordinateRing 
goal: Algebra R[X] W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.instIsScalarTowerPolynomial
code: instance : IsScalarTower R R[X] W.CoordinateRing 
goal: IsScalarTower R R[X] W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.instSubsingleton
code: instance [Subsingleton R] : Subsingleton W.CoordinateRing 
goal: Subsingleton W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.mk
code: /-- The natural ring homomorphism mapping an element of `R[X][Y]` to an element of `R[W]`. -/
noncomputable abbrev mk : R[X][Y] →+* W.CoordinateRing 
goal: R[X][Y] →+* W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.basis
code: /-- The basis $\{1, Y\}$ for the coordinate ring $R[W]$ over the polynomial ring $R[X]$. -/
protected noncomputable def basis : Basis (Fin 2) R[X] W.CoordinateRing 
goal: Basis (Fin 2) R[X] W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.basis_apply
code: lemma basis_apply (n : Fin 2) :
    CoordinateRing.basis W n = (AdjoinRoot.powerBasis' W.monic_polynomial).gen ^ (n : ℕ) 
goal: (WeierstrassCurve.Affine.CoordinateRing.basis W) n = (AdjoinRoot.powerBasis' ⋯).gen ^ ↑n

full_name: WeierstrassCurve.Affine.CoordinateRing.basis_zero
code: @[simp]
lemma basis_zero : CoordinateRing.basis W 0 = 1 
goal: (WeierstrassCurve.Affine.CoordinateRing.basis W) 0 = 1

full_name: WeierstrassCurve.Affine.CoordinateRing.basis_one
code: @[simp]
lemma basis_one : CoordinateRing.basis W 1 = mk W Y 
goal: (WeierstrassCurve.Affine.CoordinateRing.basis W) 1 = (WeierstrassCurve.Affine.CoordinateRing.mk W) Y

full_name: WeierstrassCurve.Affine.CoordinateRing.coe_basis
code: lemma coe_basis : (CoordinateRing.basis W : Fin 2 → W.CoordinateRing) = ![1, mk W Y] 
goal: ⇑(WeierstrassCurve.Affine.CoordinateRing.basis W) = ![1, (WeierstrassCurve.Affine.CoordinateRing.mk W) Y]

full_name: WeierstrassCurve.Affine.CoordinateRing.smul
code: lemma smul (x : R[X]) (y : W.CoordinateRing) : x • y = mk W (C x) * y 
goal: x • y = (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C x) * y

full_name: WeierstrassCurve.Affine.CoordinateRing.smul_basis_eq_zero
code: lemma smul_basis_eq_zero {p q : R[X]} (hpq : p • (1 : W.CoordinateRing) + q • mk W Y = 0) :
    p = 0 ∧ q = 0 
goal: p = 0 ∧ q = 0

full_name: WeierstrassCurve.Affine.CoordinateRing.exists_smul_basis_eq
code: lemma exists_smul_basis_eq (x : W.CoordinateRing) :
    ∃ p q : R[X], p • (1 : W.CoordinateRing) + q • mk W Y = x 
goal: ∃ p q, p • 1 + q • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y = x

full_name: WeierstrassCurve.Affine.CoordinateRing.smul_basis_mul_C
code: lemma smul_basis_mul_C (y : R[X]) (p q : R[X]) :
    (p • (1 : W.CoordinateRing) + q • mk W Y) * mk W (C y) =
      (p * y) • (1 : W.CoordinateRing) + (q * y) • mk W Y 
goal: (p • 1 + q • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y) *
    (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C y) =
  (p * y) • 1 + (q * y) • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y

full_name: WeierstrassCurve.Affine.CoordinateRing.smul_basis_mul_Y
code: lemma smul_basis_mul_Y (p q : R[X]) : (p • (1 : W.CoordinateRing) + q • mk W Y) * mk W Y =
    (q * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) • (1 : W.CoordinateRing) +
      (p - q * (C W.a₁ * X + C W.a₃)) • mk W Y 
goal: (p • 1 + q • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y) * (WeierstrassCurve.Affine.CoordinateRing.mk W) Y =
  (q *
        (Polynomial.X ^ 3 + Polynomial.C W.a₂ * Polynomial.X ^ 2 + Polynomial.C W.a₄ * Polynomial.X +
          Polynomial.C W.a₆)) •
      1 +
    (p - q * (Polynomial.C W.a₁ * Polynomial.X + Polynomial.C W.a₃)) • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y

full_name: WeierstrassCurve.Affine.CoordinateRing.map
code: /-- The ring homomorphism `R[W] →+* S[W.map f]` induced by a ring homomorphism `f : R →+* S`. -/
noncomputable def map : W.CoordinateRing →+* (W.map f).toAffine.CoordinateRing 
goal: W.CoordinateRing →+* (WeierstrassCurve.map W f).toAffine.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.map_mk
code: lemma map_mk (x : R[X][Y]) : map W f (mk W x) = mk (W.map f) (x.map <| mapRingHom f) 
goal: (WeierstrassCurve.Affine.CoordinateRing.map W f) ((WeierstrassCurve.Affine.CoordinateRing.mk W) x) =
  (WeierstrassCurve.Affine.CoordinateRing.mk (WeierstrassCurve.map W f)) (Polynomial.map (Polynomial.mapRingHom f) x)

full_name: WeierstrassCurve.Affine.CoordinateRing.map_smul
code: protected lemma map_smul (x : R[X]) (y : W.CoordinateRing) :
    map W f (x • y) = x.map f • map W f y 
goal: (WeierstrassCurve.Affine.CoordinateRing.map W f) (x • y) =
  Polynomial.map f x • (WeierstrassCurve.Affine.CoordinateRing.map W f) y

full_name: WeierstrassCurve.Affine.CoordinateRing.map_injective
code: lemma map_injective (hf : Function.Injective f) : Function.Injective <| map W f 
goal: Function.Injective ⇑(WeierstrassCurve.Affine.CoordinateRing.map W f)

full_name: WeierstrassCurve.Affine.CoordinateRing.instIsDomain
code: instance [IsDomain R] : IsDomain W.CoordinateRing 
goal: IsDomain W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.XClass
code: /-- The class of the element $X - x$ in $R[W]$ for some $x \in R$. -/
noncomputable def XClass (x : R) : W.CoordinateRing 
goal: W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.XClass_ne_zero
code: lemma XClass_ne_zero [Nontrivial R] (x : R) : XClass W x ≠ 0 
goal: WeierstrassCurve.Affine.CoordinateRing.XClass W x ≠ 0

full_name: WeierstrassCurve.Affine.CoordinateRing.YClass
code: /-- The class of the element $Y - y(X)$ in $R[W]$ for some $y(X) \in R[X]$. -/
noncomputable def YClass (y : R[X]) : W.CoordinateRing 
goal: W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.YClass_ne_zero
code: lemma YClass_ne_zero [Nontrivial R] (y : R[X]) : YClass W y ≠ 0 
goal: WeierstrassCurve.Affine.CoordinateRing.YClass W y ≠ 0

full_name: WeierstrassCurve.Affine.CoordinateRing.C_addPolynomial
code: lemma C_addPolynomial (x y L : R) : mk W (C <| W.addPolynomial x y L) =
    mk W ((Y - C (linePolynomial x y L)) * (W.negPolynomial - C (linePolynomial x y L))) 
goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C (W.addPolynomial x y L)) =
  (WeierstrassCurve.Affine.CoordinateRing.mk W)
    ((Y - Polynomial.C (WeierstrassCurve.Affine.linePolynomial x y L)) *
      (W.negPolynomial - Polynomial.C (WeierstrassCurve.Affine.linePolynomial x y L)))

full_name: WeierstrassCurve.Affine.CoordinateRing.XIdeal
code: /-- The ideal $\langle X - x \rangle$ of $R[W]$ for some $x \in R$. -/
noncomputable def XIdeal (x : R) : Ideal W.CoordinateRing 
goal: Ideal W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.YIdeal
code: /-- The ideal $\langle Y - y(X) \rangle$ of $R[W]$ for some $y(X) \in R[X]$. -/
noncomputable def YIdeal (y : R[X]) : Ideal W.CoordinateRing 
goal: Ideal W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal
code: /-- The ideal $\langle X - x, Y - y(X) \rangle$ of $R[W]$ for some $x \in R$ and $y(X) \in R[X]$. -/
noncomputable def XYIdeal (x : R) (y : R[X]) : Ideal W.CoordinateRing 
goal: Ideal W.CoordinateRing

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal_eq₁
code: lemma XYIdeal_eq₁ (x y L : R) : XYIdeal W x (C y) = XYIdeal W x (linePolynomial x y L) 
goal: WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (Polynomial.C y) =
  WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (WeierstrassCurve.Affine.linePolynomial x y L)

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal_add_eq
code: lemma XYIdeal_add_eq (x₁ x₂ y₁ L : R) : XYIdeal W (W.addX x₁ x₂ L) (C <| W.addY x₁ x₂ y₁ L) =
    span {mk W <| W.negPolynomial - C (linePolynomial x₁ y₁ L)} ⊔ XIdeal W (W.addX x₁ x₂ L) 
goal: WeierstrassCurve.Affine.CoordinateRing.XYIdeal W (W.addX x₁ x₂ L) (Polynomial.C (W.addY x₁ x₂ y₁ L)) =
  Ideal.span
      {(WeierstrassCurve.Affine.CoordinateRing.mk W)
          (W.negPolynomial - Polynomial.C (WeierstrassCurve.Affine.linePolynomial x₁ y₁ L))} ⊔
    WeierstrassCurve.Affine.CoordinateRing.XIdeal W (W.addX x₁ x₂ L)

full_name: WeierstrassCurve.Affine.CoordinateRing.quotientXYIdealEquiv
code: /-- The $R$-algebra isomorphism from $R[W] / \langle X - x, Y - y(X) \rangle$ to $R$ obtained by
evaluation at $y(X)$ and at $x$ provided that $W(x, y(x)) = 0$. -/
noncomputable def quotientXYIdealEquiv {x : R} {y : R[X]} (h : (W.polynomial.eval y).eval x = 0) :
    (W.CoordinateRing ⧸ XYIdeal W x y) ≃ₐ[R] R 
goal: (W.CoordinateRing ⧸ WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x y) ≃ₐ[R] R

full_name: WeierstrassCurve.Affine.CoordinateRing.C_addPolynomial_slope
code: lemma C_addPolynomial_slope {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁) (h₂ : W.Equation x₂ y₂)
    (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) : mk W (C <| W.addPolynomial x₁ y₁ <| W.slope x₁ x₂ y₁ y₂) =
      -(XClass W x₁ * XClass W x₂ * XClass W (W.addX x₁ x₂ <| W.slope x₁ x₂ y₁ y₂)) 
goal: (WeierstrassCurve.Affine.CoordinateRing.mk W) (Polynomial.C (W.addPolynomial x₁ y₁ (W.slope x₁ x₂ y₁ y₂))) =
  -(WeierstrassCurve.Affine.CoordinateRing.XClass W x₁ * WeierstrassCurve.Affine.CoordinateRing.XClass W x₂ *
      WeierstrassCurve.Affine.CoordinateRing.XClass W (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)))

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal_eq₂
code: lemma XYIdeal_eq₂ {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁)
    (h₂ : W.Equation x₂ y₂) (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) :
    XYIdeal W x₂ (C y₂) = XYIdeal W x₂ (linePolynomial x₁ y₁ <| W.slope x₁ x₂ y₁ y₂) 
goal: WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x₂ (Polynomial.C y₂) =
  WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x₂
    (WeierstrassCurve.Affine.linePolynomial x₁ y₁ (W.slope x₁ x₂ y₁ y₂))

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal_neg_mul
code: lemma XYIdeal_neg_mul {x y : F} (h : W.Nonsingular x y) :
    XYIdeal W x (C <| W.negY x y) * XYIdeal W x (C y) = XIdeal W x 
goal: WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (Polynomial.C (W.negY x y)) *
    WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (Polynomial.C y) =
  WeierstrassCurve.Affine.CoordinateRing.XIdeal W x

full_name: _private.Mathlib.AlgebraicGeometry.EllipticCurve.Group.0.WeierstrassCurve.Affine.CoordinateRing.XYIdeal'_mul_inv
code: private lemma XYIdeal'_mul_inv {x y : F} (h : W.Nonsingular x y) :
    XYIdeal W x (C y) * (XYIdeal W x (C <| W.negY x y) *
        (XIdeal W x : FractionalIdeal W.CoordinateRing⁰ W.FunctionField)⁻¹) = 1 
goal: ↑(WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (Polynomial.C y)) *
    (↑(WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (Polynomial.C (W.negY x y))) *
      (↑(WeierstrassCurve.Affine.CoordinateRing.XIdeal W x))⁻¹) =
  1

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal_mul_XYIdeal
code: lemma XYIdeal_mul_XYIdeal {x₁ x₂ y₁ y₂ : F} (h₁ : W.Equation x₁ y₁) (h₂ : W.Equation x₂ y₂)
    (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) :
    XIdeal W (W.addX x₁ x₂ <| W.slope x₁ x₂ y₁ y₂) * (XYIdeal W x₁ (C y₁) * XYIdeal W x₂ (C y₂)) =
      YIdeal W (linePolynomial x₁ y₁ <| W.slope x₁ x₂ y₁ y₂) *
        XYIdeal W (W.addX x₁ x₂ <| W.slope x₁ x₂ y₁ y₂)
          (C <| W.addY x₁ x₂ y₁ <| W.slope x₁ x₂ y₁ y₂) 
goal: WeierstrassCurve.Affine.CoordinateRing.XIdeal W (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) *
    (WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x₁ (Polynomial.C y₁) *
      WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x₂ (Polynomial.C y₂)) =
  WeierstrassCurve.Affine.CoordinateRing.YIdeal W (WeierstrassCurve.Affine.linePolynomial x₁ y₁ (W.slope x₁ x₂ y₁ y₂)) *
    WeierstrassCurve.Affine.CoordinateRing.XYIdeal W (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))
      (Polynomial.C (W.addY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂)))

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal'
code: /-- The non-zero fractional ideal $\langle X - x, Y - y \rangle$ of $F(W)$ for some $x, y \in F$. -/
noncomputable def XYIdeal' {x y : F} (h : W.Nonsingular x y) :
    (FractionalIdeal W.CoordinateRing⁰ W.FunctionField)ˣ 
goal: (FractionalIdeal W.CoordinateRing⁰ W.FunctionField)ˣ

full_name: WeierstrassCurve.Affine.CoordinateRing.XYIdeal'_eq
code: lemma XYIdeal'_eq {x y : F} (h : W.Nonsingular x y) :
    (XYIdeal' h : FractionalIdeal W.CoordinateRing⁰ W.FunctionField) = XYIdeal W x (C y) 
goal: ↑(WeierstrassCurve.Affine.CoordinateRing.XYIdeal' h) =
  ↑(WeierstrassCurve.Affine.CoordinateRing.XYIdeal W x (Polynomial.C y))

full_name: WeierstrassCurve.Affine.CoordinateRing.mk_XYIdeal'_mul_mk_XYIdeal'_of_Yeq
code: lemma mk_XYIdeal'_mul_mk_XYIdeal'_of_Yeq {x y : F} (h : W.Nonsingular x y) :
    ClassGroup.mk (XYIdeal' <| nonsingular_neg h) * ClassGroup.mk (XYIdeal' h) = 1 
goal: ClassGroup.mk (WeierstrassCurve.Affine.CoordinateRing.XYIdeal' ⋯) *
    ClassGroup.mk (WeierstrassCurve.Affine.CoordinateRing.XYIdeal' h) =
  1

full_name: WeierstrassCurve.Affine.CoordinateRing.mk_XYIdeal'_mul_mk_XYIdeal'
code: lemma mk_XYIdeal'_mul_mk_XYIdeal' {x₁ x₂ y₁ y₂ : F} (h₁ : W.Nonsingular x₁ y₁)
    (h₂ : W.Nonsingular x₂ y₂) (hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂) :
    ClassGroup.mk (XYIdeal' h₁) * ClassGroup.mk (XYIdeal' h₂) =
      ClassGroup.mk (XYIdeal' <| nonsingular_add h₁ h₂ hxy) 
goal: ClassGroup.mk (WeierstrassCurve.Affine.CoordinateRing.XYIdeal' h₁) *
    ClassGroup.mk (WeierstrassCurve.Affine.CoordinateRing.XYIdeal' h₂) =
  ClassGroup.mk (WeierstrassCurve.Affine.CoordinateRing.XYIdeal' ⋯)

full_name: WeierstrassCurve.Affine.CoordinateRing.norm_smul_basis
code: lemma norm_smul_basis (p q : R[X]) :
    Algebra.norm R[X] (p • (1 : W.CoordinateRing) + q • mk W Y) =
      p ^ 2 - p * q * (C W.a₁ * X + C W.a₃) -
        q ^ 2 * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆) 
goal: (Algebra.norm R[X]) (p • 1 + q • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y) =
  p ^ 2 - p * q * (Polynomial.C W.a₁ * Polynomial.X + Polynomial.C W.a₃) -
    q ^ 2 *
      (Polynomial.X ^ 3 + Polynomial.C W.a₂ * Polynomial.X ^ 2 + Polynomial.C W.a₄ * Polynomial.X + Polynomial.C W.a₆)

full_name: WeierstrassCurve.Affine.CoordinateRing.coe_norm_smul_basis
code: lemma coe_norm_smul_basis (p q : R[X]) :
    Algebra.norm R[X] (p • (1 : W.CoordinateRing) + q • mk W Y) =
      mk W ((C p + C q * X) * (C p + C q * (-(Y : R[X][Y]) - C (C W.a₁ * X + C W.a₃)))) 
goal: (AdjoinRoot.of W.polynomial) ((Algebra.norm R[X]) (p • 1 + q • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y)) =
  (WeierstrassCurve.Affine.CoordinateRing.mk W)
    ((Polynomial.C p + Polynomial.C q * Y) *
      (Polynomial.C p + Polynomial.C q * (-Y - Polynomial.C (Polynomial.C W.a₁ * Polynomial.X + Polynomial.C W.a₃))))

full_name: WeierstrassCurve.Affine.CoordinateRing.degree_norm_smul_basis
code: lemma degree_norm_smul_basis [IsDomain R] (p q : R[X]) :
    (Algebra.norm R[X] <| p • (1 : W.CoordinateRing) + q • mk W Y).degree =
      max (2 • p.degree) (2 • q.degree + 3) 
goal: ((Algebra.norm R[X]) (p • 1 + q • (WeierstrassCurve.Affine.CoordinateRing.mk W) Y)).degree =
  max (2 • p.degree) (2 • q.degree + 3)

full_name: WeierstrassCurve.Affine.CoordinateRing.degree_norm_ne_one
code: lemma degree_norm_ne_one [IsDomain R] (x : W.CoordinateRing) :
    (Algebra.norm R[X] x).degree ≠ 1 
goal: ((Algebra.norm R[X]) x).degree ≠ 1

full_name: WeierstrassCurve.Affine.CoordinateRing.natDegree_norm_ne_one
code: lemma natDegree_norm_ne_one [IsDomain R] (x : W.CoordinateRing) :
    (Algebra.norm R[X] x).natDegree ≠ 1 
goal: ((Algebra.norm R[X]) x).natDegree ≠ 1

full_name: WeierstrassCurve.Affine.Point.toClassFun
code: /-- The set function mapping an affine point $(x, y)$ of `W` to the class of the non-zero fractional
ideal $\langle X - x, Y - y \rangle$ of $F(W)$ in the class group of $F[W]$. -/
@[simp]
noncomputable def toClassFun : W.Point → Additive (ClassGroup W.CoordinateRing)
  
goal: W.Point → Additive (ClassGroup W.CoordinateRing)

full_name: WeierstrassCurve.Affine.Point.toClass_apply
code: /-- The group homomorphism mapping an affine point $(x, y)$ of `W` to the class of the non-zero
fractional ideal $\langle X - x, Y - y \rangle$ of $F(W)$ in the class group of $F[W]$. -/
@[simps]
noncomputable def toClass : W.Point →+ Additive (ClassGroup W.CoordinateRing) 
goal: ∀ (a : W.Point), WeierstrassCurve.Affine.Point.toClass a = a.toClassFun

full_name: WeierstrassCurve.Affine.Point.toClass
code: /-- The group homomorphism mapping an affine point $(x, y)$ of `W` to the class of the non-zero
fractional ideal $\langle X - x, Y - y \rangle$ of $F(W)$ in the class group of $F[W]$. -/
@[simps]
noncomputable def toClass : W.Point →+ Additive (ClassGroup W.CoordinateRing) 
goal: W.Point →+ Additive (ClassGroup W.CoordinateRing)

full_name: WeierstrassCurve.Affine.Point.toClass_zero
code: lemma toClass_zero : toClass (0 : W.Point) = 0 
goal: WeierstrassCurve.Affine.Point.toClass 0 = 0

full_name: WeierstrassCurve.Affine.Point.toClass_some
code: lemma toClass_some {x y : F} (h : W.Nonsingular x y) :
    toClass (some h) = ClassGroup.mk (CoordinateRing.XYIdeal' h) 
goal: WeierstrassCurve.Affine.Point.toClass (WeierstrassCurve.Affine.Point.some h) =
  ClassGroup.mk (WeierstrassCurve.Affine.CoordinateRing.XYIdeal' h)

full_name: _private.Mathlib.AlgebraicGeometry.EllipticCurve.Group.0.WeierstrassCurve.Affine.Point.add_eq_zero
code: private lemma add_eq_zero (P Q : W.Point) : P + Q = 0 ↔ P = -Q 
goal: P + Q = 0 ↔ P = -Q

full_name: WeierstrassCurve.Affine.Point.toClass_eq_zero
code: lemma toClass_eq_zero (P : W.Point) : toClass P = 0 ↔ P = 0 
goal: WeierstrassCurve.Affine.Point.toClass P = 0 ↔ P = 0

full_name: WeierstrassCurve.Affine.Point.toClass_injective
code: lemma toClass_injective : Function.Injective <| @toClass _ _ W 
goal: Function.Injective ⇑WeierstrassCurve.Affine.Point.toClass

full_name: WeierstrassCurve.Affine.Point.instAddCommGroup
code: noncomputable instance : AddCommGroup W.Point 
goal: AddCommGroup W.Point

full_name: WeierstrassCurve.Jacobian.Point.instAddCommGroup
code: noncomputable instance : AddCommGroup W.Point 
goal: AddCommGroup W.Point

full_name: EllipticCurve.Affine.Point.mk
code: /-- An affine point on an elliptic curve `E` over `R`. -/
def mk {x y : R} (h : E.toAffine.Equation x y) : E.toAffine.Point 
goal: E.toAffine.Point