Functor that converts a commutative additive group into a multiplicative group. - Groups

Skip to content
Back to top
View this page
Edit this page

# Functor that converts a commutative additive group into a multiplicative group.

AUTHORS:

- Mark Shimozono (2013): initial version

class sage.groups.group_exp.GroupExp

  Bases: `Functor`

  A functor that converts a commutative additive group into an isomorphic multiplicative group.

  More precisely, given a commutative additive group \(G\), define the exponential of \(G\) to be the isomorphic group with elements denoted \(e^g\) for every \(g \in G\) and but with product in multiplicative notation

  \[e^g e^h = e^{g+h} \qquad\text{for all $g,h \in G$.}\]

  The class `GroupExp` implements the sage functor which sends a commutative additive group \(G\) to its exponential.

  The creation of an instance of the functor `GroupExp` requires no input:

  Sage

      sage: E = GroupExp(); E
      Functor from Category of commutative additive groups to Category of groups

  Python

      >>> from sage.all import *
      >>> E = GroupExp(); E
      Functor from Category of commutative additive groups to Category of groups

  The `GroupExp` functor (denoted \(E\) in the examples) can be applied to two kinds of input. The first is a commutative additive group. The output is its exponential. This is accomplished by `_apply_functor()`:

  Sage

      sage: EZ = E(ZZ); EZ
      Multiplicative form of Integer Ring

  [Python]

      >>> from sage.all import *
      >>> EZ = E(ZZ); EZ
      Multiplicative form of Integer Ring

  Elements of the exponentiated group can be created and manipulated as follows:

  Sage

      sage: x = EZ(-3); x
      -3
      sage: x.parent()
      Multiplicative form of Integer Ring
      sage: EZ(-1) * EZ(6) == EZ(5)
      True
      sage: EZ(3)^(-1)
      -3
      sage: EZ.one()
      0

  Python

      >>> from sage.all import *
      >>> x = EZ(-Integer(3)); x
      -3
      >>> x.parent()
      Multiplicative form of Integer Ring
      >>> EZ(-Integer(1)) * EZ(Integer(6)) == EZ(Integer(5))
      True
      >>> EZ(Integer(3))**(-Integer(1))
      -3
      >>> EZ.one()
      0

  The second kind of input the `GroupExp` functor accepts, is a homomorphism of commutative additive groups. The output is the multiplicative form of the homomorphism. This is achieved by `_apply_functor_to_morphism()`:

  Sage

      sage: L = RootSystem(['A',2]).ambient_space()
      sage: EL = E(L)
      sage: W = L.weyl_group(prefix='s')
      sage: s2 = W.simple_reflection(2)
      sage: def my_action(mu):
      ....:     return s2.action(mu)
      sage: from sage.categories.morphism import SetMorphism
      sage: from sage.categories.homset import Hom
      sage: f = SetMorphism(Hom(L, L, CommutativeAdditiveGroups()), my_action)
      sage: F = E(f); F
      Generic endomorphism of
       Multiplicative form of Ambient space of the Root system of type ['A', 2]
      sage: v = L.an_element(); v
      (2, 2, 3)
      sage: y = F(EL(v)); y
      (2, 3, 2)
      sage: y.parent()
      Multiplicative form of Ambient space of the Root system of type ['A', 2]

  [Python]

      >>> from sage.all import *
      >>> L = RootSystem(['A',Integer(2)]).ambient_space()
      >>> EL = E(L)
      >>> W = L.weyl_group(prefix='s')
      >>> s2 = W.simple_reflection(Integer(2))
      >>> def my_action(mu):
      ...     return s2.action(mu)
      >>> from sage.categories.morphism import SetMorphism
      >>> from sage.categories.homset import Hom
      >>> f = SetMorphism(Hom(L, L, CommutativeAdditiveGroups()), my_action)
      >>> F = E(f); F
      Generic endomorphism of
       Multiplicative form of Ambient space of the Root system of type ['A', 2]
      >>> v = L.an_element(); v
      (2, 2, 3)
      >>> y = F(EL(v)); y
      (2, 3, 2)
      >>> y.parent()
      Multiplicative form of Ambient space of the Root system of type ['A', 2]

class sage.groups.group_exp.GroupExpElement(parent, x)

  Bases: `ElementWrapper`, `MultiplicativeGroupElement`

  An element in the exponential of a commutative additive group.

  INPUT:

  - `self` – the exponentiated group element being created

  - `parent` – the exponential group (parent of `self`)

  - `x` – the commutative additive group element being wrapped to form `self`

  EXAMPLES:

  Sage

      sage: from sage.groups.group_exp import GroupExpElement
      sage: G = QQ^2
      sage: EG = GroupExp()(G)
      sage: z = GroupExpElement(EG, vector(QQ, (1, -3))); z
      (1, -3)
      sage: z.parent()
      Multiplicative form of Vector space of dimension 2 over Rational Field
      sage: EG(vector(QQ, (1, -3))) == z
      True

  Python

      >>> from sage.all import *
      >>> from sage.groups.group_exp import GroupExpElement
      >>> G = QQ**Integer(2)
      >>> EG = GroupExp()(G)
      >>> z = GroupExpElement(EG, vector(QQ, (Integer(1), -Integer(3)))); z
      (1, -3)
      >>> z.parent()
      Multiplicative form of Vector space of dimension 2 over Rational Field
      >>> EG(vector(QQ, (Integer(1), -Integer(3)))) == z
      True

class sage.groups.group_exp.GroupExp_Class(G)

  Bases: `UniqueRepresentation`, `Parent`

  The multiplicative form of a commutative additive group.

  INPUT:

  - `G` – a commutative additive group

  OUTPUT: the multiplicative form of \(G\)

  EXAMPLES:

  Sage

      sage: GroupExp()(QQ)
      Multiplicative form of Rational Field

  Python

      >>> from sage.all import *
      >>> GroupExp()(QQ)
      Multiplicative form of Rational Field

  Element

    alias of `GroupExpElement`

  group_generators()

    Return generators of `self`.

    EXAMPLES:

    Sage

        sage: GroupExp()(ZZ).group_generators()
        (1,)

    Python

        >>> from sage.all import *
        >>> GroupExp()(ZZ).group_generators()
        (1,)

  one()

    Return the identity element of the multiplicative group.

    EXAMPLES:

    Sage

        sage: G = GroupExp()(ZZ^2)
        sage: G.one()
        (0, 0)
        sage: x = G.an_element(); x
        (1, 0)
        sage: x == x * G.one()
        True

    Python

        >>> from sage.all import *
        >>> G = GroupExp()(ZZ**Integer(2))
        >>> G.one()
        (0, 0)
        >>> x = G.an_element(); x
        (1, 0)
        >>> x == x * G.one()
        True

  product(x, y)

    Return the product of \(x\) and \(y\) in the multiplicative group.

    EXAMPLES:

    Sage

        sage: G = GroupExp()(ZZ)
        sage: G.product(G(2),G(7))
        9
        sage: x = G(2)
        sage: x.__mul__(G(7))
        9

    Python

        >>> from sage.all import *
        >>> G = GroupExp()(ZZ)
        >>> G.product(G(Integer(2)),G(Integer(7)))
        9
        >>> x = G(Integer(2))
        >>> x.__mul__(G(Integer(7)))
        9