passagemath-groups 10.6.41__cp314-cp314t-musllinux_1_2_x86_64.whl

sage/groups/group_exp.py

@@ -0,0 +1,360 @@
+# sage_setup: distribution = sagemath-groups
+r"""
+Functor that converts a commutative additive group into a multiplicative group.
+
+AUTHORS:
+
+- Mark Shimozono (2013): initial version
+"""
+# ***************************************************************************
+#       Copyright (C) 2013 <mshimo at math.vt.edu>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from sage.categories.commutative_additive_groups import CommutativeAdditiveGroups
+from sage.categories.functor import Functor
+from sage.categories.groups import Groups
+from sage.categories.homset import Hom
+from sage.categories.morphism import SetMorphism
+from sage.structure.element import MultiplicativeGroupElement
+from sage.structure.element_wrapper import ElementWrapper
+from sage.structure.parent import Parent
+from sage.structure.unique_representation import UniqueRepresentation
+
+
+class GroupExp(Functor):
+    r"""
+    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
+
+    .. MATH::
+
+        e^g e^h = e^{g+h} \qquad\text{for all $g,h \in G$.}
+
+    The class :class:`GroupExp` implements the sage functor which sends a commutative
+    additive group `G` to its exponential.
+
+    The creation of an instance of the functor :class:`GroupExp` requires no input::
+
+        sage: E = GroupExp(); E
+        Functor from Category of commutative additive groups to Category of groups
+
+    The :class:`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 :meth:`_apply_functor`::
+
+        sage: EZ = E(ZZ); EZ
+        Multiplicative form of Integer Ring
+
+    Elements of the exponentiated group can be created and manipulated as follows::
+
+        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
+
+    The second kind of input the :class:`GroupExp` functor accepts, is a homomorphism of commutative additive groups.
+    The output is the multiplicative form of the homomorphism. This is achieved by :meth:`_apply_functor_to_morphism`::
+
+        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]
+    """
+    def __init__(self):
+        r"""
+        Initialize the :class:`GroupExp` functor.
+
+        EXAMPLES::
+
+            sage: F = GroupExp()
+            sage: F.domain()
+            Category of commutative additive groups
+            sage: F.codomain()
+            Category of groups
+        """
+        Functor.__init__(self, CommutativeAdditiveGroups(), Groups())
+
+    def _apply_functor(self, x):
+        r"""
+        Given a commutative additive group, return the isomorphic
+        multiplicative group.
+
+        INPUT:
+
+        - A commutative additive group `x`
+
+        OUTPUT: an isomorphic group whose operation is multiplication rather
+        than addition
+
+        In the following example, ``self`` is the functor ``GroupExp()``,
+        ``x`` is the additive group ``QQ^2``, and the output group is stored as ``EQ2``.
+
+        EXAMPLES::
+
+            sage: EQ2 = GroupExp()(QQ^2)
+            sage: x = EQ2(vector(QQ,(-2,1))); x
+            (-2, 1)
+            sage: x^(-1)
+            (2, -1)
+            sage: x*x
+            (-4, 2)
+            sage: EQ2(vector(QQ,(-1,1)))*EQ2(vector(QQ,(3,4))) == EQ2(vector(QQ,(2,5)))
+            True
+            sage: EQ2.one()
+            (0, 0)
+        """
+        return GroupExp_Class(x)
+
+    def _apply_functor_to_morphism(self, f):
+        r"""
+        Given a morphism of commutative additive groups, return the corresponding morphism
+        of multiplicative groups.
+
+        INPUT:
+
+        - A homomorphism `f` of commutative additive groups
+
+        OUTPUT: the above homomorphism, but between the corresponding
+        multiplicative groups
+
+        In the following example, ``self`` is the functor :class:`GroupExp` and `f`
+        is an endomorphism of the additive group of integers.
+
+        EXAMPLES::
+
+            sage: def double(x):
+            ....:     return x + x
+            sage: from sage.categories.morphism import SetMorphism
+            sage: from sage.categories.homset import Hom
+            sage: f = SetMorphism(Hom(ZZ, ZZ, CommutativeAdditiveGroups()), double)
+            sage: E = GroupExp()
+            sage: EZ = E._apply_functor(ZZ)
+            sage: F = E._apply_functor_to_morphism(f)
+            sage: F.domain() == EZ
+            True
+            sage: F.codomain() == EZ
+            True
+            sage: F(EZ(3)) == EZ(3) * EZ(3)
+            True
+        """
+        new_domain = self._apply_functor(f.domain())
+        new_codomain = self._apply_functor(f.codomain())
+
+        def new_f(a):
+            return new_codomain(f(a.value))
+
+        return SetMorphism(Hom(new_domain, new_codomain, Groups()), new_f)
+
+
+class GroupExpElement(ElementWrapper, MultiplicativeGroupElement):
+    r"""
+    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: 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
+    """
+    def __init__(self, parent, x):
+        r"""
+        EXAMPLES::
+
+            sage: G = QQ^2
+            sage: EG = GroupExp()(G)
+            sage: x = EG.an_element(); x
+            (1, 0)
+            sage: TestSuite(x).run(skip="_test_category")
+
+        See the documentation of :meth:`sage.structure.element_wrapper.ElementWrapper.__init__`
+        for the reason behind skipping the category test.
+        """
+        if x not in parent._G:
+            raise ValueError("%s is not an element of %s" % (x, parent._G))
+        ElementWrapper.__init__(self, parent, x)
+
+    def __invert__(self):
+        r"""
+        Invert the element ``self``.
+
+        EXAMPLES::
+
+            sage: EZ = GroupExp()(ZZ)
+            sage: EZ(-3).inverse()  # indirect doctest
+            3
+        """
+        return GroupExpElement(self.parent(), -self.value)
+
+    def __mul__(self, x):
+        r"""
+        Multiply ``self`` by `x`.
+
+        EXAMPLES::
+
+            sage: G = GroupExp()(ZZ)
+            sage: x = G(2)
+            sage: x.__mul__(G(3))
+            5
+            sage: G.product(G(2), G(3))
+            5
+        """
+        return GroupExpElement(self.parent(), self.value + x.value)
+
+
+class GroupExp_Class(UniqueRepresentation, Parent):
+    r"""
+    The multiplicative form of a commutative additive group.
+
+    INPUT:
+
+    - ``G`` -- a commutative additive group
+
+    OUTPUT: the multiplicative form of `G`
+
+    EXAMPLES::
+
+        sage: GroupExp()(QQ)
+        Multiplicative form of Rational Field
+    """
+    def __init__(self, G) -> None:
+        r"""
+
+        EXAMPLES::
+
+            sage: EG = GroupExp()(QQ^2)
+            sage: TestSuite(EG).run(skip="_test_elements")
+        """
+        if G not in CommutativeAdditiveGroups():
+            raise TypeError("%s must be a commutative additive group" % G)
+        self._G = G
+        Parent.__init__(self, category=Groups())
+
+    def _repr_(self) -> str:
+        r"""
+        Return a string describing the multiplicative form of a commutative additive group.
+
+        EXAMPLES::
+
+            sage: GroupExp()(ZZ) # indirect doctest
+            Multiplicative form of Integer Ring
+        """
+        return "Multiplicative form of %s" % self._G
+
+    def _element_constructor_(self, x):
+        r"""
+        Construct the multiplicative group element, which wraps the additive
+        group element `x`.
+
+        EXAMPLES::
+
+            sage: G = GroupExp()(ZZ)
+            sage: G(4)  # indirect doctest
+            4
+        """
+        return GroupExpElement(self, x)
+
+    def one(self):
+        r"""
+        Return the identity element of the multiplicative group.
+
+        EXAMPLES::
+
+            sage: G = GroupExp()(ZZ^2)
+            sage: G.one()
+            (0, 0)
+            sage: x = G.an_element(); x
+            (1, 0)
+            sage: x == x * G.one()
+            True
+        """
+        return GroupExpElement(self, self._G.zero())
+
+    def _an_element_(self):
+        r"""
+        Return an element of the multiplicative group.
+
+        EXAMPLES::
+
+            sage: L = RootSystem(['A',2]).weight_lattice()
+            sage: EL = GroupExp()(L)
+            sage: x = EL.an_element(); x
+            2*Lambda[1] + 2*Lambda[2]
+            sage: x.parent()
+            Multiplicative form of Weight lattice of the Root system of type ['A', 2]
+        """
+        return GroupExpElement(self, self._G.an_element())
+
+    def product(self, x, y):
+        r"""
+        Return the product of `x` and `y` in the multiplicative group.
+
+        EXAMPLES::
+
+            sage: G = GroupExp()(ZZ)
+            sage: G.product(G(2),G(7))
+            9
+            sage: x = G(2)
+            sage: x.__mul__(G(7))
+            9
+        """
+        return GroupExpElement(self, x.value + y.value)
+
+    def group_generators(self):
+        r"""
+        Return generators of ``self``.
+
+        EXAMPLES::
+
+            sage: GroupExp()(ZZ).group_generators()
+            (1,)
+        """
+        if hasattr(self._G, 'gens'):
+            additive_generators = self._G.gens()
+        else:
+            raise AttributeError("Additive group has no method 'gens'")
+        return tuple([self(x) for x in additive_generators])
+
+
+GroupExp_Class.Element = GroupExpElement