addition -- addition of smooth points on a curve of genus 1

Synopsis

Usage:

L = addition(o,p,q,C)

I = addition(oC, pC, qC)
Inputs:
- o, a list,
- oC, an ideal,
- p, a list,
- pC, an ideal,
- q, a list,
- qC, an ideal,
- C, a ring,
Optional inputs:
- Conductor => ..., default value null
Outputs:
- L, a list,
- I, an ideal,

Description

If E is an irreducible plane curve of degree 3 then the set of smooth points of C is a principal homogeneous space under the group Pic_0 E of invertible sheaves of degree 0. Thus if we choose a smooth point o the map p -> O_E(p-o) identifies the set of smooth points with such invertible sheaves.

This script computes the sum of smooth points p,q with respect to the group law in which o is the zero point, where the group operation makes p+q = r if, as divisors, r is linearly equivalent to p+q-o. The functions addition and negative, based on linearSeries, allow us to implement the group law.

The points o,p,q may be represented either by their homogeneous coordinates or by ideal in the ring E. The functions fromCoordinates and toCoordinates pass between these two representations.

Here is an example with a smooth plane cubic:

i1 : kk = QQ

o1 = QQ

o1 : Ring

i2 : S = kk[x,y,z]

o2 = S

o2 : PolynomialRing

i3 : p = {0,1,0}; pS = fromCoordinates(p,S)

o4 = ideal (x, z)

o4 : Ideal of S

i5 : q = {1,0,0}; qS = fromCoordinates(q,S)

o6 = ideal (y, z)

o6 : Ideal of S

i7 : o = {1,1,1}; oS = fromCoordinates(o,S)

o8 = ideal (- x + y, - x + z)

o8 : Ideal of S

i9 : I = ideal random(3, intersect(oS, pS, qS))

           3 2    3   2   1 2    29        1 2    23   2   19 3
o9 = ideal(-x y + -x*y  + -x z + --x*y*z + -y z - --x*z  - --z )
           2      4       2       4        2       4        4

o9 : Ideal of S

i10 : E = S/I

o10 = E

o10 : QuotientRing

i11 : r = addition(o,p,q, E)

o11 = {1, 196, 66}

o11 : List

i12 : addition(o, negative(o, p, E), r, E)

o12 = {1, 0, 0}

o12 : List

It is known that when one takes multiples of a point that is not torsion, the "height" - roughly the number of digits in the coordinates - is doubled with each iteration, that is, the number of digits doubles:

i13 : q' := o;

i14 : netList ({q}| for i from 0 to 3 list(
      q' = addition(o,p,q',E)))

      +---------------------+---------------------+--------------------+
o14 = |1                    |0                    |0                   |
      +---------------------+---------------------+--------------------+
      |0                    |1                    |0                   |
      +---------------------+---------------------+--------------------+
      |-941                 |-602                 |189                 |
      +---------------------+---------------------+--------------------+
      |609373631            |318813775            |404996407           |
      +---------------------+---------------------+--------------------+
      |-10212613234813494608|639161987255910986687|19374346679105744952|
      +---------------------+---------------------+--------------------+

i15 : kk = ZZ/7

o15 = kk

o15 : QuotientRing

On the other hand, over a finite field, a curve has only finitely many points, so any subgroup of the Jacobian is finite:

i16 : S = kk[x,y,z]

o16 = S

o16 : PolynomialRing

i17 : p = {0,1,0}; pS = fromCoordinates(p,S)

o18 = ideal (x, z)

o18 : Ideal of S

i19 : o = {1,1,1}; oS = fromCoordinates(o,S)

o20 = ideal (- x + y, - x + z)

o20 : Ideal of S

i21 : setRandomSeed 0

o21 = 0

i22 : I = ideal random(3, intersect(pS,oS))

              3       2     2              2        2      2     3
o22 = ideal(3x  + 3x*y  - 2x z + 3x*y*z + y z - 2x*z  - y*z  + 2z )

o22 : Ideal of S

i23 : E = S/I

o23 = E

o23 : QuotientRing

i24 : geometricGenus E

o24 = 1

i25 : q = o

o25 = {1, 1, 1}

o25 : List

i26 : netList ({o} | apply(5, i-> q = addition(o,p,q,E)))

      +-+--+-+
o26 = |1|1 |1|
      +-+--+-+
      |0|1 |0|
      +-+--+-+
      |2|0 |1|
      +-+--+-+
      |1|2 |1|
      +-+--+-+
      |0|-3|1|
      +-+--+-+
      |1|1 |1|
      +-+--+-+

i27 : setRandomSeed 1

o27 = 1

A cubic with a node or cusp is also arithmetic genus 1; in the case of a node, the smooth points are in correspondence with P^1 minus {0, infinity} and the Jacobian is the multiplicative group of the field. To allow the program to consider this as a curve of arithmetic genus 1, use the optional argument Conductor.

i28 : kk = ZZ/7

o28 = kk

o28 : QuotientRing

i29 : S = kk[x,y,z]

o29 = S

o29 : PolynomialRing

i30 : (o,p,sing) = ({1,1,1}, {-1,1,0},{1,0,-1})

o30 = ({1, 1, 1}, {-1, 1, 0}, {1, 0, -1})

o30 : Sequence

i31 : oS = fromCoordinates(o, S)

o31 = ideal (- x + y, - x + z)

o31 : Ideal of S

i32 : pS = fromCoordinates(p, S)

o32 = ideal (x + y, z)

o32 : Ideal of S

i33 : singS = fromCoordinates(sing, S)

o33 = ideal (y, x + z)

o33 : Ideal of S

i34 : I = random(3, intersect(oS,pS,singS^2))

        3     2        2     3    2              2      3
o34 = 3x  + 3x y - 3x*y  - 3y  + x z + 3x*y*z + y z + 2z

o34 : S

i35 : E = S/I

o35 = E

o35 : QuotientRing

i36 : q' = o

o36 = {1, 1, 1}

o36 : List

i37 : netList ({q'}|apply(6, i->(
        q' = addition(o,p,q',E, Conductor => 1_E)
        )))

      +--+--+-+
o37 = |1 |1 |1|
      +--+--+-+
      |-1|1 |0|
      +--+--+-+
      |-1|-1|1|
      +--+--+-+
      |-3|0 |1|
      +--+--+-+
      |-3|3 |1|
      +--+--+-+
      |0 |3 |1|
      +--+--+-+
      |1 |1 |1|
      +--+--+-+

i38 : I = kernel map(kk[s,t], S, {s^3, s^2*t,t^3})

             3    2
o38 = ideal(y  - x z)

o38 : Ideal of S

In the case of rational curve with a cusp, the smooth points correspond to the additive group of the field

i39 : C = S/I

o39 = C

o39 : QuotientRing

i40 : genus C

o40 = 1

i41 : geometricGenus C

o41 = 0

i42 : geometricGenus (C, Conductor => ideal(1_C))

o42 = 1

i43 : setRandomSeed 0

o43 = 0

the singular point is the image {0,0,1} of the point (0,1) in P^1, so we may take the origin to be the image {1,1,1} of (1,1) and take another smooth point p to be the image {1,0,0} of (1,0).

i44 : p = {1,0,0};

i45 : o = {1,1,1};

i46 : q = o

o46 = {1, 1, 1}

o46 : List

i47 : netList ({o}|apply(7, i-> q = addition(o,p,q,C, Conductor => ideal 1_C)))

      +--+--+-+
o47 = |1 |1 |1|
      +--+--+-+
      |1 |0 |0|
      +--+--+-+
      |-1|1 |1|
      +--+--+-+
      |-1|2 |1|
      +--+--+-+
      |1 |-3|1|
      +--+--+-+
      |-1|-3|1|
      +--+--+-+
      |1 |2 |1|
      +--+--+-+
      |1 |1 |1|
      +--+--+-+

i48 :

so 7p ~ o.

References

"The Practice of Algebraic Curves" Ch. 4, by David Eisenbud and Joe Harris, American Mathematical Society

Caveat

Some aspects of the program use random arguments, so one should be wary of computation over very small fields

Ways to use addition :

addition(Ideal,Ideal,Ideal)
addition(List,List,List,Ring)

For the programmer

The object addition is a method function with options.