### Navigation

- index
- modules |
- next |
- previous |
- Monoids »

# Free abelian monoids

AUTHORS:

- David Kohel (2005-09)

Sage supports free abelian monoids on any prescribed finite number \(n\geq 0\) of generators. Use the `FreeAbelianMonoid` function to create a free abelian monoid, and the `gen` and `gens` functions to obtain the corresponding generators. You can print the generators as arbitrary strings using the optional `names` argument to the `FreeAbelianMonoid` function.

EXAMPLE 1: It is possible to create an abelian monoid in zero or more variables; the syntax T(1) creates the monoid identity element even in the rank zero case.

    sage: T = FreeAbelianMonoid(0, '')
    sage: T
    Free abelian monoid on 0 generators ()
    sage: T.gens()
    ()
    sage: T(1)
    1

EXAMPLE 2: A free abelian monoid uses a multiplicative representation of elements, but the underlying representation is lists of integer exponents.

    sage: F = FreeAbelianMonoid(5,names='a,b,c,d,e')
    sage: (a,b,c,d,e) = F.gens()
    sage: a*b^2*e*d
    a*b^2*d*e
    sage: x = b^2*e*d*a^7
    sage: x
    a^7*b^2*d*e
    sage: x.list()
    [7, 2, 0, 1, 1]

`sage.monoids.free_abelian_monoid.``FreeAbelianMonoid`(index_set=None, names=None, **kwds)

  Return a free abelian monoid on \(n\) generators or with the generators indexed by a set \(I\).

  We construct free abelian monoids by specifing either:

  - the number of generators and/or the names of the generators
  - the indexing set for the generators (this ignores the other two inputs)

  INPUT:

  - `index_set` – an indexing set for the generators; if an integer, then this becomes \(\{0, 1, \ldots, n-1\}\)
  - `names` – names of generators

  OUTPUT:

  A free abelian monoid.

  EXAMPLES:

      sage: F.<a,b,c,d,e> = FreeAbelianMonoid(); F
      Free abelian monoid on 5 generators (a, b, c, d, e)
      sage: FreeAbelianMonoid(index_set=ZZ)
      Free abelian monoid indexed by Integer Ring

class `sage.monoids.free_abelian_monoid.``FreeAbelianMonoidFactory`

  Bases: `sage.structure.factory.UniqueFactory`

  Create the free abelian monoid in \(n\) generators.

  INPUT:

  - `n` - integer
  - `names` - names of generators

  OUTPUT: free abelian monoid

  EXAMPLES:

      sage: FreeAbelianMonoid(0, '')
      Free abelian monoid on 0 generators ()
      sage: F = FreeAbelianMonoid(5,names = list("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: mul([ a, b, a, c, b, d, c, d ], F(1))
      a^2*b^2*c^2*d^2
      sage: a**2 * b**3 * a**2 * b**4
      a^4*b^7

      sage: loads(dumps(F)) is F
      True

  `create_key`(n, names)

    x.__init__(...) initializes x; see help(type(x)) for signature

  `create_object`(version, key)

    x.__init__(...) initializes x; see help(type(x)) for signature

class `sage.monoids.free_abelian_monoid.``FreeAbelianMonoid_class`(n, names)

  Bases: `sage.structure.parent_gens.ParentWithGens`

  Free abelian monoid on \(n\) generators.

  `cardinality`()

    Return the cardinality of `self`, which is \(\infty\).

    EXAMPLES:

        sage: F = FreeAbelianMonoid(3000, 'a')
        sage: F.cardinality()
        +Infinity

  `gen`(i=0)

    The \(i\)-th generator of the abelian monoid.

    EXAMPLES:

        sage: F = FreeAbelianMonoid(5,'a')
        sage: F.gen(0)
        a0
        sage: F.gen(2)
        a2

  `ngens`()

    The number of free generators of the abelian monoid.

    EXAMPLES:

        sage: F = FreeAbelianMonoid(3000, 'a')
        sage: F.ngens()
        3000

`sage.monoids.free_abelian_monoid.``is_FreeAbelianMonoid`(x)

  Return True if \(x\) is a free abelian monoid.

  EXAMPLES:

      sage: from sage.monoids.free_abelian_monoid import is_FreeAbelianMonoid
      sage: is_FreeAbelianMonoid(5)
      False
      sage: is_FreeAbelianMonoid(FreeAbelianMonoid(7,'a'))
      True
      sage: is_FreeAbelianMonoid(FreeMonoid(7,'a'))
      False
      sage: is_FreeAbelianMonoid(FreeMonoid(0,''))
      False

### Navigation

- index
- modules |
- next |
- previous |
- Monoids »