First version of deformation cone for pc and polyhedron

Author: jplab

src/doc/en/reference/references/index.rst

@@ -104,6 +104,10 @@ REFERENCES:
              graphs and isoperimetric inequalities*, The Annals of Probability
              32 (2004), no.  3A, 1727-1745.
 
+.. [ACEP2020] Federico Ardila, Federico Castillo, Christopher Eur, Alexander Postnikov,
+         *Coxeter submodular functions and deformations of Coxeter permutahedra*,
+         Advances in Mathematics, Volume 365, 13 May 2020.
+
 .. [ALL2002] P. Auger, G. Labelle and P. Leroux, *Combinatorial
              addition formulas and applications*, Advances in Applied
              Mathematics 28 (2002) 302-342.

src/sage/geometry/polyhedron/base5.py

@@ -659,6 +659,56 @@ def lawrence_polytope(self):
         parent = self.parent().change_ring(self.base_ring(), ambient_dim=self.ambient_dim() + n)
         return parent.element_class(parent, [lambda_V, [], []], None)
 
+    def deformation_cone(self):
+        r"""
+        Return the deformation cone of ``self``.
+
+        Let `P` be a `d`-polytope in `\RR^r` with `n` facets. The deformation
+        cone is a polyhedron in `\RR^n` who points are the right-hand side `b`
+        in `Ax\leq b` where `A` is the matrix of facet normals of ``self``, so
+        that the resulting polytope has a normal fan which is a coarsening of
+        the normal fan of ``self``.
+
+        EXAMPLES::
+
+            sage: tc = Polyhedron([(1, -1), (1/3, 1), (1, 1/3), (-1, 1), (-1, -1)])
+            sage: dc = tc.deformation_cone()
+            sage: dc.an_element()
+            (2, 1, 1, 0, 0)
+            sage: [_.A() for _ in tc.Hrepresentation()]
+            [(1, 0), (0, 1), (0, -1), (-3, -3), (-1, 0)]
+            sage: P = Polyhedron(rays=[(1, 0, 2), (0, 1, 1), (0, -1, 1), (-3, -3, 0), (-1, 0, 0)])
+            sage: P.rays()
+            (A ray in the direction (-1, -1, 0),
+             A ray in the direction (-1, 0, 0),
+             A ray in the direction (0, -1, 1),
+             A ray in the direction (0, 1, 1),
+             A ray in the direction (1, 0, 2))
+
+        .. SEEALSO::
+
+            :meth:`~sage.schemes.toric.variety.Kaehler_cone`
+
+        REFERENCES:
+
+            For more information, see Section 5.4 of [DLRS2010]_ and Section
+            2.2 of [ACEP2020].
+        """
+        from .constructor import Polyhedron
+        A = matrix([_.A() for _ in self.Hrepresentation()])
+        A = A.transpose()
+        A_ker = A.right_kernel_matrix(basis='computed')
+        gale = tuple(A_ker.columns())
+        collection = [_.ambient_H_indices() for _ in self.faces(0)]
+        n = len(gale)
+        K = None
+        for cone_indices in collection:
+            dual_cone = Polyhedron(rays=[gale[i] for i in range(n) if i not in
+                                         cone_indices])
+            K = K.intersection(dual_cone) if K is not None else dual_cone
+        preimages = [A_ker.solve_right(r.vector()) for r in K.rays()]
+        return Polyhedron(lines=A.rows(), rays=preimages)
+
     ###########################################################
     # Binary operations.
     ###########################################################

src/sage/geometry/triangulation/point_configuration.py

@@ -2039,7 +2039,7 @@ def facets_of_simplex(simplex):
     pushing_triangulation = placing_triangulation
 
     @cached_method
-    def Gale_transform(self, points=None):
+    def Gale_transform(self, points=None, homogenize=True):
         r"""
         Return the Gale transform of ``self``.
 
@@ -2049,6 +2049,9 @@ def Gale_transform(self, points=None):
           (default). A subset of points for which to compute the Gale
           transform. By default, all points are used.
 
+        - ``homogenize`` -- boolean (default: ``True``); whether to add a row
+          of 1's before taking the transform.
+
         OUTPUT: a matrix over :meth:`base_ring`
 
         EXAMPLES::
@@ -2064,6 +2067,50 @@ def Gale_transform(self, points=None):
             sage: points = (pc.point(0), pc.point(1), pc.point(3), pc.point(4))
             sage: pc.Gale_transform(points)
             [ 1 -1  1 -1]
+
+        It is possible to take the inverse of the Gale transform, by specifying
+        whether to homogenize or not::
+
+            sage: pc2 = PointConfiguration([[0,0],[3,0],[0,3],[3,3],[1,1]])
+            sage: pc2.Gale_transform(homogenize=False)
+            [-1  0  0  0  0]
+            [ 0  1  1 -1  0]
+            [ 0  1  1  0 -3]
+            sage: pc2.Gale_transform(homogenize=True)
+            [ 1  1  1  0 -3]
+            [ 0  2  2 -1 -3]
+
+        It might not affect the dimension of the result:: 
+
+            sage: PC = PointConfiguration([[4,0,0],[0,4,0],[0,0,4],[2,1,1],[1,2,1],[1,1,2]])
+            sage: GT = PC.Gale_transform(homogenize=False);GT
+            [ 2  1  1 -4  0  0]
+            [ 1  2  1  0 -4  0]
+            [-2 -2 -1  3  3 -1]
+            sage: GT = PC.Gale_transform(homogenize=True);GT
+            [ 1  0  0 -3  1  1]
+            [ 0  1  0  1 -3  1]
+            [ 0  0  1  1  1 -3]
+
+        The following point configuration is totally cyclic (the cone spanned
+        by the vectors is equal to the vector space spanned by the points),
+        hence its Gale dual is acyclic (there is a linear functional that is
+        positive in all the points of the configuration) when not homogenized::
+
+            sage: pc3 = PointConfiguration([[-1, -1, -1], [-1, 0, 0], [0, -1, 0], [0, 0, -1], [1, 0, 0], [0, 0, 1], [0, 1, 0]])
+            sage: g_hom = pc3.Gale_transform(homogenize=True);g_hom
+            [ 1  0  0 -2  1 -1  1]
+            [ 0  1  0 -1  1 -1  0]
+            [ 0  0  1 -1  0 -1  1]
+            sage: g_inhom = pc3.Gale_transform(homogenize=False);g_inhom
+            [-1  1  1  1  0  0  0]
+            [ 0  1  0  0  1  0  0]
+            [ 1 -1 -1  0  0  1  0]
+            [ 0  0  1  0  0  0  1]
+            sage: Polyhedron(rays=g_hom.columns())
+            A 3-dimensional polyhedron in ZZ^3 defined as the convex hull of 1 vertex and 3 lines
+            sage: Polyhedron(rays=g_inhom.columns())
+            A 4-dimensional polyhedron in ZZ^4 defined as the convex hull of 1 vertex and 4 rays
         """
         self._assert_is_affine()
         if points is None:
@@ -2073,9 +2120,73 @@ def Gale_transform(self, points=None):
                 points = [ self.point(ZZ(i)) for i in points ]
             except TypeError:
                 pass
-        m = matrix([ (1,) + p.affine() for p in points])
+        if homogenize:
+            m = matrix([ (1,) + p.affine() for p in points])
+        else:
+            m = matrix([p.affine() for p in points])
         return m.left_kernel().matrix()
 
+    def deformation_cone(self, collection):
+        r"""
+        Return the deformation cone for the ``collection`` of subconfigurations
+        of ``self``.
+
+        INPUT:
+
+        - ``collection`` -- a collection of subconfigurations of ``self``.
+          Subconfigurations are given as indices
+
+        OUTPUT: a polyhedron. It contains the liftings of the point configuration 
+        making the collection a regular (or coherent, or projective)
+        subdivision.
+
+        EXAMPLES::
+
+            sage: PC = PointConfiguration([(-1, -1), (-1, 0), (0, -1), (1, 0), (0, 1)])
+            sage: coll = [(1, 4), (0, 2), (0, 1), (2, 3), (3, 4)]
+            sage: dc = PC.deformation_cone(coll);dc
+            A 5-dimensional polyhedron in QQ^5 defined as the convex hull of 1 vertex, 3 rays, 2 lines
+            sage: dc.rays()
+            (A ray in the direction (1, 0, 1, 0, 0),
+             A ray in the direction (1, 1, 0, 0, 0),
+             A ray in the direction (1, 1, 1, 0, 0))
+            sage: dc.lines()
+            (A line in the direction (1, 0, 1, 0, -1),
+             A line in the direction (1, 1, 0, -1, 0))
+            sage: dc.an_element()
+            (3, 2, 2, 0, 0)
+
+        We add to the interior element the first line and we verify that the
+        given rays are defining rays of the lower hull::
+
+            sage: P = Polyhedron(rays=[(-1, -1, 4), (-1, 0, 3), (0, -1, 2), (1, 0, -1), (0, 1, 0)])
+            sage: P.rays()
+            (A ray in the direction (-1, -1, 4),
+             A ray in the direction (-1, 0, 3),
+             A ray in the direction (0, -1, 2),
+             A ray in the direction (0, 1, 0),
+             A ray in the direction (1, 0, -1))
+
+        .. SEEALSO::                                                                                                                                                                                        
+                   
+            :meth:`~sage.schemes.toric.variety.Kaehler_cone`
+                   
+        REFERENCES:
+                   
+            For more information, see Section 5.4 of [DLRS2010]_ and Section
+            2.2 of [ACEP2020].
+        """
+        from sage.geometry.polyhedron.constructor import Polyhedron
+        gale = self.Gale_transform(homogenize=False)
+        dual_rays = gale.columns()
+        n = self.n_points()
+        K = None
+        for cone_indices in collection:
+            dual_cone = Polyhedron(rays=[dual_rays[i] for i in range(n) if i not in cone_indices])
+            K = K.intersection(dual_cone) if K is not None else dual_cone
+        preimages = [gale.solve_right(r.vector()) for r in K.rays()]
+        return Polyhedron(lines=matrix(self.points()).transpose().rows(),rays=preimages)
+
     def plot(self, **kwds):
         r"""
         Produce a graphical representation of the point configuration.