UNCONDITIONAL CLASS GROUP TABULATION TO 240

Anton Mosunov (University of Waterloo)Michael J. Jacobson, Jr. (University of Calgary)

June 11th, 2015

AGENDA• Background

• Motivation

• Previous work

• Class number tabulation

• Out-of-core multiplication

• Class group tabulation

• Performance

• Future work

BACKGROUND• Consider a binary quadratic form

of discriminant ,Denote it by .

• The substitution , yields another form . If , then the backward substitution exists. In that case, we call these two forms equivalent.

• we can define an operation of composition under which the set of all equivalence classes forms a finite abelian group, i.e.

ax

2 + bxy + cy

2

� = b2 � 4ac < 0

x = ↵x

0 + �y

0y = �x

0 + �y

0

a, b, c, x, y 2 Z.

↵� � �� = 1

(a, b, c)

(a0, b0, c0)

(a, b, c) � (a0, b0, c0) = (a00, b00, c00)

�

GOAL

• This finite abelian group for a fixed discriminantis called the class group, and is denoted by .

• The cardinality of is called the class number, and is denoted by .

• Goal. Tabulate class groups for every fundamental discriminant . |�| < 240

Cl(�)

h(�)

�

Cl(�)

MOTIVATION• Not much known about class groups.

• It is hard to compute them, in a sense that there is no polynomial time algorithm for the class group computation.

• Want to provide an extensive computational evidence in support of the Cohen-Lenstra heuristics and the Littlewood’s bounds.

• Certain cryptosystems, such as the Buchmann-Williams key exchange protocol, rely on them. Want to have enough evidence that they hold.

PREVIOUS WORK• In late 90s, Buell tabulated to , using algorithm for

enumerating reduced forms. After computing all , he produced by resolving structures of each p-group.

• In 2006, Ramachandran tabulated to using Buchmann-Jacobson-Teske algorithm. The algorithm computes right away. However, it is conditional, and requires verification.

• We follow Buell’s approach. In order to compute all , we use the algorithm due to Hart, Tornaria and Watkins, who used an out-of-core polynomial multiplication technique to tabulate all congruent numbers to .

Cl(�)

2⇥ 1011

Cl(�)

1012

2.2⇥ 109

h(�)

h(�)

CLASS NUMBER TABULATION

• Why do class numbers help us to resolve the group structure faster?

• Consider the factorization of :

• If , then the -group is cyclic, so we can ignore it.

• Up to 240, 85.13% of have non-square factors.

• For more than 57% of them this factor exceeds .

h(�)

h(�) = pe11 · pe22 · . . . · pekk

ei = 1 pi

ph(�)

h(�)

CLASS NUMBER TABULATION• Let

• For the Hurwitz class number the following relations hold:

r(q) =1X

n=0

qn(n+1)

2 = 1 + q + q3 + q6 + q10 + . . .

(a)

(b)

(c)

#3(q) = 1 + 21X

n=0

qn2

= 1 + 2q + 2q4 + 2q9 + 2q16 + . . .

1X

n=0

H(�16n� 8)qn = r2(q2)#3(q)

1X

n=0

H(�16n� 4)qn =1

2r(q2)#2

3(q)

H(�)

1X

n=0

H(�8n� 3)qn =1

3r3(q)

CLASS NUMBER TABULATION• Compute (a) and (b) to 236, and (c) to 237.

This allows us to produce all , except .

• For the Hurwitz class number the following relations hold:

(a)

(b)

(c)

� ⌘ 1(mod 8)

�

H(�)

1X

n=0

H(�16n� 8)qn = r2(q2)#3(q)

1X

n=0

H(�16n� 4)qn =1

2r(q2)#2

3(q)

1X

n=0

H(�8n� 3)qn =1

3r3(q)

OUT-OF-CORE MULTIPLICATION

• We want to compute the product of two polynomials, each of length 2

36. Each coefficient is of size 4

bytes, so in total we require at least of memory.

• Need to store intermediate results on hard disk.

• Need multithreaded environment.

• For our computations, we utilize an out-of-core Fast Fourier Transform with Chinese Remainder Theorem (non-trivial).

h(x) = f(x)⇥ g(x)

3 · 4 · 236 bytes = 768Gb

CLASS GROUP TABULATION• We used the Buchmann-Jacobson-Teske algorithm to compute the

structure of a group.

• The algorithm requires , or the lower bound :

• For , we computed with the Bach’s averaging method (conditional).

• To unconditionally verify our results, we used the Eichler-Selberg trace formula (previously used by Ramachandran).

� ⌘ 1(mod 8)

h(�) h⇤

h⇤ h(�) 2h⇤

h⇤

PERFORMANCE

• We were using Westgrid’s Hungabee supercomputer.

• For each multiplication, we requested 64 Intel Xeon 2.67GHz processors with 8Gb of memory per core.

• (a) to 236 terminated in 8 h 48 min (859 Gb)

• (b) to 236 terminated in 11 h 13 min (893.4 Gb)

• (c) to 237 terminated in 25 h 35 min (1855 Gb)

PERFORMANCE• For class group tabulation, we requested 1008 processors for

and 64 processors for :

• got computed over 6.25 times faster ;

• With class number tabulation and verification, got computed over 4.72 times faster.

� ⌘ 1(mod 8)

� 6⌘ 1(mod 8)

CPU time Real time # of processors265d 4h 31m 4d 3h 27m 64

1657h 22h 12m 39h 29m 1008

�6⌘ 1(mod 8)

⌘ 1(mod 8)

� 6⌘ 1(mod 8)

� 6⌘ 1(mod 8)

SOME EXOTIC GROUPS DISCOVERED

• 3-rank = 4:

• 4-rank = 5:

• Doubly non-cyclic (19-rank = 2, 29-rank = 2):

• Trebly non-cyclic (5-rank = 2, 7-rank = 2, 17-rank = 2):

• Quadruply non-cyclic (4-rank = 2, 3-rank = 2, 5-rank = 2, 13-rank = 2)

� = �1074734433547, Cl⇤(�) ⇠= C(33)⇥ C(33)⇥ C(3)⇥ C(3)

� = �940830993327, Cl(�) ⇠= C(2433)⇥ C(24)⇥ C(22)⇥ C(22)⇥ C(22)

� = �915336787039, Cl(�) ⇠= C(19 · 29)⇥ C(19 · 29)

� = �658234953151, Cl⇤(�) ⇠= C(5 · 7 · 17)⇥ C(5 · 7 · 17)

� = �616825494863, Cl(�) ⇠= C(4 · 3 · 5 · 13)⇥ C(4 · 3 · 5 · 13)

CONCLUSION• Ramachandran’s approach allows to compute class groups right

away. However, for 64 processors it would take at least 4 months (vs. 1 month). Moreover, the result is dependent on Extended Riemann Hypothesis, and requires an additional verification step.

• Out-of-core multiplication approach is unconditional, and with 64 processors allows to produce 2/3 of all class numbers to 240 in less than 2 days!

• We gathered an unconditional numerical evidence in support of Littlewood’s bounds and the Cohen-Lenstra heuristics.

FUTURE WORK

• Find a better way of tabulating class numbers for discriminants unconditionally.

• We believe that Sutherland’s p-group resolution algorithms can also speed up our computations.

• The tabulation of class groups with positive discriminant is currently work in progress.

� ⌘ 1(mod 8)

SOURCES

• The data is available at lmfdb.org.

• The source code is available at github.com/amosunov.

• The paper is soon to appear in “Mathematics of Computation”.

• Also available at arXiv.org:1502.07953.

THANK YOU VERY MUCHFOR YOUR ATTENTION