Goto Chapter: Top 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 Bib Ind

18 Cyclotomic Numbers

18.1 Operations for Cyclotomics

18.1-1 E

18.1-2 Cyclotomics

18.1-3 IsCyclotomic

18.1-4 IsIntegralCyclotomic

18.1-5 Int

18.1-6 String

18.1-7 Conductor

18.1-8 AbsoluteValue

18.1-9 RoundCyc

18.1-10 CoeffsCyc

18.1-11 DenominatorCyc

18.1-12 ExtRepOfObj

18.1-13 DescriptionOfRootOfUnity

18.1-14 IsGaussInt

18.1-15 IsGaussRat

18.1-16 DefaultField

18.1-1 E

18.1-2 Cyclotomics

18.1-3 IsCyclotomic

18.1-4 IsIntegralCyclotomic

18.1-5 Int

18.1-6 String

18.1-7 Conductor

18.1-8 AbsoluteValue

18.1-9 RoundCyc

18.1-10 CoeffsCyc

18.1-11 DenominatorCyc

18.1-12 ExtRepOfObj

18.1-13 DescriptionOfRootOfUnity

18.1-14 IsGaussInt

18.1-15 IsGaussRat

18.1-16 DefaultField

**GAP** admits computations in abelian extension fields of the rational number field ?, that is fields with abelian Galois group over ?. These fields are subfields of *cyclotomic fields* ?(e_n) where e_n = exp(2 π i/n) is a primitive complex n-th root of unity. The elements of these fields are called *cyclotomics*.

Information concerning operations for domains of cyclotomics, for example certain integral bases of fields of cyclotomics, can be found in Chapter?60. For more general operations that take a field extension as a –possibly optional– argument, e.g., `Trace`

(58.3-5) or `Coefficients`

(61.6-3), see Chapter?58.

`‣ E` ( n ) | ( operation ) |

`E`

returns the primitive `n`-th root of unity e_n = exp(2π i/n). Cyclotomics are usually entered as sums of roots of unity, with rational coefficients, and irrational cyclotomics are displayed in such a way. (For special cyclotomics, see?18.4.)

gap> E(9); E(9)^3; E(6); E(12) / 3; -E(9)^4-E(9)^7 E(3) -E(3)^2 -1/3*E(12)^7

A particular basis is used to express cyclotomics, see?60.3; note that `E(9)`

is *not* a basis element, as the above example shows.

`‣ Cyclotomics` | ( global variable ) |

is the domain of all cyclotomics.

gap> E(9) in Cyclotomics; 37 in Cyclotomics; true in Cyclotomics; true true false

As the cyclotomics are field elements, the usual arithmetic operators `+`

, `-`

, `*`

and `/`

(and `^`

to take powers by integers) are applicable. Note that `^`

does *not* denote the conjugation of group elements, so it is *not* possible to explicitly construct groups of cyclotomics. (However, it is possible to compute the inverse and the multiplicative order of a nonzero cyclotomic.) Also, taking the k-th power of a root of unity z defines a Galois automorphism if and only if k is coprime to the conductor (see `Conductor`

(18.1-7)) of z.

gap> E(5) + E(3); (E(5) + E(5)^4) ^ 2; E(5) / E(3); E(5) * E(3); -E(15)^2-2*E(15)^8-E(15)^11-E(15)^13-E(15)^14 -2*E(5)-E(5)^2-E(5)^3-2*E(5)^4 E(15)^13 E(15)^8 gap> Order( E(5) ); Order( 1+E(5) ); 5 infinity

`‣ IsCyclotomic` ( obj ) | ( category ) |

`‣ IsCyc` ( obj ) | ( category ) |

Every object in the family `CyclotomicsFamily`

lies in the category `IsCyclotomic`

. This covers integers, rationals, proper cyclotomics, the object `infinity`

(18.2-1), and unknowns (see Chapter?74). All these objects except `infinity`

(18.2-1) and unknowns lie also in the category `IsCyc`

, `infinity`

(18.2-1) lies in (and can be detected from) the category `IsInfinity`

(18.2-1), and unknowns lie in `IsUnknown`

(74.1-3).

gap> IsCyclotomic(0); IsCyclotomic(1/2*E(3)); IsCyclotomic( infinity ); true true true gap> IsCyc(0); IsCyc(1/2*E(3)); IsCyc( infinity ); true true false

`‣ IsIntegralCyclotomic` ( obj ) | ( property ) |

A cyclotomic is called *integral* or a *cyclotomic integer* if all coefficients of its minimal polynomial over the rationals are integers. Since the underlying basis of the external representation of cyclotomics is an integral basis (see?60.3), the subring of cyclotomic integers in a cyclotomic field is formed by those cyclotomics for which the external representation is a list of integers. For example, square roots of integers are cyclotomic integers (see?18.4), any root of unity is a cyclotomic integer, character values are always cyclotomic integers, but all rationals which are not integers are not cyclotomic integers.

gap> r:= ER( 5 ); # The square root of 5 ... E(5)-E(5)^2-E(5)^3+E(5)^4 gap> IsIntegralCyclotomic( r ); # ... is a cyclotomic integer. true gap> r2:= 1/2 * r; # This is not a cyclotomic integer, ... 1/2*E(5)-1/2*E(5)^2-1/2*E(5)^3+1/2*E(5)^4 gap> IsIntegralCyclotomic( r2 ); false gap> r3:= 1/2 * r - 1/2; # ... but this is one. E(5)+E(5)^4 gap> IsIntegralCyclotomic( r3 ); true

`‣ Int` ( cyc ) | ( method ) |

The operation `Int`

can be used to find a cyclotomic integer near to an arbitrary cyclotomic, by applying `Int`

(14.2-3) to the coefficients.

gap> Int( E(5)+1/2*E(5)^2 ); Int( 2/3*E(7)-3/2*E(4) ); E(5) -E(4)

`‣ String` ( cyc ) | ( method ) |

The operation `String`

returns for a cyclotomic `cyc` a string corresponding to the way the cyclotomic is printed by `ViewObj`

(6.3-5) and `PrintObj`

(6.3-5).

gap> String( E(5)+1/2*E(5)^2 ); String( 17/3 ); "E(5)+1/2*E(5)^2" "17/3"

`‣ Conductor` ( cyc ) | ( attribute ) |

`‣ Conductor` ( C ) | ( attribute ) |

For an element `cyc` of a cyclotomic field, `Conductor`

returns the smallest integer n such that `cyc` is contained in the n-th cyclotomic field. For a collection `C` of cyclotomics (for example a dense list of cyclotomics or a field of cyclotomics), `Conductor`

returns the smallest integer n such that all elements of `C` are contained in the n-th cyclotomic field.

gap> Conductor( 0 ); Conductor( E(10) ); Conductor( E(12) ); 1 5 12

`‣ AbsoluteValue` ( cyc ) | ( attribute ) |

returns the absolute value of a cyclotomic number `cyc`. At the moment only methods for rational numbers exist.

gap> AbsoluteValue(-3); 3

`‣ RoundCyc` ( cyc ) | ( operation ) |

is a cyclotomic integer z (see `IsIntegralCyclotomic`

(18.1-4)) near to the cyclotomic `cyc` in the following sense: Let `c`

be the i-th coefficient in the external representation (see?`CoeffsCyc`

(18.1-10)) of `cyc`. Then the i-th coefficient in the external representation of z is `Int( c + 1/2 )`

or `Int( c - 1/2 )`

, depending on whether `c`

is nonnegative or negative, respectively.

Expressed in terms of the Zumbroich basis (see?60.3), rounding the coefficients of `cyc` w.r.t.?this basis to the nearest integer yields the coefficients of z.

gap> RoundCyc( E(5)+1/2*E(5)^2 ); RoundCyc( 2/3*E(7)+3/2*E(4) ); E(5)+E(5)^2 -2*E(28)^3+E(28)^4-2*E(28)^11-2*E(28)^15-2*E(28)^19-2*E(28)^23 -2*E(28)^27

`‣ CoeffsCyc` ( cyc, N ) | ( function ) |

Let `cyc` be a cyclotomic with conductor n (see `Conductor`

(18.1-7)). If `N` is not a multiple of n then `CoeffsCyc`

returns `fail`

because `cyc` cannot be expressed in terms of `N`-th roots of unity. Otherwise `CoeffsCyc`

returns a list of length `N` with entry at position j equal to the coefficient of exp(2 π i (j-1)/`N`) if this root belongs to the `N`-th Zumbroich basis (see?60.3), and equal to zero otherwise. So we have `cyc` = `CoeffsCyc(`

`cyc`, `N` `) * List( [1..`

`N``], j -> E(`

`N``)^(j-1) )`

.

gap> cyc:= E(5)+E(5)^2; E(5)+E(5)^2 gap> CoeffsCyc( cyc, 5 ); CoeffsCyc( cyc, 15 ); CoeffsCyc( cyc, 7 ); [ 0, 1, 1, 0, 0 ] [ 0, -1, 0, 0, 0, 0, 0, 0, -1, 0, 0, -1, 0, -1, 0 ] fail

`‣ DenominatorCyc` ( cyc ) | ( function ) |

For a cyclotomic number `cyc` (see?`IsCyclotomic`

(18.1-3)), this function returns the smallest positive integer n such that n` * `

`cyc` is a cyclotomic integer (see?`IsIntegralCyclotomic`

(18.1-4)). For rational numbers `cyc`, the result is the same as that of `DenominatorRat`

(17.2-5).

`‣ ExtRepOfObj` ( cyc ) | ( method ) |

The external representation of a cyclotomic `cyc` with conductor n (see `Conductor`

(18.1-7) is the list returned by `CoeffsCyc`

(18.1-10), called with `cyc` and n.

gap> ExtRepOfObj( E(5) ); CoeffsCyc( E(5), 5 ); [ 0, 1, 0, 0, 0 ] [ 0, 1, 0, 0, 0 ] gap> CoeffsCyc( E(5), 15 ); [ 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, 0, 0, 0, -1, 0 ]

`‣ DescriptionOfRootOfUnity` ( root ) | ( function ) |

Given a cyclotomic `root` that is known to be a root of unity (this is *not* checked), `DescriptionOfRootOfUnity`

returns a list [ n, e ] of coprime positive integers such that `root` = `E`

(n)^e holds.

gap> E(9); DescriptionOfRootOfUnity( E(9) ); -E(9)^4-E(9)^7 [ 9, 1 ] gap> DescriptionOfRootOfUnity( -E(3) ); [ 6, 5 ]

`‣ IsGaussInt` ( x ) | ( function ) |

`IsGaussInt`

returns `true`

if the object `x` is a Gaussian integer (see?`GaussianIntegers`

(60.5-1)), and `false`

otherwise. Gaussian integers are of the form a + b`*E(4)`

, where a and b are integers.

`‣ IsGaussRat` ( x ) | ( function ) |

`IsGaussRat`

returns `true`

if the object `x` is a Gaussian rational (see?`GaussianRationals`

(60.1-3)), and `false`

otherwise. Gaussian rationals are of the form a + b`*E(4)`

, where a and b are rationals.

`‣ DefaultField` ( list ) | ( function ) |

`DefaultField`

for cyclotomics is defined to return the smallest *cyclotomic* field containing the given elements.

Note that `Field`

(58.1-3) returns the smallest field containing all given elements, which need not be a cyclotomic field. In both cases, the fields represent vector spaces over the rationals (see?60.3).

gap> Field( E(5)+E(5)^4 ); DefaultField( E(5)+E(5)^4 ); NF(5,[ 1, 4 ]) CF(5)

`‣ IsInfinity` ( obj ) | ( category ) |

`‣ IsNegInfinity` ( obj ) | ( category ) |

`‣ infinity` | ( global variable ) |

`‣ -infinity` | ( global variable ) |

`infinity`

and `-infinity`

are special **GAP** objects that lie in `CyclotomicsFamily`

. They are larger or smaller than all other objects in this family respectively. `infinity`

is mainly used as return value of operations such as `Size`

(30.4-6) and `Dimension`

(57.3-3) for infinite and infinite dimensional domains, respectively.

Some arithmetic operations are provided for convenience when using `infinity`

and `-infinity`

as top and bottom element respectively.

gap> -infinity + 1; -infinity gap> infinity + infinity; infinity

Often it is useful to distinguish `infinity`

from "proper" cyclotomics. For that, `infinity`

lies in the category `IsInfinity`

but not in `IsCyc`

(18.1-3), and the other cyclotomics lie in the category `IsCyc`

(18.1-3) but not in `IsInfinity`

.

gap> s:= Size( Rationals ); infinity gap> s = infinity; IsCyclotomic( s ); IsCyc( s ); IsInfinity( s ); true true false true gap> s in Rationals; s > 17; false true gap> Set( [ s, 2, s, E(17), s, 19 ] ); [ 2, 19, E(17), infinity ]

To compare cyclotomics, the operators `<`

, `<=`

, `=`

, `>=`

, `>`

, and `<>`

can be used, the result will be `true`

if the first operand is smaller, smaller or equal, equal, larger or equal, larger, or unequal, respectively, and `false`

otherwise.

Cyclotomics are ordered as follows: The relation between rationals is the natural one, rationals are smaller than irrational cyclotomics, and `infinity`

(18.2-1) is the largest cyclotomic. For two irrational cyclotomics with different conductors (see `Conductor`

(18.1-7)), the one with smaller conductor is regarded as smaller. Two irrational cyclotomics with same conductor are compared via their external representation (see `ExtRepOfObj`

(18.1-12)).

For comparisons of cyclotomics and other **GAP** objects, see Section?4.12.

gap> E(5) < E(6); # the latter value has conductor 3 false gap> E(3) < E(3)^2; # both have conductor 3, compare the ext. repr. false gap> 3 < E(3); E(5) < E(7); true true

`‣ EB` ( N ) | ( function ) |

`‣ EC` ( N ) | ( function ) |

`‣ ED` ( N ) | ( function ) |

`‣ EE` ( N ) | ( function ) |

`‣ EF` ( N ) | ( function ) |

`‣ EG` ( N ) | ( function ) |

`‣ EH` ( N ) | ( function ) |

For a positive integer `N`, let z = `E(`

`N``)`

= exp(2 π i/`N`). The following so-called *atomic irrationalities* (see [CCN+85, Chapter 7, Section 10]) can be entered using functions. (Note that the values are not necessary irrational.)

`EB(` N`)` |
= | b_N |
= | ( ∑_{j = 1}^{N-1} z^{j^2} ) / 2 |
, | N ≡ 1 mod 2 |

`EC(` N`)` |
= | c_N |
= | ( ∑_{j = 1}^{N-1} z^{j^3} ) / 3 |
, | N ≡ 1 mod 3 |

`ED(` N`)` |
= | d_N |
= | ( ∑_{j = 1}^{N-1} z^{j^4} ) / 4 |
, | N ≡ 1 mod 4 |

`EE(` N`)` |
= | e_N |
= | ( ∑_{j = 1}^{N-1} z^{j^5} ) / 5 |
, | N ≡ 1 mod 5 |

`EF(` N`)` |
= | f_N |
= | ( ∑_{j = 1}^{N-1} z^{j^6} ) / 6 |
, | N ≡ 1 mod 6 |

`EG(` N`)` |
= | g_N |
= | ( ∑_{j = 1}^{N-1} z^{j^7} ) / 7 |
, | N ≡ 1 mod 7 |

`EH(` N`)` |
= | h_N |
= | ( ∑_{j = 1}^{N-1} z^{j^8} ) / 8 |
, | N ≡ 1 mod 8 |

(Note that in `EC(`

`N``)`

, ..., `EH(`

`N``)`

, `N` must be a prime.)

gap> EB(5); EB(9); E(5)+E(5)^4 1

`‣ EI` ( N ) | ( function ) |

`‣ ER` ( N ) | ( function ) |

For a rational number `N`, `ER`

returns the square root sqrt{`N`} of `N`, and `EI`

returns sqrt{-`N`}. By the chosen embedding of cyclotomic fields into the complex numbers, `ER`

returns the positive square root if `N` is positive, and if `N` is negative then `ER(`

`N``) = EI(-`

`N``)`

holds. In any case, `EI(`

`N``) = E(4) * ER(`

`N``)`

.

`ER`

is installed as method for the operation `Sqrt`

(31.12-5), for rational argument.

From a theorem of Gauss we know that b_`N` =

(-1 + sqrt{N}) / 2 |
if | N ≡ 1 mod 4 |

(-1 + i sqrt{N}) / 2 |
if | N ≡ -1 mod 4 |

So sqrt{`N`} can be computed from b_`N`, see?`EB`

(18.4-1).

gap> ER(3); EI(3); -E(12)^7+E(12)^11 E(3)-E(3)^2

`‣ EY` ( N[, d] ) | ( function ) |

`‣ EX` ( N[, d] ) | ( function ) |

`‣ EW` ( N[, d] ) | ( function ) |

`‣ EV` ( N[, d] ) | ( function ) |

`‣ EU` ( N[, d] ) | ( function ) |

`‣ ET` ( N[, d] ) | ( function ) |

`‣ ES` ( N[, d] ) | ( function ) |

For the given integer `N` > 2, let `N`_k denote the first integer with multiplicative order exactly k modulo `N`, chosen in the order of preference

1, -1, 2, -2, 3, -3, 4, -4, ... .

We define (with z = exp(2 π i/`N`))

`EY(` N`)` |
= | y_N |
= | z + z^n | (n = N_2) |

`EX(` N`)` |
= | x_N |
= | z + z^n + z^{n^2} | (n = N_3) |

`EW` (N`)` |
= | w_N |
= | z + z^n + z^{n^2} + z^{n^3} | (n = N_4) |

`EV(` N`)` |
= | v_N |
= | z + z^n + z^{n^2} + z^{n^3} + z^{n^4} | (n = N_5) |

`EU(` N`)` |
= | u_N |
= | z + z^n + z^{n^2} + ... + z^{n^5} | (n = N_6) |

`ET(` N`)` |
= | t_N |
= | z + z^n + z^{n^2} + ... + z^{n^6} | (n = N_7) |

`ES(` N`)` |
= | s_N |
= | z + z^n + z^{n^2} + ... + z^{n^7} | (n = N_8) |

For the two-argument versions of the functions, see Section `NK`

(18.4-5).

gap> EY(5); E(5)+E(5)^4 gap> EW(16,3); EW(17,2); 0 E(17)+E(17)^4+E(17)^13+E(17)^16

`‣ EM` ( N[, d] ) | ( function ) |

`‣ EL` ( N[, d] ) | ( function ) |

`‣ EK` ( N[, d] ) | ( function ) |

`‣ EJ` ( N[, d] ) | ( function ) |

Let `N` be an integer, `N` > 2. We define (with z = exp(2 π i/`N`))

`EM(` N`)` |
= | m_N |
= | z - z^n | (n = N_2) |

`EL(` N`)` |
= | l_N |
= | z - z^n + z^{n^2} - z^{n^3} | (n = N_4) |

`EK(` N`)` |
= | k_N |
= | z - z^n + ... - z^{n^5} | (n = N_6) |

`EJ(` N`)` |
= | j_N |
= | z - z^n + ... - z^{n^7} | (n = N_8) |

For the two-argument versions of the functions, see Section `NK`

(18.4-5).

`‣ NK` ( N, k, d ) | ( function ) |

Let `N`_`k`^(`d`) be the (`d`+1)-th integer with multiplicative order exactly `k` modulo `N`, chosen in the order of preference defined in Section 18.4-3; `NK`

returns `N`_`k`^(`d`); if there is no integer with the required multiplicative order, `NK`

returns `fail`

.

We write `N`_`k` = `N`_`k`^(0), `N`_`k`^' = `N`_`k`^(1), `N`_`k`^'' = `N`_`k`^(2) and so on.

The algebraic numbers

y_`N`^' = y_`N`^(1), y_`N`^'' = y_`N`^(2), ..., x_`N`^', x_`N`^'', ..., j_`N`^', j_`N`^'', ...

are obtained on replacing `N`_`k` in the definitions in the sections 18.4-3 and 18.4-4 by `N`_`k`^', `N`_`k`^'', ...; they can be entered as

`EY(` N,d`)` |
= | y_N^(d) |

`EX(` N,d`)` |
= | x_N^(d) |

... | ||

`EJ(` N,d`)` |
= | j_N^(d) |

`‣ AtlasIrrationality` ( irratname ) | ( function ) |

Let `irratname` be a string that describes an irrational value as a linear combination in terms of the atomic irrationalities introduced in the sections 18.4-1, 18.4-2, 18.4-3, 18.4-4. These irrational values are defined in [CCN+85, Chapter 6, Section 10], and the following description is mainly copied from there. If q_N is such a value (e.g. y_24^'') then linear combinations of algebraic conjugates of q_N are abbreviated as in the following examples:

`2qN+3&5-4&7+&9` |
means | 2 q_N + 3 q_N^{*5} - 4 q_N^{*7} + q_N^{*9} |

`4qN&3&5&7-3&4` |
means | 4 (q_N + q_N^{*3} + q_N^{*5} + q_N^{*7}) - 3 q_N^{*11} |

`4qN*3&5+&7` |
means | 4 (q_N^{*3} + q_N^{*5}) + q_N^{*7} |

To explain the "ampersand" syntax in general we remark that "&k" is interpreted as q_N^{*k}, where q_N is the most recently named atomic irrationality, and that the scope of any premultiplying coefficient is broken by a + or - sign, but not by & or *k. The algebraic conjugations indicated by the ampersands apply directly to the *atomic* irrationality q_N, even when, as in the last example, q_N first appears with another conjugacy *k.

gap> AtlasIrrationality( "b7*3" ); E(7)^3+E(7)^5+E(7)^6 gap> AtlasIrrationality( "y'''24" ); E(24)-E(24)^19 gap> AtlasIrrationality( "-3y'''24*13&5" ); 3*E(8)-3*E(8)^3 gap> AtlasIrrationality( "3y'''24*13-2&5" ); -3*E(24)-2*E(24)^11+2*E(24)^17+3*E(24)^19 gap> AtlasIrrationality( "3y'''24*13-&5" ); -3*E(24)-E(24)^11+E(24)^17+3*E(24)^19 gap> AtlasIrrationality( "3y'''24*13-4&5&7" ); -7*E(24)-4*E(24)^11+4*E(24)^17+7*E(24)^19 gap> AtlasIrrationality( "3y'''24&7" ); 6*E(24)-6*E(24)^19

`‣ GaloisCyc` ( cyc, k ) | ( operation ) |

`‣ GaloisCyc` ( list, k ) | ( operation ) |

For a cyclotomic `cyc` and an integer `k`, `GaloisCyc`

returns the cyclotomic obtained by raising the roots of unity in the Zumbroich basis representation of `cyc` to the `k`-th power. If `k` is coprime to the integer n, `GaloisCyc( ., `

acts as a Galois automorphism of the n-th cyclotomic field (see?60.4); to get the Galois automorphisms themselves, use `k` )`GaloisGroup`

(58.3-1).

The *complex conjugate* of `cyc` is `GaloisCyc( `

, which can also be computed using `cyc`, -1 )`ComplexConjugate`

(18.5-2).

For a list or matrix `list` of cyclotomics, `GaloisCyc`

returns the list obtained by applying `GaloisCyc`

to the entries of `list`.

`‣ ComplexConjugate` ( z ) | ( attribute ) |

`‣ RealPart` ( z ) | ( attribute ) |

`‣ ImaginaryPart` ( z ) | ( attribute ) |

For a cyclotomic number `z`, `ComplexConjugate`

returns `GaloisCyc( `

, see?`z`, -1 )`GaloisCyc`

(18.5-1). For a quaternion `z` = c_1 e + c_2 i + c_3 j + c_4 k, `ComplexConjugate`

returns c_1 e - c_2 i - c_3 j - c_4 k, see?`IsQuaternion`

(62.8-8).

When `ComplexConjugate`

is called with a list then the result is the list of return values of `ComplexConjugate`

for the list entries in the corresponding positions.

When `ComplexConjugate`

is defined for an object `z` then `RealPart`

and `ImaginaryPart`

return `(`

and `z` + ComplexConjugate( `z` )) / 2`(`

, respectively, where `z` - ComplexConjugate( `z` )) / 2 i`i`

denotes the corresponding imaginary unit.

gap> GaloisCyc( E(5) + E(5)^4, 2 ); E(5)^2+E(5)^3 gap> GaloisCyc( E(5), -1 ); # the complex conjugate E(5)^4 gap> GaloisCyc( E(5) + E(5)^4, -1 ); # this value is real E(5)+E(5)^4 gap> GaloisCyc( E(15) + E(15)^4, 3 ); E(5)+E(5)^4 gap> ComplexConjugate( E(7) ); E(7)^6

`‣ StarCyc` ( cyc ) | ( function ) |

If the cyclotomic `cyc` is an irrational element of a quadratic extension of the rationals then `StarCyc`

returns the unique Galois conjugate of `cyc` that is different from `cyc`, otherwise `fail`

is returned. In the first case, the return value is often called `cyc`* (see?71.13).

gap> StarCyc( EB(5) ); StarCyc( E(5) ); E(5)^2+E(5)^3 fail

`‣ Quadratic` ( cyc ) | ( function ) |

Let `cyc` be a cyclotomic integer that lies in a quadratic extension field of the rationals. Then we have `cyc`= (a + b sqrt{n}) / d, for integers a, b, n, d, such that d is either 1 or 2. In this case, `Quadratic`

returns a record with the components `a`

, `b`

, `root`

, `d`

, `ATLAS`

, and `display`

; the values of the first four are a, b, n, and d, the `ATLAS`

value is a (not necessarily shortest) representation of `cyc` in terms of the **Atlas** irrationalities b_{|n|}, i_{|n|}, r_{|n|}, and the `display`

value is a string that expresses `cyc` in **GAP** notation, corresponding to the value of the `ATLAS`

component.

If `cyc` is not a cyclotomic integer or does not lie in a quadratic extension field of the rationals then `fail`

is returned.

If the denominator d is 2 then necessarily n is congruent to 1 modulo 4, and r_n, i_n are not possible; we have

with `cyc` = x + y * EB( root )`y = b`

, `x = ( a + b ) / 2`

.

If d = 1, we have the possibilities i_{|n|} for n < -1, a + b * i for n = -1, a + b * r_n for n > 0. Furthermore if n is congruent to 1 modulo 4, also `cyc` = (a+b) + 2 * b * b_{|n|} is possible; the shortest string of these is taken as the value for the component `ATLAS`

.

gap> Quadratic( EB(5) ); Quadratic( EB(27) ); rec( ATLAS := "b5", a := -1, b := 1, d := 2, display := "(-1+Sqrt(5))/2", root := 5 ) rec( ATLAS := "1+3b3", a := -1, b := 3, d := 2, display := "(-1+3*Sqrt(-3))/2", root := -3 ) gap> Quadratic(0); Quadratic( E(5) ); rec( ATLAS := "0", a := 0, b := 0, d := 1, display := "0", root := 1 ) fail

`‣ GaloisMat` ( mat ) | ( attribute ) |

Let `mat` be a matrix of cyclotomics. `GaloisMat`

calculates the complete orbits under the operation of the Galois group of the (irrational) entries of `mat`, and the permutations of rows corresponding to the generators of the Galois group.

If some rows of `mat` are identical, only the first one is considered for the permutations, and a warning will be printed.

`GaloisMat`

returns a record with the components `mat`

, `galoisfams`

, and `generators`

.

`mat`

a list with initial segment being the rows of

`mat`(*not*shallow copies of these rows); the list consists of full orbits under the action of the Galois group of the entries of`mat`defined above. The last rows in the list are those not contained in`mat`but must be added in order to complete the orbits; so if the orbits were already complete,`mat`and`mat`

have identical rows.`galoisfams`

a list that has the same length as the

`mat`

component, its entries are either 1, 0, -1, or lists.`galoisfams[i] = 1`

means that

`mat[i]`

consists of rationals, i.e.,`[ mat[i] ]`

forms an orbit;`galoisfams[i] = -1`

means that

`mat[i]`

contains unknowns (see Chapter?74); in this case`[ mat[i] ]`

is regarded as an orbit, too, even if`mat[i]`

contains irrational entries;`galoisfams[i] =`

[ l_1, l_2 ](a list) means that

`mat[i]`

is the first element of its orbit in`mat`

, l_1 is the list of positions of rows that form the orbit, and l_2 is the list of corresponding Galois automorphisms (as exponents, not as functions); so we have`mat`

[ l_1[j] ][k] =`GaloisCyc( mat`

[i][k], l_2[j]`)`

;`galoisfams[i] = 0`

means that

`mat[i]`

is an element of a nontrivial orbit but not the first element of it.

`generators`

a list of permutations generating the permutation group corresponding to the action of the Galois group on the rows of

`mat`

.

gap> GaloisMat( [ [ E(3), E(4) ] ] ); rec( galoisfams := [ [ [ 1, 2, 3, 4 ], [ 1, 7, 5, 11 ] ], 0, 0, 0 ], generators := [ (1,2)(3,4), (1,3)(2,4) ], mat := [ [ E(3), E(4) ], [ E(3), -E(4) ], [ E(3)^2, E(4) ], [ E(3)^2, -E(4) ] ] ) gap> GaloisMat( [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ] ] ); rec( galoisfams := [ 1, [ [ 2, 3 ], [ 1, 2 ] ], 0 ], generators := [ (2,3) ], mat := [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ] )

`‣ RationalizedMat` ( mat ) | ( attribute ) |

returns the list of rationalized rows of `mat`, which must be a matrix of cyclotomics. This is the set of sums over orbits under the action of the Galois group of the entries of `mat` (see `GaloisMat`

(18.5-5)), so the operation may be viewed as a kind of trace on the rows.

Note that no two rows of `mat` should be equal.

gap> mat:= [ [ 1, 1, 1 ], [ 1, E(3), E(3)^2 ], [ 1, E(3)^2, E(3) ] ];; gap> RationalizedMat( mat ); [ [ 1, 1, 1 ], [ 2, -1, -1 ] ]

The implementation of an *internally represented cyclotomic* is based on a list of length equal to its conductor. This means that the internal representation of a cyclotomic does *not* refer to the smallest number field but the smallest *cyclotomic* field containing it. The reason for this is the wish to reflect the natural embedding of two cyclotomic fields into a larger one that contains both. With such embeddings, it is easy to construct the sum or the product of two arbitrary cyclotomics (in possibly different fields) as an element of a cyclotomic field.

The disadvantage of this approach is that the arithmetical operations are quite expensive, so the use of internally represented cyclotomics is not recommended for doing arithmetics over number fields, such as calculations with matrices of cyclotomics. But internally represented cyclotomics are good enough for dealing with irrationalities in character tables (see chapter?71).

For the representation of cyclotomics one has to recall that the n-th cyclotomic field ?(e_n) is a vector space of dimension φ(n) over the rationals where φ denotes Euler's phi-function (see?`Phi`

(15.2-2)).

A special integral basis of cyclotomic fields is chosen that allows one to easily convert arbitrary sums of roots of unity into the basis, as well as to convert a cyclotomic represented w.r.t.?the basis into the smallest possible cyclotomic field. This basis is accessible in **GAP**, see?60.3 for more information and references.

Note that the set of all n-th roots of unity is linearly dependent for n > 1, so multiplication is *not* the multiplication of the group ring ?? e_n ?; given a ?-basis of ?(e_n) the result of the multiplication (computed as multiplication of polynomials in e_n, using (e_n)^n = 1) will be converted to the basis.

gap> E(5) * E(5)^2; ( E(5) + E(5)^4 ) * E(5)^2; E(5)^3 E(5)+E(5)^3 gap> ( E(5) + E(5)^4 ) * E(5); -E(5)-E(5)^3-E(5)^4

An internally represented cyclotomic is always represented in the smallest cyclotomic field it is contained in. The internal coefficients list coincides with the external representation returned by `ExtRepOfObj`

(18.1-12).

To avoid calculations becoming unintentionally very long, or consuming very large amounts of memory, there is a limit on the conductor of internally represented cyclotomics, by default set to one million. This can be raised (although not lowered) using `SetCyclotomicsLimit`

(18.6-1) and accessed using `GetCyclotomicsLimit`

(18.6-1). The maximum value of the limit is 2^28-1 on 32 bit systems, and 2^32-1 on 64 bit systems. So the maximal cyclotomic field implemented in **GAP** is not really the field ?^ab.

It should be emphasized that one disadvantage of representing a cyclotomic in the smallest *cyclotomic* field (and not in the smallest field) is that arithmetic operations in a fixed small extension field of the rational number field are comparatively expensive. For example, take a prime integer p and suppose that we want to work with a matrix group over the field ?(sqrt{p}). Then each matrix entry could be described by two rational coefficients, whereas the representation in the smallest cyclotomic field requires p-1 rational coefficients for each entry. So it is worth thinking about using elements in a field constructed with `AlgebraicExtension`

(67.1-1) when natural embeddings of cyclotomic fields are not needed.

`‣ SetCyclotomicsLimit` ( newlimit ) | ( function ) |

`‣ GetCyclotomicsLimit` ( ) | ( function ) |

`GetCyclotomicsLimit`

returns the current limit on conductors of internally represented cyclotomic numbers

`SetCyclotomicsLimit`

can be called to increase the limit on conductors of internally represented cyclotomic numbers. Note that computing in large cyclotomic fields using this representation can be both slow and memory-consuming, and that other approaches may be better for some problems. See 18.6.

Goto Chapter: Top 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 Bib Ind

generated by GAPDoc2HTML

王中王中特免费公开资料选料