Try the span_iso approach to fix my isomorphism tests.

[sage.d.git] / mjo / cone / cone.py

diff --git a/mjo/cone/cone.py b/mjo/cone/cone.py
index 4b0193692edd7655f2880408d143bf141e6d567c..3f5a4fed4e1c49853f00eafcf6084744223ca296 100644 (file)
--- a/mjo/cone/cone.py
+++ b/mjo/cone/cone.py
@@ -7,6 +7,92 @@ addsitedir(abspath('../../'))
 
 from sage.all import *
 
+def rename_lattice(L,s):
+    r"""
+    Change all names of the given lattice to ``s``.
+    """
+    L._name = s
+    L._dual_name = s
+    L._latex_name = s
+    L._latex_dual_name = s
+
+def span_iso(K):
+    r"""
+    Return an isomorphism (and its inverse) that will send ``K`` into a
+    lower-dimensional space isomorphic to its span (and back).
+
+    EXAMPLES:
+
+    The inverse composed with the isomorphism should be the identity::
+
+        sage: K = random_cone(max_dim=10)
+        sage: (phi, phi_inv) = span_iso(K)
+        sage: phi_inv(phi(K)) == K
+        True
+
+    The image of ``K`` under the isomorphism should have full dimension::
+
+        sage: K = random_cone(max_dim=10)
+        sage: (phi, phi_inv) = span_iso(K)
+        sage: phi(K).dim() == phi(K).lattice_dim()
+        True
+
+    The isomorphism should be an inner product space isomorphism, and
+    thus it should preserve dual cones (and commute with the "dual"
+    operation). But beware the automatic renaming of the dual lattice.
+    OH AND YOU HAVE TO SORT THE CONES::
+
+        sage: K = random_cone(max_dim=10, strictly_convex=False, solid=True)
+        sage: L = K.lattice()
+        sage: rename_lattice(L, 'L')
+        sage: (phi, phi_inv) = span_iso(K)
+        sage: sorted(phi_inv( phi(K).dual() )) == sorted(K.dual())
+        True
+
+    We may need to isomorph twice to make sure we stop moving down to
+    smaller spaces. (Once you've done this on a cone and its dual, the
+    result should be proper.) OH AND YOU HAVE TO SORT THE CONES::
+
+        sage: K = random_cone(max_dim=10, strictly_convex=False, solid=False)
+        sage: L = K.lattice()
+        sage: rename_lattice(L, 'L')
+        sage: (phi, phi_inv) = span_iso(K)
+        sage: K_S = phi(K)
+        sage: (phi_dual, phi_dual_inv) = span_iso(K_S.dual())
+        sage: J_T = phi_dual(K_S.dual()).dual()
+        sage: phi_inv(phi_dual_inv(J_T)) == K
+        True
+
+    """
+    phi_domain = K.sublattice().vector_space()
+    phi_codo = VectorSpace(phi_domain.base_field(), phi_domain.dimension())
+
+    # S goes from the new space to the cone space.
+    S = linear_transformation(phi_codo, phi_domain, phi_domain.basis())
+
+    # phi goes from the cone space to the new space.
+    def phi(J_orig):
+        r"""
+        Takes a cone ``J`` and sends it into the new space.
+        """
+        newrays = map(S.inverse(), J_orig.rays())
+        L = None
+        if len(newrays) == 0:
+            L = ToricLattice(0)
+
+        return Cone(newrays, lattice=L)
+
+    def phi_inverse(J_sub):
+        r"""
+        The inverse to phi which goes from the new space to the cone space.
+        """
+        newrays = map(S, J_sub.rays())
+        return Cone(newrays, lattice=K.lattice())
+
+
+    return (phi, phi_inverse)
+
+
 
 def discrete_complementarity_set(K):
     r"""
@@ -233,6 +319,9 @@ def lyapunov_rank(K):
        cone and Lyapunov-like transformations, Mathematical Programming, 147
        (2014) 155-170.
 
+    .. [Orlitzky/Gowda] M. Orlitzky and M. S. Gowda. The Lyapunov Rank of an
+       Improper Cone. Work in-progress.
+
     .. [Rudolf et al.] G. Rudolf, N. Noyan, D. Papp, and F. Alizadeh, Bilinear
        optimality constraints for the cone of positive polynomials,
        Mathematical Programming, Series B, 129 (2011) 5-31.
@@ -321,5 +410,31 @@ def lyapunov_rank(K):
         sage: b == n-1
         False
 
+    In fact [Orlitzky/Gowda]_, no closed convex polyhedral cone can have
+    Lyapunov rank `n-1` in `n` dimensions::
+
+        sage: K = random_cone(max_dim=10)
+        sage: b = lyapunov_rank(K)
+        sage: n = K.lattice_dim()
+        sage: b == n-1
+        False
+
+    The calculation of the Lyapunov rank of an improper cone can be
+    reduced to that of a proper cone [Orlitzky/Gowda]_::
+
+        sage: K = random_cone(max_dim=15, solid=False, strictly_convex=False)
+        sage: actual = lyapunov_rank(K)
+        sage: (phi1, phi1_inv) = span_iso(K)
+        sage: K_S = phi1(K)
+        sage: (phi2, phi2_inv) = span_iso(K_S.dual())
+        sage: J_T = phi2(K_S.dual()).dual()
+        sage: phi1_inv(phi2_inv(J_T)) == K
+        True
+        sage: l = K.linear_subspace().dimension()
+        sage: codim = K.lattice_dim() - K.dim()
+        sage: expected = lyapunov_rank(J_T) + K.dim()*(l + codim) + codim**2
+        sage: actual == expected
+        True
+
     """
     return len(LL(K))