Class DualAbelianGroupElement

Create an element X of the DualAbelianGroup of F.

EXAMPLES:
    sage: F = AbelianGroup(3,[7,8,9])
    sage: Fd = DualAbelianGroup(F,names="ABC")
    sage: A,B,C = Fd.gens()
    sage: A*B^-1 in Fd
    True

Overrides: structure.element.Element.__init__

Return (a reference to) the underlying list used to represent
this element.  If this is a word in an abelian group on $n$
generators, then this is a list of nonnegative integers of
length $n$.

EXAMPLES:
    sage: F = AbelianGroup(5,[2, 3, 5, 7, 8], names="abcde")
    sage: a,b,c,d,e = F.gens()
    sage: Ad = DualAbelianGroup(F, names = "ABCDE")
    sage: A,B,C,D,E = Ad.gens()
    sage: (A*B*C^2*D^20*E^65).list()
    [1, 1, 2, 6, 1]
    sage: X = A*B*C^2*D^2*E^-6
    sage: X.list()
    [1, 1, 2, 2, 2]
    sage: X.list()[1] = -1
    sage: X
    A*B^-1*C^2*D^2*E^2

File: sage/structure/element.pyx (starting at line 291)

Overrides: structure.element.Element._repr_

(inherited documentation)

File: sage/structure/element.pyx (starting at line 1073)

Top-level multiplication operator for monoid elements.
See extensive documentation at the top of element.pyx.

Overrides: structure.element.MonoidElement.__mul__

(inherited documentation)

requires that len(invs) = n

Overrides: structure.element.MonoidElement.__pow__

cmp(x,y)

Overrides: structure.element.Element.__cmp__

(inherited documentation)

Returns the (finite) order of this element.

EXAMPLES:
    sage: F = AbelianGroup(3,[7,8,9])
    sage: Fd = DualAbelianGroup(F)
    sage: A,B,C = Fd.gens()
    sage: (B*C).order()
    72

Overrides: structure.element.MonoidElement.order

Computes the value of a character self on a group element
g (g must be an element of self.group())

EXAMPLES:
    sage: F = AbelianGroup(5, [2,3,5,7,8], names="abcde")
    sage: a,b,c,d,e = F.gens()
    sage: Fd = DualAbelianGroup(F, names="ABCDE")
    sage: A,B,C,D,E = Fd.gens()
    sage: A*B^2*D^7
    A*B^2
    sage: A(a)    ## random last few digits
    -1.0000000000000000 + 0.00000000000000013834419720915037*I
    sage: B(b)    ## random last few digits
    -0.49999999999999983 + 0.86602540378443871*I
    sage: A(a*b)    ## random last few digits
    -1.0000000000000000 + 0.00000000000000013834419720915037*I

This is a rather hackish method and is included for completeness.

The word problem for an instance of DualAbelianGroup as it can
for an AbelianGroup. The reason why is that word problem
for an instance of AbelianGroup simply calls GAP (which
has abelian groups implemented) and invokes "EpimorphismFromFreeGroup"
and "PreImagesRepresentative". GAP does not have duals of
abelian groups implemented. So, by using the same name
for the generators, the method below converts the problem for
the dual group to the corresponding problem on the group
itself and uses GAP to solve that.

EXAMPLES:
    sage: G = AbelianGroup(5,[3, 5, 5, 7, 8],names="abcde")
    sage: Gd = DualAbelianGroup(G,names="abcde")
    sage: a,b,c,d,e = Gd.gens()
    sage: u = a^3*b*c*d^2*e^5
    sage: v = a^2*b*c^2*d^3*e^3
    sage: w = a^7*b^3*c^5*d^4*e^4
    sage: x = a^3*b^2*c^2*d^3*e^5
    sage: y = a^2*b^4*c^2*d^4*e^5
    sage: e.word_problem([u,v,w,x,y],display=False)
    [[b^2*c^2*d^3*e^5, 245]]

The command e.word_problem([u,v,w,x,y],display=True) returns
the same list but also prints $e = (b^2*c^2*d^3*e^5)^245$.