Rubinstein’s \(L\)-function Calculator

This interface provides complete access to Rubinstein’s lcalc calculator with extra PARI functionality compiled in and is a standard part of Sage.

Note

Each call to lcalc runs a complete lcalc process. On a typical Linux system, this entails about 0.3 seconds overhead.

AUTHORS:

  • Michael Rubinstein (2005): released under GPL the C++ program lcalc
  • William Stein (2006-03-05): wrote Sage interface to lcalc
class sage.lfunctions.lcalc.LCalc

Bases: sage.structure.sage_object.SageObject

Rubinstein’s \(L\)-functions Calculator

Type lcalc.[tab] for a list of useful commands that are implemented using the command line interface, but return objects that make sense in Sage. For each command the possible inputs for the L-function are:

  • " - (default) the Riemann zeta function
  • 'tau' - the L function of the Ramanujan delta function
  • elliptic curve E - where E is an elliptic curve over \(\mathbb{Q}\); defines \(L(E,s)\)

You can also use the complete command-line interface of Rubinstein’s \(L\)-functions calculations program via this class. Type lcalc.help() for a list of commands and how to call them.

analytic_rank(L='')

Return the analytic rank of the \(L\)-function at the central critical point.

INPUT:

  • L - defines \(L\)-function (default: Riemann zeta function)

OUTPUT: integer

Note

Of course this is not provably correct in general, since it is an open problem to compute analytic ranks provably correctly in general.

EXAMPLES:

sage: E = EllipticCurve('37a')
sage: lcalc.analytic_rank(E)
  ***   Warning:...new stack size = ...
1
help()

x.__init__(...) initializes x; see help(type(x)) for signature

twist_values(s, dmin, dmax, L='')

Return values of \(L(s, \chi_k)\) for each quadratic character \(\chi_k\) whose discriminant \(d\) satisfies \(d_{\min} \leq d \leq d_{\max}\).

INPUT:

  • s - complex numbers
  • dmin - integer
  • dmax - integer
  • L - defines \(L\)-function (default: Riemann zeta function)

OUTPUT:

  • list - list of pairs (d, L(s,chi_d))

EXAMPLES:

sage: lcalc.twist_values(0.5, -10, 10)
[(-8, 1.10042141), (-7, 1.14658567), (-4, 0.667691457), (-3, 0.480867558), (5, 0.231750947), (8, 0.373691713)]
twist_zeros(n, dmin, dmax, L='')

Return first \(n\) real parts of nontrivial zeros for each quadratic character \(\chi_k\) whose discriminant \(d\) satisfies \(d_{\min} \leq d \leq d_{\max}\).

INPUT:

  • n - integer
  • dmin - integer
  • dmax - integer
  • L - defines \(L\)-function (default: Riemann zeta function)

OUTPUT:

  • dict - keys are the discriminants \(d\), and values are list of corresponding zeros.

EXAMPLES:

sage: lcalc.twist_zeros(3, -3, 6)
{-3: [8.03973716, 11.2492062, 15.7046192], 5: [6.64845335, 9.83144443, 11.9588456]}
value(s, L='')

Return \(L(s)\) for \(s\) a complex number.

INPUT:

  • s - complex number
  • L - defines \(L\)-function (default: Riemann zeta function)

EXAMPLES:

sage: I = CC.0
sage: lcalc.value(0.5 + 100*I)
2.69261989 - 0.0203860296*I

Note, Sage can also compute zeta at complex numbers (using the PARI C library):

sage: (0.5 + 100*I).zeta()
2.69261988568132 - 0.0203860296025982*I
values_along_line(s0, s1, number_samples, L='')

Return values of \(L(s)\) at number_samples equally-spaced sample points along the line from \(s_0\) to \(s_1\) in the complex plane.

INPUT:

  • s0, s1 - complex numbers
  • number_samples - integer
  • L - defines \(L\)-function (default: Riemann zeta function)

OUTPUT:

  • list - list of pairs (s, zeta(s)), where the s are equally spaced sampled points on the line from s0 to s1.

EXAMPLES:

sage: I = CC.0
sage: lcalc.values_along_line(0.5, 0.5+20*I, 5)
[(0.500000000, -1.46035451), (0.500000000 + 4.00000000*I, 0.606783764 + 0.0911121400*I), (0.500000000 + 8.00000000*I, 1.24161511 + 0.360047588*I), (0.500000000 + 12.0000000*I, 1.01593665 - 0.745112472*I), (0.500000000 + 16.0000000*I, 0.938545408 + 1.21658782*I)]

Sometimes warnings are printed (by lcalc) when this command is run:

sage: E = EllipticCurve('389a')
sage: E.lseries().values_along_line(0.5, 3, 5)
  ***   Warning:...new stack size = ...
[(0.000000000, 0.209951303),
 (0.500000000, -...e-16),
 (1.00000000, 0.133768433),
 (1.50000000, 0.360092864),
 (2.00000000, 0.552975867)]
zeros(n, L='')

Return the imaginary parts of the first \(n\) nontrivial zeros of the \(L\)-function in the upper half plane, as 32-bit reals.

INPUT:

  • n - integer
  • L - defines \(L\)-function (default: Riemann zeta function)

This function also checks the Riemann Hypothesis and makes sure no zeros are missed. This means it looks for several dozen zeros to make sure none have been missed before outputting any zeros at all, so takes longer than self.zeros_of_zeta_in_interval(...).

EXAMPLES:

sage: lcalc.zeros(4)                           # long time
[14.1347251, 21.0220396, 25.0108576, 30.4248761]
sage: lcalc.zeros(5, L='--tau')                # long time
[9.22237940, 13.9075499, 17.4427770, 19.6565131, 22.3361036]
sage: lcalc.zeros(3, EllipticCurve('37a'))     # long time
  ***   Warning:...new stack size = ...
[0.000000000, 5.00317001, 6.87039122]
zeros_in_interval(x, y, stepsize, L='')

Return the imaginary parts of (most of) the nontrivial zeros of the \(L\)-function on the line \(\Re(s)=1/2\) with positive imaginary part between \(x\) and \(y\), along with a technical quantity for each.

INPUT:

  • x, y, stepsize - positive floating point numbers
  • L - defines \(L\)-function (default: Riemann zeta function)

OUTPUT: list of pairs (zero, S(T)).

Rubinstein writes: The first column outputs the imaginary part of the zero, the second column a quantity related to \(S(T)\) (it increases roughly by 2 whenever a sign change, i.e. pair of zeros, is missed). Higher up the critical strip you should use a smaller stepsize so as not to miss zeros.

EXAMPLES:

sage: lcalc.zeros_in_interval(10, 30, 0.1)
[(14.1347251, 0.184672916), (21.0220396, -0.0677893290), (25.0108576, -0.0555872781)]

Previous topic

L-Functions

Next topic

Watkins Symmetric Power \(L\)-function Calculator

This Page