passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/categories/finite_lattice_posets.py

@@ -0,0 +1,242 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite lattice posets
+"""
+#*****************************************************************************
+#  Copyright (C) 2011 Nicolas M. Thiery <nthiery at users.sf.net>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+#******************************************************************************
+
+from sage.categories.category_with_axiom import CategoryWithAxiom
+
+
+class FiniteLatticePosets(CategoryWithAxiom):
+    r"""
+    The category of finite lattices, i.e. finite partially ordered
+    sets which are also lattices.
+
+    EXAMPLES::
+
+        sage: FiniteLatticePosets()
+        Category of finite lattice posets
+        sage: FiniteLatticePosets().super_categories()
+        [Category of lattice posets, Category of finite posets]
+        sage: FiniteLatticePosets().example()
+        NotImplemented
+
+    .. SEEALSO::
+
+        :class:`FinitePosets`, :class:`LatticePosets`, :class:`~sage.combinat.posets.lattices.FiniteLatticePoset`
+
+    TESTS::
+
+        sage: C = FiniteLatticePosets()
+        sage: C is FiniteLatticePosets().Finite()
+        True
+        sage: TestSuite(C).run()
+    """
+
+    class ParentMethods:
+
+        def join_irreducibles(self):
+            r"""
+            Return the join-irreducible elements of this finite lattice.
+
+            A *join-irreducible element* of ``self`` is an element
+            `x` that is not minimal and that can not be written as
+            the join of two elements different from `x`.
+
+            EXAMPLES::
+
+                sage: L = LatticePoset({0:[1,2],1:[3],2:[3,4],3:[5],4:[5]})             # needs sage.graphs sage.modules
+                sage: L.join_irreducibles()                                             # needs sage.graphs sage.modules
+                [1, 2, 4]
+
+            .. SEEALSO::
+
+                - Dual function: :meth:`meet_irreducibles`
+                - Other: :meth:`~sage.combinat.posets.lattices.FiniteLatticePoset.double_irreducibles`,
+                  :meth:`join_irreducibles_poset`
+            """
+            return [x for x in self if len(self.lower_covers(x)) == 1]
+
+        def join_irreducibles_poset(self):
+            r"""
+            Return the poset of join-irreducible elements of this finite lattice.
+
+            A *join-irreducible element* of ``self`` is an element `x`
+            that is not minimal and can not be written as the join of two
+            elements different from `x`.
+
+            EXAMPLES::
+
+                sage: L = LatticePoset({0:[1,2,3],1:[4],2:[4],3:[4]})                   # needs sage.graphs sage.modules
+                sage: L.join_irreducibles_poset()                                       # needs sage.graphs sage.modules
+                Finite poset containing 3 elements
+
+            .. SEEALSO::
+
+                - Dual function: :meth:`meet_irreducibles_poset`
+                - Other: :meth:`join_irreducibles`
+            """
+            return self.subposet(self.join_irreducibles())
+
+        def meet_irreducibles(self):
+            r"""
+            Return the meet-irreducible elements of this finite lattice.
+
+            A *meet-irreducible element* of ``self`` is an element
+            `x` that is not maximal and that can not be written as
+            the meet of two elements different from `x`.
+
+            EXAMPLES::
+
+                sage: L = LatticePoset({0:[1,2],1:[3],2:[3,4],3:[5],4:[5]})             # needs sage.graphs sage.modules
+                sage: L.meet_irreducibles()                                             # needs sage.graphs sage.modules
+                [1, 3, 4]
+
+            .. SEEALSO::
+
+                - Dual function: :meth:`join_irreducibles`
+                - Other: :meth:`~sage.combinat.posets.lattices.FiniteLatticePoset.double_irreducibles`,
+                  :meth:`meet_irreducibles_poset`
+            """
+            return [x for x in self if len(self.upper_covers(x)) == 1]
+
+        def meet_irreducibles_poset(self):
+            r"""
+            Return the poset of join-irreducible elements of this finite lattice.
+
+            A *meet-irreducible element* of ``self`` is an element `x`
+            that is not maximal and can not be written as the meet of two
+            elements different from `x`.
+
+            EXAMPLES::
+
+                sage: L = LatticePoset({0:[1,2,3],1:[4],2:[4],3:[4]})                   # needs sage.graphs sage.modules
+                sage: L.join_irreducibles_poset()                                       # needs sage.graphs sage.modules
+                Finite poset containing 3 elements
+
+            .. SEEALSO::
+
+                - Dual function: :meth:`join_irreducibles_poset`
+                - Other: :meth:`meet_irreducibles`
+            """
+            return self.subposet(self.meet_irreducibles())
+
+        def irreducibles_poset(self):
+            """
+            Return the poset of meet- or join-irreducibles of the lattice.
+
+            A *join-irreducible* element of a lattice is an element with
+            exactly one lower cover. Dually a *meet-irreducible* element
+            has exactly one upper cover.
+
+            This is the smallest poset with completion by cuts being
+            isomorphic to the lattice. As a special case this returns
+            one-element poset from one-element lattice.
+
+            .. SEEALSO::
+
+                :meth:`~sage.combinat.posets.posets.FinitePoset.completion_by_cuts`.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat sage.graphs sage.modules
+                sage: L = LatticePoset({1: [2, 3, 4], 2: [5, 6], 3: [5],
+                ....:                   4: [6], 5: [9, 7], 6: [9, 8], 7: [10],
+                ....:                   8: [10], 9: [10], 10: [11]})
+                sage: L_ = L.irreducibles_poset()
+                sage: sorted(L_)
+                [2, 3, 4, 7, 8, 9, 10, 11]
+                sage: L_.completion_by_cuts().is_isomorphic(L)
+                True
+
+            TESTS::
+
+                sage: LatticePoset().irreducibles_poset()                               # needs sage.graphs
+                Finite poset containing 0 elements
+                sage: posets.ChainPoset(1).irreducibles_poset()                         # needs sage.graphs
+                Finite poset containing 1 elements
+            """
+            if self.cardinality() == 1:
+                from sage.combinat.posets.posets import Poset
+                return Poset({self[0]: []})
+            return self.subposet(self.join_irreducibles()+self.meet_irreducibles())
+
+        ##########################################################################
+        # Lattice morphisms
+
+        def is_lattice_morphism(self, f, codomain):
+            r"""
+            Return whether ``f`` is a morphism of posets from ``self``
+            to ``codomain``.
+
+            A map `f : P \to Q` is a poset morphism if
+
+            .. MATH::
+
+                x \leq y \Rightarrow f(x) \leq f(y)
+
+            for all `x,y \in P`.
+
+            INPUT:
+
+            - ``f`` -- a function from ``self`` to ``codomain``
+            - ``codomain`` -- a lattice
+
+            EXAMPLES:
+
+            We build the boolean lattice of `\{2,2,3\}` and the
+            lattice of divisors of `60`, and check that the map
+            `b \mapsto 5 \prod_{x\in b} x` is a morphism of lattices::
+
+                sage: D = LatticePoset((divisors(60), attrcall("divides")))             # needs sage.graphs sage.modules
+                sage: B = LatticePoset((Subsets([2,2,3]), attrcall("issubset")))        # needs sage.graphs sage.modules
+                sage: def f(b): return D(5*prod(b))
+                sage: B.is_lattice_morphism(f, D)                                       # needs sage.graphs sage.modules
+                True
+
+            We construct the boolean lattice `B_2`::
+
+                sage: B = posets.BooleanLattice(2)                                      # needs sage.graphs
+                sage: B.cover_relations()                                               # needs sage.graphs
+                [[0, 1], [0, 2], [1, 3], [2, 3]]
+
+            And the same lattice with new top and bottom elements
+            numbered respectively `-1` and `3`::
+
+                sage: G = DiGraph({-1:[0], 0:[1,2], 1:[3], 2:[3], 3:[4]})               # needs sage.graphs
+                sage: L = LatticePoset(G)                                               # needs sage.graphs sage.modules
+                sage: L.cover_relations()                                               # needs sage.graphs sage.modules
+                [[-1, 0], [0, 1], [0, 2], [1, 3], [2, 3], [3, 4]]
+
+                sage: f = {B(0): L(0), B(1): L(1), B(2): L(2), B(3): L(3)}.__getitem__  # needs sage.graphs sage.modules
+                sage: B.is_lattice_morphism(f, L)                                       # needs sage.graphs sage.modules
+                True
+
+                sage: f = {B(0): L(-1),B(1): L(1), B(2): L(2), B(3): L(3)}.__getitem__  # needs sage.graphs sage.modules
+                sage: B.is_lattice_morphism(f, L)                                       # needs sage.graphs sage.modules
+                False
+
+                sage: f = {B(0): L(0), B(1): L(1), B(2): L(2), B(3): L(4)}.__getitem__  # needs sage.graphs sage.modules
+                sage: B.is_lattice_morphism(f, L)                                       # needs sage.graphs sage.modules
+                False
+
+            .. SEEALSO::
+
+                :meth:`~sage.categories.finite_posets.FinitePosets.ParentMethods.is_poset_morphism`
+            """
+            # Note: in a lattice, x <= y iff join(x,y) = y .
+            # Therefore checking joins and meets is sufficient to
+            # ensure that this is a poset morphism. It actually may
+            # be sufficient to check just joins (or just meets).
+            from sage.combinat.subset import Subsets
+            for x,y in Subsets(self,2):
+                if f(self.join(x,y)) != codomain.join(f(x), f(y)):
+                    return False
+                if f(self.meet(x,y)) != codomain.meet(f(x), f(y)):
+                    return False
+            return True

sage/categories/finite_monoids.py

@@ -0,0 +1,316 @@
+# sage_setup: distribution = sagemath-categories
+r"""
+Finite monoids
+"""
+# ****************************************************************************
+#  Copyright (C) 2008 Teresa Gomez-Diaz (CNRS) <Teresa.Gomez-Diaz@univ-mlv.fr>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+from sage.misc.cachefunc import cached_method
+from sage.categories.category_with_axiom import CategoryWithAxiom
+
+
+class FiniteMonoids(CategoryWithAxiom):
+    """
+    The category of finite (multiplicative) :class:`monoids <Monoids>`.
+
+    A finite monoid is a :class:`finite sets <FiniteSets>` endowed
+    with an associative unital binary operation `*`.
+
+    EXAMPLES::
+
+        sage: FiniteMonoids()
+        Category of finite monoids
+        sage: FiniteMonoids().super_categories()
+        [Category of monoids, Category of finite semigroups]
+
+    TESTS::
+
+        sage: TestSuite(FiniteMonoids()).run()
+
+        sage: # needs sage.combinat
+        sage: R = IntegerModRing(15)
+        sage: M = R.subsemigroup([R(5)], one=R(10),
+        ....:     category=Semigroups().Finite().Subobjects() & Groups())
+        sage: M.one()
+        10
+    """
+    class ParentMethods:
+
+        def nerve(self):
+            r"""
+            The nerve (classifying space) of this monoid.
+
+            OUTPUT:
+
+            the nerve `BG` (if `G` denotes this monoid), as a
+            simplicial set.  The `k`-dimensional simplices of this
+            object are indexed by products of `k` elements in the
+            monoid:
+
+            .. MATH::
+
+                a_1 * a_2 * \cdots * a_k
+
+            The `0`-th face of this is obtained by deleting `a_1`, and
+            the `k`-th face is obtained by deleting `a_k`. The other
+            faces are obtained by multiplying elements: the 1st face
+            is
+
+            .. MATH::
+
+               (a1 * a_2) * \cdots * a_k
+
+            and so on. See :wikipedia:`Nerve_(category_theory)`, which
+            describes the construction of the nerve as a simplicial
+            set.
+
+            A simplex in this simplicial set will be degenerate if in
+            the corresponding product of `k` elements, one of those
+            elements is the identity. So we only need to keep track of
+            the products of non-identity elements. Similarly, if a
+            product `a_{i-1} a_i` is the identity element, then the
+            corresponding face of the simplex will be a degenerate
+            simplex.
+
+            EXAMPLES:
+
+            The nerve (classifying space) of the cyclic group of order
+            2 is infinite-dimensional real projective space. ::
+
+                sage: Sigma2 = groups.permutation.Cyclic(2)                             # needs sage.groups
+                sage: BSigma2 = Sigma2.nerve()                                          # needs sage.graphs sage.groups
+                sage: BSigma2.cohomology(4, base_ring=GF(2))                            # needs sage.graphs sage.groups sage.modules
+                Vector space of dimension 1 over Finite Field of size 2
+
+            The `k`-simplices of the nerve are named after the chains
+            of `k` non-unit elements to be multiplied. The group
+            `\Sigma_2` has two elements, written ``()`` (the identity
+            element) and ``(1,2)`` in Sage. So the 1-cells and 2-cells
+            in `B\Sigma_2` are::
+
+                sage: BSigma2.n_cells(1)                                                # needs sage.graphs sage.groups
+                [(1,2)]
+                sage: BSigma2.n_cells(2)                                                # needs sage.graphs sage.groups
+                [(1,2) * (1,2)]
+
+            Another construction of the group, with different names
+            for its elements::
+
+                sage: # needs sage.groups sage.rings.number_field
+                sage: C2 = groups.misc.MultiplicativeAbelian([2])
+                sage: BC2 = C2.nerve()
+                sage: BC2.n_cells(0)
+                [1]
+                sage: BC2.n_cells(1)
+                [f]
+                sage: BC2.n_cells(2)
+                [f * f]
+
+            With mod `p` coefficients, `B \Sigma_p` should have its
+            first nonvanishing homology group in dimension `p`::
+
+                sage: Sigma3 = groups.permutation.Symmetric(3)                          # needs sage.groups
+                sage: BSigma3 = Sigma3.nerve()                                          # needs sage.graphs sage.groups
+                sage: BSigma3.homology(range(4), base_ring=GF(3))                       # needs sage.graphs sage.groups
+                {0: Vector space of dimension 0 over Finite Field of size 3,
+                 1: Vector space of dimension 0 over Finite Field of size 3,
+                 2: Vector space of dimension 0 over Finite Field of size 3,
+                 3: Vector space of dimension 1 over Finite Field of size 3}
+
+            Note that we can construct the `n`-skeleton for
+            `B\Sigma_2` for relatively large values of `n`, while for
+            `B\Sigma_3`, the complexes get large pretty quickly::
+
+                sage: # needs sage.graphs sage.groups
+                sage: Sigma2.nerve().n_skeleton(14)
+                Simplicial set with 15 non-degenerate simplices
+                sage: BSigma3 = Sigma3.nerve()
+                sage: BSigma3.n_skeleton(3)
+                Simplicial set with 156 non-degenerate simplices
+                sage: BSigma3.n_skeleton(4)
+                Simplicial set with 781 non-degenerate simplices
+
+            Finally, note that the classifying space of the order `p`
+            cyclic group is smaller than that of the symmetric group
+            on `p` letters, and its first homology group appears
+            earlier::
+
+                sage: # needs sage.graphs sage.groups sage.rings.number_field
+                sage: C3 = groups.misc.MultiplicativeAbelian([3])
+                sage: list(C3)
+                [1, f, f^2]
+                sage: BC3 = C3.nerve()
+                sage: BC3.n_cells(1)
+                [f, f^2]
+                sage: BC3.n_cells(2)
+                [f * f, f * f^2, f^2 * f, f^2 * f^2]
+                sage: len(BSigma3.n_cells(2))
+                25
+                sage: len(BC3.n_cells(3))
+                8
+                sage: len(BSigma3.n_cells(3))
+                125
+                sage: BC3.homology(range(4), base_ring=GF(3))
+                {0: Vector space of dimension 0 over Finite Field of size 3,
+                 1: Vector space of dimension 1 over Finite Field of size 3,
+                 2: Vector space of dimension 1 over Finite Field of size 3,
+                 3: Vector space of dimension 1 over Finite Field of size 3}
+                sage: BC5 = groups.permutation.Cyclic(5).nerve()
+                sage: BC5.homology(range(4), base_ring=GF(5))
+                {0: Vector space of dimension 0 over Finite Field of size 5,
+                 1: Vector space of dimension 1 over Finite Field of size 5,
+                 2: Vector space of dimension 1 over Finite Field of size 5,
+                 3: Vector space of dimension 1 over Finite Field of size 5}
+            """
+            from sage.topology.simplicial_set_examples import Nerve
+            return Nerve(self)
+
+        def rhodes_radical_congruence(self, base_ring=None):
+            r"""
+            Return the Rhodes radical congruence of the semigroup.
+
+            The Rhodes radical congruence is the congruence induced on S by the
+            map `S \rightarrow kS \rightarrow kS / rad kS` with k a field.
+
+            INPUT:
+
+            - ``base_ring`` -- (default: `\QQ`) a field
+
+            OUTPUT:
+
+            - A list of couples (m, n) with `m \neq n` in the lexicographic
+              order for the enumeration of the monoid ``self``.
+
+            EXAMPLES::
+
+                sage: M = Monoids().Finite().example()
+                sage: M.rhodes_radical_congruence()                                     # needs sage.modules
+                [(0, 6), (2, 8), (4, 10)]
+
+                sage: # needs sage.combinat sage.groups sage.modules
+                sage: from sage.monoids.hecke_monoid import HeckeMonoid
+                sage: H3 = HeckeMonoid(SymmetricGroup(3))
+                sage: H3.repr_element_method(style='reduced')
+                sage: H3.rhodes_radical_congruence()
+                [([1, 2], [2, 1]), ([1, 2], [1, 2, 1]), ([2, 1], [1, 2, 1])]
+
+            By Maschke's theorem, every group algebra over `\QQ`
+            is semisimple hence the Rhodes radical of a group must be trivial::
+
+                sage: SymmetricGroup(3).rhodes_radical_congruence()                     # needs sage.combinat sage.groups sage.modules
+                []
+                sage: DihedralGroup(10).rhodes_radical_congruence()                     # needs sage.groups sage.modules
+                []
+
+            REFERENCES:
+
+            - [Rho69]_
+            """
+            from sage.rings.rational_field import QQ
+            if base_ring is None:
+                base_ring = QQ
+            kS = self.algebra(base_ring)
+            kSrad = kS.radical()
+            res = []
+            for m in self:
+                for n in self:
+                    if m == n or (n, m) in res:
+                        continue
+                    try:
+                        kSrad.retract(kS(m) - kS(n))
+                    except ValueError:
+                        pass
+                    else:
+                        res.append((m, n))
+            return res
+
+    class ElementMethods:
+        def pseudo_order(self):
+            r"""
+            Return the pair `[k, j]` with `k` minimal and `0\leq j <k` such
+            that ``self^k == self^j``.
+
+            Note that `j` is uniquely determined.
+
+            EXAMPLES::
+
+                sage: M = FiniteMonoids().example(); M
+                An example of a finite multiplicative monoid: the integers modulo 12
+
+                sage: x = M(2)
+                sage: [ x^i for i in range(7) ]
+                [1, 2, 4, 8, 4, 8, 4]
+                sage: x.pseudo_order()
+                [4, 2]
+
+                sage: x = M(3)
+                sage: [ x^i for i in range(7) ]
+                [1, 3, 9, 3, 9, 3, 9]
+                sage: x.pseudo_order()
+                [3, 1]
+
+                sage: x = M(4)
+                sage: [ x^i for i in range(7) ]
+                [1, 4, 4, 4, 4, 4, 4]
+                sage: x.pseudo_order()
+                [2, 1]
+
+                sage: x = M(5)
+                sage: [ x^i for i in range(7) ]
+                [1, 5, 1, 5, 1, 5, 1]
+                sage: x.pseudo_order()
+                [2, 0]
+
+            .. TODO::
+
+                more appropriate name? see, for example, Jean-Eric Pin's
+                lecture notes on semigroups.
+            """
+            self_powers = {self.parent().one(): 0}
+            k = 1
+            self_power_k = self
+            while self_power_k not in self_powers:
+                self_powers[self_power_k] = k
+                k += 1
+                self_power_k = self_power_k * self
+            return [k, self_powers[self_power_k]]
+
+        @cached_method
+        def __invert__(self):
+            """
+            Return the inverse of ``self`` if it exists.
+
+            This is the generic implementation, very naive and slow.
+
+            EXAMPLES::
+
+                sage: # needs sage.combinat
+                sage: R = IntegerModRing(15)
+                sage: M = R.subsemigroup([R(5)], one=R(10),
+                ....:     category=Semigroups().Finite().Subobjects() & Groups())
+                sage: [~x for x in M]
+                [10, 5]
+
+            TESTS::
+
+                sage: # needs sage.combinat
+                sage: R = IntegerModRing(15)
+                sage: M = R.subsemigroup([R(3)], one=R(1),
+                ....:     category=Semigroups().Finite().Subobjects())
+                sage: ~M(3)
+                Traceback (most recent call last):
+                ...
+                ValueError: the element 3 is not invertible
+            """
+            parent = self.parent()
+            one = parent.one()
+            if self == one:
+                return one
+            it = (v for v in parent if v * self == one == self * v)
+            try:
+                return next(it)
+            except StopIteration:
+                raise ValueError(f"the element {self} is not invertible")