The basic idea is very simple. Let G be an abelian group and its
dual (i.e., the group of homomorphisms from G to
). Let
,
, denote generators of
- say
is of order
. There are generators
,
, of
for which
and
if
. These are
used to construct
.
Sage supports multiplicative abelian groups on any prescribed finite
number of generators. Use
AbelianGroup() function
to create an abelian group, the
dual_group()
method to create its dual, and then the gen() and gens()
methods to obtain the corresponding generators. You can print the
generators as arbitrary strings using the optional names argument
to the
dual_group()
method.
EXAMPLES:
sage: F = AbelianGroup(5, [2,5,7,8,9], names='abcde')
sage: (a, b, c, d, e) = F.gens()
sage: Fd = F.dual_group(names='ABCDE')
sage: Fd.base_ring()
Cyclotomic Field of order 2520 and degree 576
sage: A,B,C,D,E = Fd.gens()
sage: A(a)
-1
sage: A(b), A(c), A(d), A(e)
(1, 1, 1, 1)
sage: Fd = F.dual_group(names='ABCDE', base_ring=CC)
sage: A,B,C,D,E = Fd.gens()
sage: A(a) # abs tol 1e-8
-1.00000000000000 + 0.00000000000000*I
sage: A(b); A(c); A(d); A(e)
1.00000000000000
1.00000000000000
1.00000000000000
1.00000000000000
AUTHORS:
Bases: sage.structure.unique_representation.UniqueRepresentation, sage.groups.group.AbelianGroup
Dual of abelian group.
EXAMPLES:
sage: F = AbelianGroup(5,[3,5,7,8,9], names="abcde")
sage: F.dual_group()
Dual of Abelian Group isomorphic to Z/3Z x Z/5Z x Z/7Z x Z/8Z x Z/9Z
over Cyclotomic Field of order 2520 and degree 576
sage: F = AbelianGroup(4,[15,7,8,9], names="abcd")
sage: F.dual_group(base_ring=CC)
Dual of Abelian Group isomorphic to Z/15Z x Z/7Z x Z/8Z x Z/9Z
over Complex Field with 53 bits of precision
alias of DualAbelianGroupElement
Return the scalars over which the group is dualized.
EXAMPLES:
sage: F = AbelianGroup(3,[5,64,729], names=list("abc"))
sage: Fd = F.dual_group(base_ring=CC)
sage: Fd.base_ring()
Complex Field with 53 bits of precision
The -th generator of the abelian group.
EXAMPLES:
sage: F = AbelianGroup(3,[1,2,3],names='a')
sage: Fd = F.dual_group(names="A")
sage: Fd.0
1
sage: Fd.1
A1
sage: Fd.gens_orders()
(1, 2, 3)
Return the generators for the group.
OUTPUT:
A tuple of group elements generating the group.
EXAMPLES:
sage: F = AbelianGroup([7,11]).dual_group()
sage: F.gens()
(X0, X1)
The orders of the generators of the dual group.
OUTPUT:
A tuple of integers.
EXAMPLES:
sage: F = AbelianGroup([5]*1000)
sage: Fd = F.dual_group()
sage: invs = Fd.gens_orders(); len(invs)
1000
Return the group that self is the dual of.
EXAMPLES:
sage: F = AbelianGroup(3,[5,64,729], names=list("abc"))
sage: Fd = F.dual_group(base_ring=CC)
sage: Fd.group() is F
True
The invariants of the dual group.
You should use gens_orders() instead.
EXAMPLES:
sage: F = AbelianGroup([5]*1000)
sage: Fd = F.dual_group()
sage: invs = Fd.gens_orders(); len(invs)
1000
Return True since this group is commutative.
EXAMPLES:
sage: G = AbelianGroup([2,3,9])
sage: Gd = G.dual_group()
sage: Gd.is_commutative()
True
sage: Gd.is_abelian()
True
Return tuple of all elements of this group.
EXAMPLES:
sage: G = AbelianGroup([2,3], names="ab")
sage: Gd = G.dual_group(names="AB")
sage: Gd.list()
(1, B, B^2, A, A*B, A*B^2)
The number of generators of the dual group.
EXAMPLES:
sage: F = AbelianGroup([7]*100)
sage: Fd = F.dual_group()
sage: Fd.ngens()
100
Return the order of this group.
EXAMPLES:
sage: G = AbelianGroup([2,3,9])
sage: Gd = G.dual_group()
sage: Gd.order()
54
Return a random element of this dual group.
EXAMPLES:
sage: G = AbelianGroup([2,3,9])
sage: Gd = G.dual_group(base_ring=CC)
sage: Gd.random_element()
X1^2
sage: N = 43^2-1
sage: G = AbelianGroup([N],names="a")
sage: Gd = G.dual_group(names="A", base_ring=CC)
sage: a, = G.gens()
sage: A, = Gd.gens()
sage: x = a^(N/4); y = a^(N/3); z = a^(N/14)
sage: X = A*Gd.random_element(); X
A^615
sage: len([a for a in [x,y,z] if abs(X(a)-1)>10^(-8)])
2
Return True if is the dual group of an abelian group.
EXAMPLES:
sage: from sage.groups.abelian_gps.dual_abelian_group import is_DualAbelianGroup
sage: F = AbelianGroup(5,[3,5,7,8,9], names=list("abcde"))
sage: Fd = F.dual_group()
sage: is_DualAbelianGroup(Fd)
True
sage: F = AbelianGroup(3,[1,2,3], names='a')
sage: Fd = F.dual_group()
sage: Fd.gens()
(1, X1, X2)
sage: F.gens()
(1, a1, a2)