1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
# Kummer Degrees
A one-file SageMath script to compute the degrees of Kummer Extensions of
the rational numbers. In order to use the functions KummerDegree and
TotalKummerFailure (described below), simply download the file
kummer_degree.sage and include it in your SageMath session/project,
for example with
```
attach("kummer_degree.sage")
```
A Kummer Extension of Q is a field extension of the form Q{M,N}:=
Q(z,G^1/N ), where:
* M and N are integers with N dividing M;
* z is a root of unity of order M;
* G is a finitely generated subgroup of the multiplicative group Q* of Q;
* G^1/N is the set of all elements x of an algebraic closure of Q such that
x^n belongs to G.
In other words, it is a number field generated by finitely many elements of
the form a^1/n and "at least sufficiently many" roots of unity to make
this field Galois over Q.
The main importance of this script is to show that, for a fixed group G as
above, one can compute in a finite time a finite-case-distinction formula
that computes the degrees of such extensions when M and N vary.
A preprint by A. Perucca, P. Sgobba and S. Tronto that explains how this is
possible can be found in the docs folder.
The computational complexity of the algorithm has not been computed precisely.
However, we can say the following:
* The complexity is exponential in the rank r of the group.
* The script can become slow if the generators of the group G are n-th powers
for very high n.
* The generators given are factored as product of prime powers, so very large
generators can slow the script as well.
* The code is very fast for groups of small rank (e.g. up to 5) and generated
by elements of magnitude 10^6; higher ranks are feasible as well with smaller
generators.
* The complexity of KummerDegree(G,M,N) does not depend on M and N.
Moreover, the results for each group G are cached, so that subsequent
computation of degrees for the same group G only require constant time
(and are very fast).
## KummerDegree( G, M, N )
Returns the degree of the Kummer extension Q{M,N}=Q(z,G^1/N ) over Q.
INPUT:
* G - a list of generators of the group G
* M - a positive integer
* N - a positive divisor of N
OUTPUT:
The degree of the Kummer Extensions Q{M,N}=Q(z,G^1/N ) over Q.
EXAMPLES:
```
sage: KummerDegree([5],10,2)
4
sage: KummerDegree([-36,12,-1],120,24)
4608
sage: KummerDegree([144,27,49/81,-1/125,121/13],36*10^6,36*10^6)
1007769600000000000000000000000000000000000
```
## TotalKummerFailure( G )
Outputs the description of the failure of maximality for all possible values
of M and N.
INPUT:
G - a list of generators for the group G
OUPUT:
The first part of the output consist of two positive integers M0 and N0.
N0 is always a divisor of M0.
The second part of the output can be either one or two tables, depending on
the group G. In case -1 is not an element of G, there is only one table,
otherwise two.
In case -1 does not belong to G:
The rows of the table are labelled with the divisors of N_0, while the
columns with the divisors of M_0. The total failure of maximality of the
Kummer Extension
Q_{M,N}, i.e. the ratio between phi(M)*N^rank(G) and the degree of Q_{M,N}
over Q, is given by the (i,j)-th entry of the table for i=gcd(N,N_0) and
j=gcd(M,M_0).
In case -1 belongs to G, we need to distinguish two cases, depending on the
parity of M/N. The two tables are similar to the one described
above, and can be seen in the example below.
The output includes an explanation of the tables and how to read them to
deduce the actual degrees (that can be computed with KummerDegree).
EXAMPLES:
```
sage: TotalKummerFailure([-36,12])
M_0 = 24
N_0 = 8
The following table shows the total failure of Kummer degrees.
The degree of the Kummer extension (M,N) is e / f, where e = phi(M)*N^rank(G)
and f is the entry of the table below at the row labelled with gcd(N,N0) and
the column labelled with gcd(M,M0).
| 1 2 3 4 6 8 12 24
- - - - - - - - - -
1 | 1 1 1 1 1 1 1 1
2 | 1 1 1 2 2 2 4 4
4 | 4 4 4 4 4 4 8 8
8 | 4 4 4 4 4 4 4 8
```
```
sage: TotalKummerFailure([-36,12,-1])
M_0 = 24
N_0 = 8
The following table shows the total failure of Kummer degrees in case the
quotient M/N is EVEN.
The degree of the Kummer extension (M,N) is e / f, where e = phi(M)*N^rank(G)
if N is odd and e = 2*phi(M)*N^rank(G) if N is even and f is the entry of the
table below at the row labelled with gcd(N,N0) and the column labelled with
gcd(M,M0).
| 1 2 3 4 6 8 12 24
- - - - - - - - - -
1 | 1 1 1 1 1 1 1 1
2 | 4 4 4 4 4 4 8 8
4 | 4 4 4 4 4 8 8 16
8 | 8 8 8 8 8 8 8 16
The following table shows the total failure of Kummer degrees if the quotient
M/N is ODD and is read as the previous one.
| 1 2 3 4 6 8 12 24
- - - - - - - - - -
1 | 1 1 1 1 1 1 1 1
2 | 2 2 2 2 4 2 4 4
4 | 2 2 2 4 4 4 8 8
8 | 4 4 4 4 4 4 8 8
```
Uncommenting the line of code:
```
print_case_list( ret )
```
inside the function total_kummer_failure makes the script output the
description of the total failure as a finite list of cases, as below:
```
sage: TotalKummerFailure([25])
M_0 = 40
N_0 = 8
The following table shows the total failure of Kummer degrees.
The degree of the Kummer extension (M,N) is e / f, where e = phi(M)*N^rank(G)
and f is the entry of the table below at the row labelled with gcd(N,N0) and
the column labelled with gcd(M,M0).
| 1 2 4 5 8 10 20 40
- - - - - - - - - -
1 | 1 1 1 1 1 1 1 1
2 | 2 2 2 2 2 2 2 2
4 | 2 2 2 2 2 2 4 4
8 | 2 2 2 2 2 2 2 4
Failure is 1 if (gcd(M,M0),gcd(N,N0)) is one of the following:
[(1, 1), (2, 1), (4, 1), (5, 1), (8, 1), (10, 1), (20, 1), (40, 1)]
Failure is 2 if (gcd(M,M0),gcd(N,N0)) is one of the following:
[(1, 2), (2, 2), (4, 2), (5, 2), (8, 2), (10, 2), (20, 2), (40, 2), (1, 4), (2, 4), (4, 4), (5, 4), (8, 4), (10, 4), (1, 8), (2, 8), (4, 8), (5, 8), (8, 8), (10, 8), (20, 8)]
Failure is 4 if (gcd(M,M0),gcd(N,N0)) is one of the following:
[(20, 4), (40, 4), (40, 8)]
```
|
