passagemath-combinat 10.6.42__cp314-cp314-musllinux_1_2_x86_64.whl

sage/combinat/crystals/virtual_crystal.py

@@ -0,0 +1,420 @@
+# sage_setup: distribution = sagemath-combinat
+# sage.doctest: needs sage.combinat sage.graphs sage.modules
+r"""
+Virtual crystals
+
+These are the crystals that are subsets of a larger ambient crystal with
+virtual crystal operators.
+
+AUTHORS:
+
+- Travis Scrimshaw (2013-10-16): initial implementation
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2013 Travis Scrimshaw <tscrim at ucdavis.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#    This code is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#    General Public License for more details.
+#
+#  The full text of the GPL is available at:
+#
+#                  http://www.gnu.org/licenses/
+#****************************************************************************
+from sage.categories.crystals import Crystals
+from sage.categories.finite_crystals import FiniteCrystals
+from sage.combinat.root_system.cartan_type import CartanType
+from sage.combinat.crystals.subcrystal import Subcrystal
+from sage.sets.family import Family
+
+
+class VirtualCrystal(Subcrystal):
+    r"""
+    A virtual crystal `V` of an ambient crystal `\widehat{B}` is a crystal
+    formed by taking a subset of `\widehat{B}` and whose crystal structure
+    is given by
+
+    .. MATH::
+
+        e_i = \prod_{j \in \sigma_i} \widehat{e}_j^{\gamma_i}, \quad
+        f_i = \prod_{j \in \sigma_i} \widehat{f}_j^{\gamma_i},
+
+    .. MATH::
+
+        \varepsilon_i = \frac{\widehat{\varepsilon}_j}{\gamma_j}, \quad
+        \varphi_i = \frac{\widehat{\varphi}_j}{\gamma_j}, \quad
+        \operatorname{wt} = \Psi^{-1} \circ \widehat{\operatorname{wt}}
+
+    where `\sigma_i` is a subset of the index set of `B`, `\gamma_i \in \ZZ`
+    are the *scaling factors*, and `\Psi : P \to \widehat{P}` is an embedding
+    of the weight lattices. We note that for the crystal to be well-defined,
+    we must have
+
+    .. MATH::
+
+        \widehat{\varepsilon}_j = \widehat{\varepsilon|j^{\prime}},
+        \quad \widehat{\varphi}_j = \widehat{\varphi}_{j^{\prime}}
+
+    for all `j, j^{\prime} \in \sigma_i` and that the order that the Kashiwara
+    operators in the ambient space are applied does not affect the result.
+
+    INPUT:
+
+    - ``ambient`` -- the ambient crystal
+    - ``virtualization`` -- dictionary whose key `i` corresponds
+      to the set `\sigma_i`
+    - ``scaling_factors`` -- dictionary whose key `i` corresponds to
+      the scaling factor `\gamma_i`
+    - ``contained`` -- (optional) a set (or function) which specifies when an
+      element is contained in the subcrystal; the default is everything
+      possible is included
+    - ``generators`` -- (optional) the generators for the virtual crystal; the
+      default is the generators for the ambient crystal
+    - ``cartan_type`` -- (optional) the Cartan type for the virtual crystal;
+      the default is the Cartan type for the ambient crystal
+    - ``index_set`` -- (optional) the index set for the virtual crystal; the
+      default is the index set for the Cartan type
+    - ``category`` -- (optional) the category for the virtual crystal; the
+      default is the :class:`~sage.categories.crystals.Crystals` category
+
+    EXAMPLES:
+
+    We construct an example from a natural virtualization map of type `C_n`
+    in type `A_{2n-1}`::
+
+        sage: C = crystals.Tableaux(['C',2], shape=[1])
+        sage: A = crystals.Tableaux(['A',3], shape=[2,1,1])
+        sage: psi = C.crystal_morphism(A.module_generators)
+        sage: V = psi.image()
+        sage: list(V)
+        [[[1, 1], [2], [3]],
+         [[1, 2], [2], [4]],
+         [[1, 3], [3], [4]],
+         [[2, 4], [3], [4]]]
+        sage: V.digraph().is_isomorphic(C.digraph(), edge_labels=True)
+        True
+
+    We construct the virtualization of a `U_q'(\mathfrak{g})`-crystal
+    `B^{r,s}` of type `C_n^{(1)}` in type `A_{2n+1}^{(2)}`. Here it is not
+    a default folding known to Sage, so we have to explicitly state the
+    folding (since the scaling factors are not specified, they are all
+    assumed to be 1)::
+
+        sage: K = crystals.KirillovReshetikhin(['C',2,1], 1,1)
+        sage: VK = crystals.KirillovReshetikhin(['A',5,2], 1,1)
+        sage: target = VK.module_generator().f(1); target
+        [[2]]
+        sage: psi = K.crystal_morphism({K.module_generator(): target},
+        ....:                          virtualization={0:[0,1], 1:[2], 2:[3]})
+        sage: V = psi.image()
+        sage: list(V)
+        [[[2]], [[3]], [[-2]], [[-3]]]
+        sage: V.digraph().is_isomorphic(K.digraph(), edge_labels=True)
+        True
+
+    We create an example of `B(\Lambda_n)` of type `B_n` inside
+    of `B(2\Lambda_n)` using the doubling map through the (virtual)
+    subcrystal method::
+
+        sage: BB = crystals.Tableaux(['B',3], shape=[1,1,1])
+        sage: S = BB.subcrystal(scaling_factors={1:2, 2:2, 3:2})
+        sage: B = crystals.Tableaux(['B',3], shape=[1/2,1/2,1/2])
+        sage: S.digraph().is_isomorphic(B.digraph(), edge_labels=True)
+        True
+
+    We can also directly construct a virtual crystal using
+    :class:`VirtualCrystal` (however it is recommended to use either
+    :meth:`~sage.categories.crystals.Crystals.ParentMethods.crystal_morphism`
+    or :meth:`~sage.categories.crystals.Crystals.ParentMethods.subcrystal`)::
+
+        sage: from sage.combinat.crystals.virtual_crystal import VirtualCrystal
+        sage: A = crystals.Tableaux(['A',3], shape=[2,1,1])
+        sage: V = VirtualCrystal(A, {1:(1,3), 2:(2,)}, {1:1, 2:2}, cartan_type=['C',2])
+        sage: G = crystals.Tableaux(['C',2], shape=[1]).digraph()
+        sage: V.digraph().is_isomorphic(G, edge_labels=True)
+        True
+
+        sage: C1 = crystals.Tableaux(['A',3], shape=[1])
+        sage: C2 = crystals.Tableaux(['A',3], shape=[1,1,1])
+        sage: T = C1.tensor(C2)
+        sage: mg = T(C1.module_generators[0], C2.module_generators[0])
+        sage: V = VirtualCrystal(A, {1:(1,3), 2:(2,)}, {1:1, 2:2},
+        ....:                    cartan_type=['C',2], generators=[mg])
+        sage: V.digraph().is_isomorphic(G, edge_labels=True)
+        True
+
+    REFERENCES:
+
+    - [FOS2009]_
+    - [OSS03]_
+    - [OSS2003]_
+    """
+    @staticmethod
+    def __classcall_private__(cls, ambient, virtualization, scaling_factors,
+                              contained=None, generators=None,
+                              cartan_type=None, index_set=None, category=None):
+        """
+        Normalize arguments to ensure a unique representation.
+
+        EXAMPLES::
+
+            sage: B = crystals.Tableaux(['B',3], shape=[1])
+            sage: C = crystals.Tableaux(['D',4], shape=[2])
+            sage: psi1 = B.crystal_morphism(C.module_generators)
+            sage: V1 = psi1.image()
+            sage: psi2 = B.crystal_morphism(C.module_generators, index_set=[1,2,3])
+            sage: V2 = psi2.image()
+            sage: V1 is V2
+            True
+
+        TESTS:
+
+        Check that :issue:`19481` is fixed::
+
+            sage: from sage.combinat.crystals.virtual_crystal import VirtualCrystal
+            sage: A = crystals.Tableaux(['A',3], shape=[2,1,1])
+            sage: V = VirtualCrystal(A, {1:(1,3), 2:(2,)}, {1:1, 2:2}, cartan_type=['C',2])
+            sage: V.category()
+            Category of finite crystals
+        """
+        if cartan_type is None:
+            cartan_type = ambient.cartan_type()
+        else:
+            cartan_type = CartanType(cartan_type)
+        if index_set is None:
+            index_set = cartan_type.index_set()
+        if generators is None:
+            generators = ambient.module_generators
+        virtualization = Family(virtualization)
+        scaling_factors = Family(scaling_factors)
+
+        category = Crystals().or_subcategory(category)
+        if ambient in FiniteCrystals() or isinstance(contained, frozenset):
+            category = category.Finite()
+
+        return super().__classcall__(cls, ambient, virtualization,
+                                     scaling_factors, contained,
+                                     tuple(generators), cartan_type,
+                                     tuple(index_set), category)
+
+    def __init__(self, ambient, virtualization, scaling_factors,
+                 contained, generators, cartan_type, index_set, category):
+        """
+        Initialize ``self``.
+
+        EXAMPLES::
+
+            sage: B = crystals.Tableaux(['B',3], shape=[1])
+            sage: C = crystals.Tableaux(['D',4], shape=[2])
+            sage: psi = B.crystal_morphism(C.module_generators)
+            sage: V = psi.image()
+            sage: TestSuite(V).run()
+        """
+        self._virtualization = virtualization
+        self._scaling_factors = scaling_factors
+        Subcrystal.__init__(self, ambient, contained, generators,
+                            cartan_type, index_set, category)
+
+    def _repr_(self):
+        """
+        Return a string representation of ``self``.
+
+        EXAMPLES::
+
+            sage: B = crystals.Tableaux(['B',3], shape=[1])
+            sage: C = crystals.Tableaux(['D',4], shape=[2])
+            sage: psi = B.crystal_morphism(C.module_generators)
+            sage: psi.image()
+            Virtual crystal of The crystal of tableaux of type ['D', 4] and shape(s) [[2]] of type ['B', 3]
+        """
+        return "Virtual crystal of {} of type {}".format(self._ambient, self._cartan_type)
+
+    def __contains__(self, x):
+        """
+        Check if ``x`` is in ``self``.
+
+        EXAMPLES::
+
+            sage: B = crystals.Tableaux(['B',3], shape=[1])
+            sage: C = crystals.Tableaux(['D',4], shape=[2])
+            sage: psi = B.crystal_morphism(C.module_generators)
+            sage: V = psi.image()
+            sage: mg = C.module_generators[0]
+            sage: mg in V
+            True
+            sage: mg.f(1) in V
+            False
+            sage: mg.f(1).f(1) in V
+            True
+        """
+        if not Subcrystal.__contains__(self, x):
+            return False
+        if self in FiniteCrystals():
+            if isinstance(x, self._ambient.element_class):
+                if x.parent() == self:
+                    x = self.element_class(self, self._ambient(x))
+                elif x.parent() == self._ambient:
+                    x = self.element_class(self, self._ambient(x))
+            elif isinstance(x, self.element_class) and x.parent() != self:
+                x = self.element_class(self, x.value)
+            return x in self.list()
+        return True
+
+    def virtualization(self):
+        r"""
+        Return the virtualization sets `\sigma_i`.
+
+        EXAMPLES::
+
+            sage: B = crystals.Tableaux(['B',3], shape=[1])
+            sage: C = crystals.Tableaux(['D',4], shape=[2])
+            sage: psi = B.crystal_morphism(C.module_generators)
+            sage: V = psi.image()
+            sage: V.virtualization()
+            Finite family {1: (1,), 2: (2,), 3: (3, 4)}
+        """
+        return self._virtualization
+
+    def scaling_factors(self):
+        r"""
+        Return the scaling factors `\gamma_i`.
+
+        EXAMPLES::
+
+            sage: B = crystals.Tableaux(['B',3], shape=[1])
+            sage: C = crystals.Tableaux(['D',4], shape=[2])
+            sage: psi = B.crystal_morphism(C.module_generators)
+            sage: V = psi.image()
+            sage: V.scaling_factors()
+            Finite family {1: 2, 2: 2, 3: 1}
+        """
+        return self._scaling_factors
+
+    class Element(Subcrystal.Element):
+        """
+        An element of a virtual (sub)crystal. Wraps an element in the
+        ambient crystal.
+        """
+
+        def e(self, i):
+            """
+            Return `e_i` of ``self``.
+
+            EXAMPLES::
+
+                sage: B = crystals.Tableaux(['B',3], shape=[1])
+                sage: C = crystals.Tableaux(['D',4], shape=[2])
+                sage: psi = B.crystal_morphism(C.module_generators)
+                sage: V = psi.image()
+                sage: mg = V.module_generators[0]
+                sage: mg.e(1)
+                sage: b = psi(B.module_generators[0].f(1))
+                sage: V(b).e(1)
+                [[1, 1]]
+            """
+            s = []
+            P = self.parent()
+            sf = P._scaling_factors[i]
+            for j in P._virtualization[i]:
+                s += [j]*sf
+            ret = self.value.e_string(s)
+            if ret is None:
+                return None
+            return self.__class__(P, ret)
+
+        def f(self, i):
+            """
+            Return `f_i` of ``self``.
+
+            EXAMPLES::
+
+                sage: B = crystals.Tableaux(['B',3], shape=[1])
+                sage: C = crystals.Tableaux(['D',4], shape=[2])
+                sage: psi = B.crystal_morphism(C.module_generators)
+                sage: V = psi.image()
+                sage: mg = V.module_generators[0]
+                sage: mg.f(1)
+                [[2, 2]]
+                sage: mg.f(2)
+            """
+            s = []
+            P = self.parent()
+            sf = P._scaling_factors[i]
+            for j in P._virtualization[i]:
+                s += [j]*sf
+            ret = self.value.f_string(s)
+            if ret is None:
+                return None
+            return self.__class__(P, ret)
+
+        def epsilon(self, i):
+            r"""
+            Return `\varepsilon_i` of ``self``.
+
+            EXAMPLES::
+
+                sage: B = crystals.Tableaux(['B',3], shape=[1])
+                sage: C = crystals.Tableaux(['D',4], shape=[2])
+                sage: psi = B.crystal_morphism(C.module_generators)
+                sage: V = psi.image()
+                sage: mg = V.module_generators[0]
+                sage: mg.epsilon(2)
+                0
+                sage: mg.f(1).epsilon(1)
+                1
+            """
+            P = self.parent()
+            return self.value.epsilon(P._virtualization[i][0]) // P._scaling_factors[i]
+
+        def phi(self, i):
+            r"""
+            Return `\varphi_i` of ``self``.
+
+            EXAMPLES::
+
+                sage: B = crystals.Tableaux(['B',3], shape=[1])
+                sage: C = crystals.Tableaux(['D',4], shape=[2])
+                sage: psi = B.crystal_morphism(C.module_generators)
+                sage: V = psi.image()
+                sage: mg = V.module_generators[0]
+                sage: mg.phi(1)
+                1
+                sage: mg.phi(2)
+                0
+            """
+            P = self.parent()
+            return self.value.phi(P._virtualization[i][0]) // P._scaling_factors[i]
+
+        def weight(self):
+            """
+            Return the weight of ``self``.
+
+            EXAMPLES::
+
+                sage: B = crystals.Tableaux(['B',3], shape=[1])
+                sage: C = crystals.Tableaux(['D',4], shape=[2])
+                sage: psi = B.crystal_morphism(C.module_generators)
+                sage: V = psi.image()
+                sage: mg = V.module_generators[0]
+                sage: mg.weight()
+                (1, 0, 0)
+                sage: mg.f(1).weight()
+                (0, 1, 0)
+                sage: all(V(psi(x)).weight() == x.weight() for x in B)
+                True
+            """
+            P = self.parent()
+            WLR = P.weight_lattice_realization()
+            wt = self.value.weight()
+            ac = P._ambient.weight_lattice_realization().simple_coroots()
+            La = WLR.fundamental_weights()
+            v = P._virtualization
+            sf = P._scaling_factors
+            return WLR.sum(wt.scalar(ac[v[i][0]]) // sf[i] * La[i]
+                           for i in self.index_set())
+
+# TODO: implement a devirtualization map

sage/combinat/cyclic_sieving_phenomenon.py

@@ -0,0 +1,204 @@
+# sage_setup: distribution = sagemath-combinat
+r"""
+Cyclic sieving phenomenon
+
+Implementation of the Cyclic Sieving Phenomenon as described by
+Reiner, Stanton, and White in [RSW2004]_.
+
+We define the :func:`CyclicSievingPolynomial` of a finite set `S`
+together with cyclic action ``cyc_act`` (of order `n`) to be the
+unique polynomial ``P(q)`` of order < `n` such that the triple (`S`,
+``cyc_act``, ``P(q)``) exhibits the cyclic sieving phenomenon.
+
+AUTHORS:
+
+- Christian Stump
+
+REFERENCES:
+
+.. [RSW2004] Reiner, Stanton, White - *The cyclic sieving phenomenon*,
+             Journal of Combinatorial Theory A 108 (2004)
+"""
+# ****************************************************************************
+#       Copyright (C) 2010 Christian Stump christian.stump@univie.ac.at
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from __future__ import annotations
+from sage.rings.integer_ring import ZZ
+from sage.arith.functions import lcm
+from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
+
+
+def CyclicSievingPolynomial(L, cyc_act=None, order=None, get_order=False):
+    """
+    Return the unique polynomial ``p`` of degree smaller than ``order`` such
+    that the triple ``(L, cyc_act, p)`` exhibits the Cyclic Sieving Phenomenon.
+
+    If ``cyc_act`` is None, ``L`` is expected to contain the orbit lengths.
+
+    INPUT:
+
+    - ``L`` -- if ``cyc_act`` is ``None``: list of orbit sizes,
+      otherwise list of objects
+
+    - ``cyc_act`` -- (default: ``None``) bijective function from ``L`` to ``L``
+
+    - ``order`` -- (default: ``None``) if set to an integer, this
+        cyclic order of ``cyc_act`` is used (must be an integer multiple
+        of the order of ``cyc_act``) otherwise, the order of ``cyc_action`` is
+        used
+
+    - ``get_order`` -- (default: ``False``) if ``True``, a tuple ``[p,n]``
+      is returned where ``p`` is as above, and ``n`` is the order
+
+    EXAMPLES::
+
+        sage: from sage.combinat.cyclic_sieving_phenomenon import CyclicSievingPolynomial
+        sage: S42 = Subsets([1,2,3,4], 2)
+        sage: def cyc_act(S): return Set(i.mod(4) + 1 for i in S)
+        sage: cyc_act([1,3])
+        {2, 4}
+        sage: cyc_act([1,4])
+        {1, 2}
+        sage: CyclicSievingPolynomial(S42, cyc_act)
+        q^3 + 2*q^2 + q + 2
+        sage: CyclicSievingPolynomial(S42, cyc_act, get_order=True)
+        [q^3 + 2*q^2 + q + 2, 4]
+        sage: CyclicSievingPolynomial(S42, cyc_act, order=8)
+        q^6 + 2*q^4 + q^2 + 2
+        sage: CyclicSievingPolynomial([4,2])
+        q^3 + 2*q^2 + q + 2
+
+    TESTS:
+
+    We check that :issue:`13997` is handled::
+
+        sage: CyclicSievingPolynomial(S42, cyc_act, order=8, get_order=True)
+        [q^6 + 2*q^4 + q^2 + 2, 8]
+        sage: CyclicSievingPolynomial(S42, cyc_act, order=11)
+        Traceback (most recent call last):
+        ...
+        ValueError: order is not a multiple of the order of the cyclic action
+    """
+    if cyc_act:
+        orbits = orbit_decomposition(L, cyc_act)
+    else:
+        orbits = [list(range(k)) for k in L]
+
+    R = PolynomialRing(ZZ, 'q')
+    q = R.gen()
+    p = R.zero()
+
+    orbit_sizes = {}
+    for orbit in orbits:
+        length = len(orbit)
+        if length in orbit_sizes:
+            orbit_sizes[length] += 1
+        else:
+            orbit_sizes[length] = 1
+
+    n = lcm(orbit_sizes)
+
+    if order:
+        if order.mod(n):
+            raise ValueError("order is not a multiple of the order"
+                             " of the cyclic action")
+    else:
+        order = n
+
+    for i in range(n):
+        if i == 0:
+            j = sum(orbit_sizes.values())
+        else:
+            j = sum(orb for l, orb in orbit_sizes.items()
+                    if not ZZ(i).mod(n // l))
+        p += j * q**i
+
+    p = p(q**(order // n))
+
+    return [p, order] if get_order else p
+
+
+def CyclicSievingCheck(L, cyc_act, f, order=None) -> bool:
+    """
+    Return whether the triple ``(L, cyc_act, f)`` exhibits
+    the cyclic sieving phenomenon.
+
+    If ``cyc_act`` is None, ``L`` is expected to contain the orbit lengths.
+
+    INPUT:
+
+    - ``L`` -- if ``cyc_act`` is ``None``: list of orbit sizes,
+      otherwise list of objects
+
+    - ``cyc_act`` -- (default: ``None``) bijective function from ``L`` to ``L``
+
+    - ``order`` -- (default: ``None``) if set to an integer, this
+        cyclic order of ``cyc_act`` is used (must be an integer
+        multiple of the order of ``cyc_act``) otherwise, the order of
+        ``cyc_action`` is used
+
+    EXAMPLES::
+
+        sage: from sage.combinat.cyclic_sieving_phenomenon import *
+        sage: from sage.combinat.q_analogues import q_binomial
+        sage: S42 = Subsets([1,2,3,4], 2)
+        sage: def cyc_act(S): return Set(i.mod(4) + 1 for i in S)
+        sage: cyc_act([1,3])
+        {2, 4}
+        sage: cyc_act([1,4])
+        {1, 2}
+        sage: p = q_binomial(4,2); p
+        q^4 + q^3 + 2*q^2 + q + 1
+        sage: CyclicSievingPolynomial( S42, cyc_act )
+        q^3 + 2*q^2 + q + 2
+        sage: CyclicSievingCheck( S42, cyc_act, p )
+        True
+    """
+    p1, n = CyclicSievingPolynomial(L, cyc_act=cyc_act, order=order,
+                                    get_order=True)
+    R = p1.parent()
+    q = R.gen()
+    return p1 == R(f).mod(q**n - 1)
+
+
+def orbit_decomposition(L, cyc_act) -> list[list]:
+    """
+    Return the orbit decomposition of ``L`` by the action of ``cyc_act``.
+
+    INPUT:
+
+    - ``L`` -- list
+
+    - ``cyc_act`` -- bijective function from ``L`` to ``L``
+
+    OUTPUT: list of lists, the orbits under the cyc_act acting on ``L``
+
+    EXAMPLES::
+
+        sage: from sage.combinat.cyclic_sieving_phenomenon import *
+        sage: S42 = Subsets([1,2,3,4], 2); S42
+        Subsets of {1, 2, 3, 4} of size 2
+        sage: def cyc_act(S): return Set(i.mod(4) + 1 for i in S)
+        sage: cyc_act([1,3])
+        {2, 4}
+        sage: cyc_act([1,4])
+        {1, 2}
+        sage: orbits = orbit_decomposition(S42, cyc_act)
+        sage: sorted([sorted(orb, key=sorted) for orb in orbits], key=len)
+        [[{1, 3}, {2, 4}], [{1, 2}, {1, 4}, {2, 3}, {3, 4}]]
+    """
+    orbits = []
+    L_prime = set(L)
+    while L_prime:
+        obj = L_prime.pop()
+        orbit = [obj]
+        obj = cyc_act(obj)
+        while obj in L_prime:
+            orbit.append(obj)
+            L_prime.remove(obj)
+            obj = cyc_act(obj)
+        orbits.append(orbit)
+    return orbits