passagemath-polyhedra 10.6.37__cp314-cp314-musllinux_1_2_x86_64.whl

sage/geometry/hasse_diagram.py

@@ -0,0 +1,202 @@
+# sage_setup: distribution = sagemath-polyhedra
+"""
+Construction of finite atomic and coatomic lattices from incidences
+
+This module provides the function :func:`lattice_from_incidences` for
+computing finite atomic and coatomic lattices in the sense of
+partially ordered sets where any two elements have meet and joint. For
+example, the face lattice of a polyhedron.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2010 Andrey Novoseltsev <novoselt@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from sage.graphs.digraph import DiGraph
+from sage.combinat.posets.lattices import FiniteLatticePoset
+
+
+def lattice_from_incidences(atom_to_coatoms, coatom_to_atoms,
+                            face_constructor=None,
+                            required_atoms=None,
+                            key=None,
+                            **kwds):
+    r"""
+    Compute an atomic and coatomic lattice from the incidence between
+    atoms and coatoms.
+
+    INPUT:
+
+    - ``atom_to_coatoms`` -- list; ``atom_to_coatom[i]`` should list all
+      coatoms over the ``i``-th atom
+
+    - ``coatom_to_atoms`` -- list; ``coatom_to_atom[i]`` should list all
+      atoms under the ``i``-th coatom
+
+    - ``face_constructor`` -- function or class taking as the first two
+      arguments sorted :class:`tuple` of integers and any keyword arguments.
+      It will be called to construct a face over atoms passed as the first
+      argument and under coatoms passed as the second argument. Default
+      implementation will just return these two tuples as a tuple;
+
+    - ``required_atoms`` -- list of atoms (default: ``None``); each
+      non-empty "face" requires at least one of the specified atoms
+      present. Used to ensure that each face has a vertex.
+
+    - ``key`` -- any hashable value (default: ``None``); it is passed down
+      to :class:`~sage.combinat.posets.posets.FinitePoset`
+
+    - all other keyword arguments will be passed to ``face_constructor`` on
+      each call
+
+    OUTPUT:
+
+    - :class:`finite poset <sage.combinat.posets.posets.FinitePoset>` with
+      elements constructed by ``face_constructor``.
+
+    .. NOTE::
+
+        In addition to the specified partial order, finite posets in Sage have
+        internal total linear order of elements which extends the partial one.
+        This function will try to make this internal order to start with the
+        bottom and atoms in the order corresponding to ``atom_to_coatoms`` and
+        to finish with coatoms in the order corresponding to
+        ``coatom_to_atoms`` and the top. This may not be possible if atoms and
+        coatoms are the same, in which case the preference is given to the
+        first list.
+
+    ALGORITHM:
+
+    The detailed description of the used algorithm is given in [KP2002]_.
+
+    The code of this function follows the pseudo-code description in the
+    section 2.5 of the paper, although it is mostly based on frozen sets
+    instead of sorted lists - this makes the implementation easier and should
+    not cost a big performance penalty. (If one wants to make this function
+    faster, it should be probably written in Cython.)
+
+    While the title of the paper mentions only polytopes, the algorithm (and
+    the implementation provided here) is applicable to any atomic and coatomic
+    lattice if both incidences are given, see Section 3.4.
+
+    In particular, this function can be used for strictly convex cones and
+    complete fans.
+
+    REFERENCES: [KP2002]_
+
+    AUTHORS:
+
+    - Andrey Novoseltsev (2010-05-13) with thanks to Marshall Hampton for the
+      reference.
+
+    EXAMPLES:
+
+    Let us construct the lattice of subsets of {0, 1, 2}.
+    Our atoms are {0}, {1}, and {2}, while our coatoms are {0,1}, {0,2}, and
+    {1,2}. Then incidences are ::
+
+        sage: atom_to_coatoms = [(0,1), (0,2), (1,2)]
+        sage: coatom_to_atoms = [(0,1), (0,2), (1,2)]
+
+    and we can compute the lattice as ::
+
+        sage: from sage.geometry.cone import lattice_from_incidences
+        sage: L = lattice_from_incidences(atom_to_coatoms, coatom_to_atoms); L          # needs sage.graphs
+        Finite lattice containing 8 elements with distinguished linear extension
+        sage: for level in L.level_sets(): print(level)                                 # needs sage.graphs
+        [((), (0, 1, 2))]
+        [((0,), (0, 1)), ((1,), (0, 2)), ((2,), (1, 2))]
+        [((0, 1), (0,)), ((0, 2), (1,)), ((1, 2), (2,))]
+        [((0, 1, 2), ())]
+
+    For more involved examples see the *source code* of
+    :meth:`sage.geometry.cone.ConvexRationalPolyhedralCone.face_lattice` and
+    :meth:`sage.geometry.fan.RationalPolyhedralFan._compute_cone_lattice`.
+    """
+
+    def default_face_constructor(atoms, coatoms, **kwds):
+        return (atoms, coatoms)
+    if face_constructor is None:
+        face_constructor = default_face_constructor
+    atom_to_coatoms = [frozenset(atc) for atc in atom_to_coatoms]
+    A = frozenset(range(len(atom_to_coatoms)))  # All atoms
+    coatom_to_atoms = [frozenset(cta) for cta in coatom_to_atoms]
+    C = frozenset(range(len(coatom_to_atoms)))  # All coatoms
+    # Comments with numbers correspond to steps in Section 2.5 of the article
+    L = DiGraph(1)       # 3: initialize L
+    faces = {}
+    atoms = frozenset()
+    coatoms = C
+    faces[atoms, coatoms] = 0
+    next_index = 1
+    Q = [(atoms, coatoms)]              # 4: initialize Q with the empty face
+    while Q:                            # 5
+        q_atoms, q_coatoms = Q.pop()    # 6: remove some q from Q
+        q = faces[q_atoms, q_coatoms]
+        # 7: compute H = {closure(q+atom) : atom not in atoms of q}
+        H = {}
+        candidates = set(A.difference(q_atoms))
+        for atom in candidates:
+            coatoms = q_coatoms.intersection(atom_to_coatoms[atom])
+            atoms = A
+            for coatom in coatoms:
+                atoms = atoms.intersection(coatom_to_atoms[coatom])
+            H[atom] = (atoms, coatoms)
+        # 8: compute the set G of minimal sets in H
+        minimals = set()
+        while candidates:
+            candidate = candidates.pop()
+            atoms = H[candidate][0]
+            if atoms.isdisjoint(candidates) and atoms.isdisjoint(minimals):
+                minimals.add(candidate)
+        # Now G == {H[atom] : atom in minimals}
+        for atom in minimals:   # 9: for g in G:
+            g_atoms, g_coatoms = H[atom]
+            if required_atoms is not None:
+                if g_atoms.isdisjoint(required_atoms):
+                    continue
+            if (g_atoms, g_coatoms) in faces:
+                g = faces[g_atoms, g_coatoms]
+            else:               # 11: if g was newly created
+                g = next_index
+                faces[g_atoms, g_coatoms] = g
+                next_index += 1
+                Q.append((g_atoms, g_coatoms))  # 12
+            L.add_edge(q, g)                    # 14
+
+    # End of algorithm, now construct a FiniteLatticePoset.
+
+    # In principle, it is recommended to use Poset or in this case perhaps
+    # even LatticePoset, but it seems to take several times more time
+    # than the above computation, makes unnecessary copies, and crashes.
+    # So for now we will mimic the relevant code from Poset.
+
+    # Enumeration of graph vertices must be a linear extension of the poset
+    new_order = L.topological_sort()
+    # Make sure that coatoms are in the end in proper order
+    tail = [faces[atomes, frozenset([coatom])]
+            for coatom, atomes in enumerate(coatom_to_atoms)]
+    tail.append(faces[A, frozenset()])
+    new_order = [n for n in new_order if n not in tail] + tail
+    # Make sure that atoms are in the beginning in proper order
+    head = [0] # We know that the empty face has index 0
+    head.extend(faces[frozenset([atom]), coatoms]
+                for atom, coatoms in enumerate(atom_to_coatoms)
+                if required_atoms is None or atom in required_atoms)
+    new_order = head + [n for n in new_order if n not in head]
+    # "Invert" this list to a dictionary
+    labels = {old: new for new, old in enumerate(new_order)}
+    L.relabel(labels)
+    # Construct the actual poset elements
+    elements = [None] * next_index
+    for face, index in faces.items():
+        atoms, coatoms = face
+        elements[labels[index]] = face_constructor(
+                        tuple(sorted(atoms)), tuple(sorted(coatoms)), **kwds)
+    D = dict(enumerate(elements))
+    L.relabel(D)
+    return FiniteLatticePoset(L, elements, key=key)

sage/geometry/hyperplane_arrangement/affine_subspace.py

@@ -0,0 +1,390 @@
+# sage_setup: distribution = sagemath-polyhedra
+"""
+Affine Subspaces of a Vector Space
+
+An affine subspace of a vector space is a translation of a linear
+subspace. The affine subspaces here are only used internally in
+hyperplane arrangements. You should not use them for interactive work
+or return them to the user.
+
+EXAMPLES::
+
+    sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+    sage: a = AffineSubspace([1,0,0,0], QQ^4)
+    sage: a.dimension()
+    4
+    sage: a.point()
+    (1, 0, 0, 0)
+    sage: a.linear_part()
+    Vector space of dimension 4 over Rational Field
+    sage: a
+    Affine space p + W where:
+      p = (1, 0, 0, 0)
+      W = Vector space of dimension 4 over Rational Field
+    sage: b = AffineSubspace((1,0,0,0), matrix(QQ, [[1,2,3,4]]).right_kernel())
+    sage: c = AffineSubspace((0,2,0,0), matrix(QQ, [[0,0,1,2]]).right_kernel())
+    sage: b.intersection(c)
+    Affine space p + W where:
+      p = (-3, 2, 0, 0)
+      W = Vector space of degree 4 and dimension 2 over Rational Field
+    Basis matrix:
+    [  1   0  -1 1/2]
+    [  0   1  -2   1]
+    sage: b < a
+    True
+    sage: c < b
+    False
+    sage: A = AffineSubspace([8,38,21,250], VectorSpace(GF(19),4))
+    sage: A
+    Affine space p + W where:
+       p = (8, 0, 2, 3)
+       W = Vector space of dimension 4 over Finite Field of size 19
+
+TESTS::
+
+    sage: A = AffineSubspace([2], VectorSpace(QQ, 1))
+    sage: A.point()
+    (2)
+    sage: A.linear_part()
+    Vector space of dimension 1 over Rational Field
+    sage: A.linear_part().basis_matrix()
+    [1]
+    sage: A = AffineSubspace([], VectorSpace(QQ, 0))
+    sage: A.point()
+    ()
+    sage: A.linear_part()
+    Vector space of dimension 0 over Rational Field
+    sage: A.linear_part().basis_matrix()
+    []
+"""
+
+#*****************************************************************************
+#       Copyright (C) 2013 David Perkinson <davidp@reed.edu>
+#                          Volker Braun <vbraun.name@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+from sage.structure.sage_object import SageObject
+from sage.matrix.constructor import vector
+
+
+class AffineSubspace(SageObject):
+    """
+    An affine subspace.
+
+    INPUT:
+
+    - ``p`` -- list/tuple/iterable representing a point on the
+      affine space
+
+    - ``V`` -- vector subspace
+
+    OUTPUT: affine subspace parallel to ``V`` and passing through ``p``
+
+    EXAMPLES::
+
+        sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+        sage: a = AffineSubspace([1,0,0,0], VectorSpace(QQ,4))
+        sage: a
+        Affine space p + W where:
+          p = (1, 0, 0, 0)
+          W = Vector space of dimension 4 over Rational Field
+    """
+    def __init__(self, p, V):
+        r"""
+        Construct an :class:`AffineSubspace`.
+
+        TESTS::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0,0], VectorSpace(QQ,4))
+            sage: TestSuite(a).run()
+            sage: AffineSubspace(0, VectorSpace(QQ,4)).point()
+            (0, 0, 0, 0)
+        """
+        R = V.base_ring()
+        from sage.categories.fields import Fields
+        if R not in Fields():
+            R = R.fraction_field()
+            V = V.change_ring(R)
+        self._base_ring = R
+        self._linear_part = V
+        p = V.ambient_vector_space()(p)
+        p.set_immutable()
+        self._point = p
+
+    def __hash__(self):
+        """
+        Return a hash value.
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0,0], VectorSpace(QQ,4))
+            sage: a.__hash__()    # random output
+            -3713096828371451969
+        """
+        # note that the point is not canonically chosen, but the linear part is
+        return hash(self._linear_part)
+
+    def _repr_(self):
+        r"""
+        String representation for an :class:`AffineSubspace`.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0,0],VectorSpace(QQ,4))
+            sage: a
+            Affine space p + W where:
+              p = (1, 0, 0, 0)
+              W = Vector space of dimension 4 over Rational Field
+        """
+        return "Affine space p + W where:\n  p = "+str(self._point)+"\n  W = "+str(self._linear_part)
+
+    def __eq__(self, other):
+        r"""
+        Test whether ``self`` is equal to ``other``.
+
+        INPUT:
+
+        - ``other`` -- an :class:`AffineSubspace`
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0], matrix([[1,0,0]]).right_kernel())
+            sage: b = AffineSubspace([2,0,0], matrix([[1,0,0]]).right_kernel())
+            sage: c = AffineSubspace([1,1,0], matrix([[1,0,0]]).right_kernel())
+            sage: a == b
+            False
+            sage: a == c
+            True
+        """
+        V = self._linear_part
+        W = other._linear_part
+        return V == W and self._point - other._point in V
+
+    def __ne__(self, other):
+        r"""
+        Test whether ``self`` is not equal to ``other``.
+
+        INPUT:
+
+        - ``other`` -- an :class:`AffineSubspace`
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0],matrix([[1,0,0]]).right_kernel())
+            sage: b = AffineSubspace([2,0,0],matrix([[1,0,0]]).right_kernel())
+            sage: a == b
+            False
+            sage: a != b
+            True
+            sage: a != a
+            False
+        """
+        return not self == other
+
+    def __le__(self, other):
+        r"""
+        Test whether ``self`` is an affine subspace of ``other``.
+
+        INPUT:
+
+        - ``other`` -- an :class:`AffineSubspace`
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: V = VectorSpace(QQ, 3)
+            sage: W1 = V.subspace([[1,0,0],[0,1,0]])
+            sage: W2 = V.subspace([[1,0,0]])
+            sage: a = AffineSubspace([1,2,3], W1)
+            sage: b = AffineSubspace([1,2,3], W2)
+            sage: a <= b
+            False
+            sage: a <= a
+            True
+            sage: b <= a
+            True
+        """
+        V = self._linear_part
+        W = other._linear_part
+        return V.is_subspace(W) and self._point-other._point in W
+
+    def __lt__(self, other):
+        r"""
+        Test whether ``self`` is a proper affine subspace of ``other``.
+
+        INPUT:
+
+        - ``other`` -- an :class:`AffineSubspace`
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: V = VectorSpace(QQ, 3)
+            sage: W1 = V.subspace([[1,0,0], [0,1,0]])
+            sage: W2 = V.subspace([[1,0,0]])
+            sage: a = AffineSubspace([1,2,3], W1)
+            sage: b = AffineSubspace([1,2,3], W2)
+            sage: a < b
+            False
+            sage: a < a
+            False
+            sage: b < a
+            True
+        """
+        if self._linear_part == other._linear_part:
+            return False
+        return self <= other
+
+    def __contains__(self, q):
+        r"""
+        Test whether the point ``q`` is in the affine space.
+
+        INPUT:
+
+        - ``q`` -- point as a list/tuple/iterable
+
+        OUTPUT: boolean
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0], matrix([[1,0,0]]).right_kernel())
+            sage: (1,1,0) in a
+            True
+            sage: (0,0,0) in a
+            False
+        """
+        q = vector(self._base_ring, q)
+        return self._point - q in self._linear_part
+
+    def linear_part(self):
+        r"""
+        Return the linear part of the affine space.
+
+        OUTPUT: a vector subspace of the ambient space
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: A = AffineSubspace([2,3,1], matrix(QQ, [[1,2,3]]).right_kernel())
+            sage: A.linear_part()
+            Vector space of degree 3 and dimension 2 over Rational Field
+            Basis matrix:
+            [   1    0 -1/3]
+            [   0    1 -2/3]
+            sage: A.linear_part().ambient_vector_space()
+            Vector space of dimension 3 over Rational Field
+        """
+        return self._linear_part
+
+    def point(self):
+        r"""
+        Return a point ``p`` in the affine space.
+
+        OUTPUT: a point of the affine space as a vector in the ambient space
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: A = AffineSubspace([2,3,1], VectorSpace(QQ,3))
+            sage: A.point()
+            (2, 3, 1)
+        """
+        return self._point
+
+    def dimension(self):
+        r"""
+        Return the dimension of the affine space.
+
+        OUTPUT: integer
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: a = AffineSubspace([1,0,0,0],VectorSpace(QQ,4))
+            sage: a.dimension()
+            4
+        """
+        return self.linear_part().dimension()
+
+    def intersection(self, other):
+        r"""
+        Return the intersection of ``self`` with ``other``.
+
+        INPUT:
+
+        - ``other`` -- an :class:`AffineSubspace`
+
+        OUTPUT:
+
+        A new affine subspace, (or ``None`` if the intersection is
+        empty).
+
+        EXAMPLES::
+
+            sage: from sage.geometry.hyperplane_arrangement.affine_subspace import AffineSubspace
+            sage: V = VectorSpace(QQ,3)
+            sage: U = V.subspace([(1,0,0), (0,1,0)])
+            sage: W = V.subspace([(0,1,0), (0,0,1)])
+            sage: A = AffineSubspace((0,0,0), U)
+            sage: B = AffineSubspace((1,1,1), W)
+            sage: A.intersection(B)
+            Affine space p + W where:
+              p = (1, 1, 0)
+              W = Vector space of degree 3 and dimension 1 over Rational Field
+            Basis matrix:
+            [0 1 0]
+            sage: C = AffineSubspace((0,0,1), U)
+            sage: A.intersection(C)
+            sage: C = AffineSubspace((7,8,9), U.complement())
+            sage: A.intersection(C)
+            Affine space p + W where:
+              p = (7, 8, 0)
+              W = Vector space of degree 3 and dimension 0 over Rational Field
+            Basis matrix:
+            []
+            sage: A.intersection(C).intersection(B)
+
+            sage: D = AffineSubspace([1,2,3], VectorSpace(GF(5),3))
+            sage: E = AffineSubspace([3,4,5], VectorSpace(GF(5),3))
+            sage: D.intersection(E)
+            Affine space p + W where:
+              p = (3, 4, 0)
+              W = Vector space of dimension 3 over Finite Field of size 5
+        """
+        if self.linear_part().ambient_vector_space() != \
+           other.linear_part().ambient_vector_space():
+            raise ValueError('incompatible ambient vector spaces')
+        m = self.linear_part().matrix()
+        n = other.linear_part().matrix()
+        p = self.point()
+        q = other.point()
+        M = m.stack(n)
+        v = q - p
+        try:
+            t = M.solve_left(v)
+        except ValueError:
+            return None  # empty intersection
+        new_p = p + t[:m.nrows()]*m
+        new_V = self.linear_part().intersection(other._linear_part)
+        return AffineSubspace(new_p, new_V)

sage/geometry/hyperplane_arrangement/all.py

@@ -0,0 +1 @@
+# sage_setup: distribution = sagemath-polyhedra