def __init__(self, F, x, check=True):
        """
        Create the element `x` of the FreeMonoid `F`.

        This should typically be called by a FreeMonoid.
        """
        MonoidElement.__init__(self, F)
        if isinstance(x, (int, long, Integer)):
            if x == 1:
                self._element_list = []
            else:
                raise TypeError("Argument x (= %s) is of the wrong type."%x)
        elif isinstance(x, list):
            if check:
                x2 = []
                for v in x:
                    if not isinstance(v, tuple) and len(v) == 2:
                        raise TypeError("x (= %s) must be a list of 2-tuples or 1."%x)
                    if not (isinstance(v[0], (int,long,Integer)) and \
                            isinstance(v[1], (int,long,Integer))):
                        raise TypeError("x (= %s) must be a list of 2-tuples of integers or 1."%x)
                    if len(x2) > 0 and v[0] == x2[len(x2)-1][0]:
                        x2[len(x2)-1] = (v[0], v[1]+x2[len(x2)-1][1])
                    else:
                        x2.append(v)
                self._element_list = x2
            else:
                self._element_list = list(x)  # make copy, so user can't accidentally change monoid.

        else:
            # TODO: should have some other checks here...
            raise TypeError("Argument x (= %s) is of the wrong type."%x)

    def __init__(self, F, x):
        """
        Create the element x of the FreeAbelianMonoid F.

        EXAMPLES::

            sage: F = FreeAbelianMonoid(5, 'abcde')
            sage: F
            Free abelian monoid on 5 generators (a, b, c, d, e)
            sage: F(1)
            1
            sage: a, b, c, d, e = F.gens()
            sage: a^2 * b^3 * a^2 * b^4
            a^4*b^7
            sage: F = FreeAbelianMonoid(5, 'abcde')
            sage: a, b, c, d, e = F.gens()
            sage: a in F
            True
            sage: a*b in F
            True
        """
        MonoidElement.__init__(self, F)
        n = F.ngens()
        if isinstance(x, integer_types + (Integer,)) and x == 1:
            self._element_vector = tuple([0]*n)
        elif isinstance(x, (list, tuple)):
            if len(x) != n:
                raise IndexError("argument length (= %s) must be %s"%(len(x), n))
            self._element_vector = tuple(x)
        else:
            raise TypeError("argument x (= %s) is of wrong type"%x)

    def __init__(self, F, x):
        """
        Create the element x of the FreeAbelianMonoid F.

        EXAMPLES::

            sage: F = FreeAbelianMonoid(5, 'abcde')
            sage: F
            Free abelian monoid on 5 generators (a, b, c, d, e)
            sage: F(1)
            1
            sage: a, b, c, d, e = F.gens()
            sage: a^2 * b^3 * a^2 * b^4
            a^4*b^7
            sage: F = FreeAbelianMonoid(5, 'abcde')
            sage: a, b, c, d, e = F.gens()
            sage: a in F
            True
            sage: a*b in F
            True
        """
        MonoidElement.__init__(self, F)
        self.__repr = None
        n = F.ngens()
        if isinstance(x, (int, long, Integer)) and x == 1:
            self.__element_vector = [ 0 for i in range(n) ]
        elif isinstance(x, list):
            if len(x) != n:
                raise IndexError("Argument length (= %s) must be %s."%(len(x), n))
            self.__element_vector = x
        else:
            raise TypeError("Argument x (= %s) is of wrong type."%x)

    def __init__(self, ring, gens, coerce=True):
        """
        Initialize this ideal.

        INPUT:

        - ``ring`` -- A ring

        - ``gens`` -- The generators for this ideal

        - ``coerce`` -- (default: ``True``) If ``gens`` needs to be coerced
          into ``ring``.

        EXAMPLES::

            sage: R.<x> = ZZ[]
            sage: R.ideal([4 + 3*x + x^2, 1 + x^2])
            Ideal (x^2 + 3*x + 4, x^2 + 1) of Univariate Polynomial Ring in x over Integer Ring
        """
        self.__ring = ring
        if not isinstance(gens, (list, tuple)):
            gens = [gens]
        if coerce:
            gens = [ring(x) for x in gens]

        gens = tuple(gens)
        if len(gens)==0: gens=(ring.zero(),)
        self.__gens = gens
        MonoidElement.__init__(self, ring.ideal_monoid())

    def __init__(self, F, X):
        """
        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

        """
        MonoidElement.__init__(self, F)
        self.__repr = None
        G = F.group()
        n = G.ngens()
        if isinstance(X, (int, Integer)) and X == 1:
            self.__element_vector = [ 0 for i in range(n) ]
        elif isinstance(X, list):
            if len(X) != n: 
                raise IndexError, \
                      "Argument length (= %s) must be %s."%(len(X), n)
            self.__element_vector = X
        else:
            raise TypeError, "Argument X (= %s) is of wrong type."%X

    def __init__(self, parent, mat):
        r"""
        EXAMPLES::

            sage: from sage.modular.pollack_stevens.sigma0 import Sigma0
            sage: s = Sigma0(3)([1,4,3,3]) # indirect doctest
            sage: TestSuite(s).run()
        """
        self._mat = mat
        MonoidElement.__init__(self, parent)

 def __init__(self, ring, gens, coerce=True):
     self.__ring = ring
     if not isinstance(gens, (list, tuple)):
         gens = [gens]
     if coerce:
         gens = [ring(x) for x in gens]
         
     gens = tuple(gens)
     if len(gens)==0: gens=(ring.zero_element(),)
     self.__gens = gens
     MonoidElement.__init__(self, ring.ideal_monoid())

    def __init__(self, parent, data, check=False):
        r"""
        INPUT:

        - ``parent`` - a free group

        - ``data`` - the data to be used

        - ``check`` - wether to check the consistency of the input is checked
          (default is ``True`` but it is much faster if ``check`` is set to
          ``False``)
        """
        MonoidElement.__init__(self, parent)
        if check:
            self._data = list(data)
            self._check_alphabet()
            self._reduce()
        else:
            assert isinstance(data, list)
            self._data = data

    def __init__(self, F, x):
        """
        Create the element ``x`` of an indexed free abelian monoid ``F``.

        EXAMPLES::

            sage: F = FreeAbelianMonoid(index_set=ZZ)
            sage: F.gen(1)
            F[1]
            sage: a,b,c,d,e = [F.gen(i) for i in range(5)]
            sage: x = a^2 * b^3 * a^2 * b^4; x
            F[0]^4*F[1]^7
            sage: TestSuite(x).run()

            sage: F = FreeMonoid(index_set=tuple('abcde'))
            sage: a,b,c,d,e = F.gens()
            sage: a in F
            True
            sage: a*b in F
            True
            sage: TestSuite(a*d^2*e*c*a).run()
        """
        MonoidElement.__init__(self, F)
        self._monomial = x

    def __pow__(self, n):
        r"""
        Raise this element to the power n.

        EXAMPLE::

            sage: K.<a> = NumberField(x^3 - 3*x + 8)
            sage: C=K.class_group()
            sage: c = C(2, a)
            sage: c^2
            Fractional ideal class (2, a^2 + 2*a - 1)
            sage: c^3
            Trivial principal fractional ideal class
            sage: c^1000
            Fractional ideal class (2, a)
            sage: (c^2)^2
            Fractional ideal class (2, a)
        """
        # We use MonoidElement's __pow__ routine, since that does
        # repeated squaring, and hence the ideal gets reduced as
        # we go along; actually computing self._value ** n would
        # be disastrous.
        n = n % self.order()
        return MonoidElement.__pow__(self, n)

    def __init__(self, parent, path, check=True):
        """
        Creates a path object.  Type ``QuiverPath?`` for more information.

        TESTS::

            sage: from sage.quivers.paths import QuiverPath
            sage: Q = DiGraph({1:{2:['a']}, 2:{3:['b']}}).path_semigroup()
            sage: p = Q([(1, 1), (1, 1)])
            sage: Q([(1,3,'x')])
            Traceback (most recent call last):
            ...
            ValueError: Cannot interpret [(1, 3, 'x')] as element of
            Partial semigroup formed by the directed paths of Multi-digraph on 3 vertices

        Note that QuiverPath should not be called directly, because
        the elements of the path semigroup associated with a quiver
        use a sub-class of QuiverPath. Nonetheless, just for test, we
        show that it *is* possible to create a path in a deprecated way::

            sage: p == QuiverPath(Q, (1, 1))
            True
            sage: Q([(1, 1), (1, 2, 'a'), (2, 2), (2, 3, 'b'), (3, 3)])._path
            ((1, 2, 'a'), (2, 3, 'b'))
        """
        MonoidElement.__init__(self, parent=parent)

        # Normalise the given path, unless it is asserted that the input is
        # fine
        if not check:
            self._path = tuple(path)
            return
        if path == 1:
            # We do not guarantee that there is only one vertex.
            # However, this element certainly exists.
            v = parent.quiver().vertices()[0]
            self._path = ((v,v),)
            return
        E = parent.quiver().edges()
        if isinstance(path, QuiverPath):
            if path.parent() is parent:
                self._path = path._path
                return
            new_path = list(path._path)
        # A tuple is assumed to be an edge, anything else is assumed to be a
        # list of edges
        elif isinstance(path, tuple):
            new_path = [path]
        else:
            new_path = list(path)

        # Check that each edge in the path is valid
        good = True
        for x in new_path:
            if (len(x) < 2 or x[0] not in ZZ or x[1] not in ZZ
                           or len(x) == 2 and x[0] != x[1]
                           or len(x) == 3 and x not in E
                           or len(x) > 3):
                good = False
                break
        if not good:
            raise ValueError("Cannot interpret %s as element of %s"%(path,parent))
        # Delete trivial edges, and clear the path if not valid
        i = 0
        while i + 1 < len(new_path):
            if new_path[i][1] != new_path[i + 1][0]:
                raise ValueError("Cannot interpret %s as element of %s"%(path,parent))
            elif len(new_path[i])!=3:
                del new_path[i]
            else:
                i += 1
        if len(new_path) > 1 and len(new_path[-1])!=3:
            del new_path[-1]
        self._path = tuple(new_path)