if len(LL(K1)) != len(LL(K2)):
return False
- C_of_K1 = discrete_complementarity_set(K1)
- C_of_K2 = discrete_complementarity_set(K2)
+ C_of_K1 = K1.discrete_complementarity_set()
+ C_of_K2 = K2.discrete_complementarity_set()
if len(C_of_K1) != len(C_of_K2):
return False
return Cone(K_W_rays, lattice=L)
-
-def discrete_complementarity_set(K):
- r"""
- Compute a discrete complementarity set of this cone.
-
- A discrete complementarity set of `K` is the set of all orthogonal
- pairs `(x,s)` such that `x \in G_{1}` and `s \in G_{2}` for some
- generating sets `G_{1}` of `K` and `G_{2}` of its dual. Polyhedral
- convex cones are input in terms of their generators, so "the" (this
- particular) discrete complementarity set corresponds to ``G1
- == K.rays()`` and ``G2 == K.dual().rays()``.
-
- OUTPUT:
-
- A list of pairs `(x,s)` such that,
-
- * Both `x` and `s` are vectors (not rays).
- * `x` is one of ``K.rays()``.
- * `s` is one of ``K.dual().rays()``.
- * `x` and `s` are orthogonal.
-
- REFERENCES:
-
- .. [Orlitzky/Gowda] M. Orlitzky and M. S. Gowda. The Lyapunov Rank of an
- Improper Cone. Work in-progress.
-
- EXAMPLES:
-
- The discrete complementarity set of the nonnegative orthant consists
- of pairs of standard basis vectors::
-
- sage: K = Cone([(1,0),(0,1)])
- sage: discrete_complementarity_set(K)
- [((1, 0), (0, 1)), ((0, 1), (1, 0))]
-
- If the cone consists of a single ray, the second components of the
- discrete complementarity set should generate the orthogonal
- complement of that ray::
-
- sage: K = Cone([(1,0)])
- sage: discrete_complementarity_set(K)
- [((1, 0), (0, 1)), ((1, 0), (0, -1))]
- sage: K = Cone([(1,0,0)])
- sage: discrete_complementarity_set(K)
- [((1, 0, 0), (0, 1, 0)),
- ((1, 0, 0), (0, -1, 0)),
- ((1, 0, 0), (0, 0, 1)),
- ((1, 0, 0), (0, 0, -1))]
-
- When the cone is the entire space, its dual is the trivial cone, so
- the discrete complementarity set is empty::
-
- sage: K = Cone([(1,0),(-1,0),(0,1),(0,-1)])
- sage: discrete_complementarity_set(K)
- []
-
- Likewise when this cone is trivial (its dual is the entire space)::
-
- sage: L = ToricLattice(0)
- sage: K = Cone([], ToricLattice(0))
- sage: discrete_complementarity_set(K)
- []
-
- TESTS:
-
- The complementarity set of the dual can be obtained by switching the
- components of the complementarity set of the original cone::
-
- sage: set_random_seed()
- sage: K1 = random_cone(max_ambient_dim=6)
- sage: K2 = K1.dual()
- sage: expected = [(x,s) for (s,x) in discrete_complementarity_set(K2)]
- sage: actual = discrete_complementarity_set(K1)
- sage: sorted(actual) == sorted(expected)
- True
-
- The pairs in the discrete complementarity set are in fact
- complementary::
-
- sage: set_random_seed()
- sage: K = random_cone(max_ambient_dim=6)
- sage: dcs = discrete_complementarity_set(K)
- sage: sum([x.inner_product(s).abs() for (x,s) in dcs])
- 0
-
- """
- V = K.lattice().vector_space()
-
- # Convert rays to vectors so that we can compute inner products.
- xs = [V(x) for x in K.rays()]
-
- # We also convert the generators of the dual cone so that we
- # return pairs of vectors and not (vector, ray) pairs.
- ss = [V(s) for s in K.dual().rays()]
-
- return [(x,s) for x in xs for s in ss if x.inner_product(s) == 0]
-
-
def LL(K):
r"""
- Compute the space `\mathbf{LL}` of all Lyapunov-like transformations
- on this cone.
+ Compute a basis of Lyapunov-like transformations on this cone.
OUTPUT:
sage: set_random_seed()
sage: K = random_cone(max_ambient_dim=8)
- sage: C_of_K = discrete_complementarity_set(K)
+ sage: C_of_K = K.discrete_complementarity_set()
sage: l = [ (L*x).inner_product(s) for (x,s) in C_of_K for L in LL(K) ]
sage: sum(map(abs, l))
0
"""
V = K.lattice().vector_space()
- C_of_K = discrete_complementarity_set(K)
+ C_of_K = K.discrete_complementarity_set()
tensor_products = [ s.tensor_product(x) for (x,s) in C_of_K ]
EXAMPLES:
- todo.
+ The identity is always Lyapunov-like in a nontrivial space::
- TESTS:
+ sage: set_random_seed()
+ sage: K = random_cone(min_ambient_dim = 1, max_rays = 8)
+ sage: L = identity_matrix(K.lattice_dim())
+ sage: is_lyapunov_like(L,K)
+ True
- todo.
+ As is the "zero" transformation::
+
+ sage: K = random_cone(min_ambient_dim = 1, max_rays = 5)
+ sage: R = K.lattice().vector_space().base_ring()
+ sage: L = zero_matrix(R, K.lattice_dim())
+ sage: is_lyapunov_like(L,K)
+ True
+
+ Everything in ``LL(K)`` should be Lyapunov-like on ``K``::
+
+ sage: K = random_cone(min_ambient_dim = 1, max_rays = 5)
+ sage: all([is_lyapunov_like(L,K) for L in LL(K)])
+ True
"""
return all([(L*x).inner_product(s) == 0
- for (x,s) in discrete_complementarity_set(K)])
+ for (x,s) in K.discrete_complementarity_set()])
+
+
+def random_element(K):
+ r"""
+ Return a random element of ``K`` from its ambient vector space.
+
+ ALGORITHM:
+
+ The cone ``K`` is specified in terms of its generators, so that
+ ``K`` is equal to the convex conic combination of those generators.
+ To choose a random element of ``K``, we assign random nonnegative
+ coefficients to each generator of ``K`` and construct a new vector
+ from the scaled rays.
+
+ A vector, rather than a ray, is returned so that the element may
+ have non-integer coordinates. Thus the element may have an
+ arbitrarily small norm.
+
+ EXAMPLES:
+
+ A random element of the trivial cone is zero::
+
+ sage: set_random_seed()
+ sage: K = Cone([], ToricLattice(0))
+ sage: random_element(K)
+ ()
+ sage: K = Cone([(0,)])
+ sage: random_element(K)
+ (0)
+ sage: K = Cone([(0,0)])
+ sage: random_element(K)
+ (0, 0)
+ sage: K = Cone([(0,0,0)])
+ sage: random_element(K)
+ (0, 0, 0)
+
+ TESTS:
+
+ Any cone should contain an element of itself::
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_rays = 8)
+ sage: K.contains(random_element(K))
+ True
+
+ """
+ V = K.lattice().vector_space()
+ F = V.base_ring()
+ coefficients = [ F.random_element().abs() for i in range(K.nrays()) ]
+ vector_gens = map(V, K.rays())
+ scaled_gens = [ coefficients[i]*vector_gens[i]
+ for i in range(len(vector_gens)) ]
+
+ # Make sure we return a vector. Without the coercion, we might
+ # return ``0`` when ``K`` has no rays.
+ v = V(sum(scaled_gens))
+ return v
+
+
+def positive_operators(K):
+ r"""
+ Compute generators of the cone of positive operators on this cone.
+
+ OUTPUT:
+
+ A list of `n`-by-``n`` matrices where ``n == K.lattice_dim()``.
+ Each matrix ``P`` in the list should have the property that ``P*x``
+ is an element of ``K`` whenever ``x`` is an element of
+ ``K``. Moreover, any nonnegative linear combination of these
+ matrices shares the same property.
+
+ EXAMPLES:
+
+ The trivial cone in a trivial space has no positive operators::
+
+ sage: K = Cone([], ToricLattice(0))
+ sage: positive_operators(K)
+ []
+
+ Positive operators on the nonnegative orthant are nonnegative matrices::
+
+ sage: K = Cone([(1,)])
+ sage: positive_operators(K)
+ [[1]]
+
+ sage: K = Cone([(1,0),(0,1)])
+ sage: positive_operators(K)
+ [
+ [1 0] [0 1] [0 0] [0 0]
+ [0 0], [0 0], [1 0], [0 1]
+ ]
+
+ Every operator is positive on the ambient vector space::
+
+ sage: K = Cone([(1,),(-1,)])
+ sage: K.is_full_space()
+ True
+ sage: positive_operators(K)
+ [[1], [-1]]
+
+ sage: K = Cone([(1,0),(-1,0),(0,1),(0,-1)])
+ sage: K.is_full_space()
+ True
+ sage: positive_operators(K)
+ [
+ [1 0] [-1 0] [0 1] [ 0 -1] [0 0] [ 0 0] [0 0] [ 0 0]
+ [0 0], [ 0 0], [0 0], [ 0 0], [1 0], [-1 0], [0 1], [ 0 -1]
+ ]
+
+ TESTS:
+
+ A positive operator on a cone should send its generators into the cone::
+
+ sage: K = random_cone(max_ambient_dim = 6)
+ sage: pi_of_k = positive_operators(K)
+ sage: all([K.contains(p*x) for p in pi_of_k for x in K.rays()])
+ True
+
+ """
+ V = K.lattice().vector_space()
+
+ # Sage doesn't think matrices are vectors, so we have to convert
+ # our matrices to vectors explicitly before we can figure out how
+ # many are linearly-indepenedent.
+ #
+ # The space W has the same base ring as V, but dimension
+ # dim(V)^2. So it has the same dimension as the space of linear
+ # transformations on V. In other words, it's just the right size
+ # to create an isomorphism between it and our matrices.
+ W = VectorSpace(V.base_ring(), V.dimension()**2)
+
+ G1 = [ V(x) for x in K.rays() ]
+ G2 = [ V(s) for s in K.dual().rays() ]
+
+ tensor_products = [ s.tensor_product(x) for x in G1 for s in G2 ]
+
+ # Turn our matrices into long vectors...
+ vectors = [ W(m.list()) for m in tensor_products ]
+
+ # Create the *dual* cone of the positive operators, expressed as
+ # long vectors..
+ L = ToricLattice(W.dimension())
+ pi_dual = Cone(vectors, lattice=L)
+
+ # Now compute the desired cone from its dual...
+ pi_cone = pi_dual.dual()
+
+ # And finally convert its rays back to matrix representations.
+ M = MatrixSpace(V.base_ring(), V.dimension())
+
+ return [ M(v.list()) for v in pi_cone.rays() ]
projects / sage.d.git / blobdiff