def motzkin_decomposition(K):
r"""
- Return the pair of components in the motzkin decomposition of this cone.
+ Return the pair of components in the Motzkin decomposition of this cone.
Every convex cone is the direct sum of a strictly convex cone and a
- linear subspace. Return a pair ``(P,S)`` of cones such that ``P`` is
- strictly convex, ``S`` is a subspace, and ``K`` is the direct sum of
- ``P`` and ``S``.
+ linear subspace [Stoer-Witzgall]_. Return a pair ``(P,S)`` of cones
+ such that ``P`` is strictly convex, ``S`` is a subspace, and ``K``
+ is the direct sum of ``P`` and ``S``.
OUTPUT:
``P`` is strictly convex, ``S`` is a subspace, and ``K`` is the
direct sum of ``P`` and ``S``.
+ REFERENCES:
+
+ .. [Stoer-Witzgall] J. Stoer and C. Witzgall. Convexity and
+ Optimization in Finite Dimensions I. Springer-Verlag, New
+ York, 1970.
+
EXAMPLES:
The nonnegative orthant is strictly convex, so it is its own
sage: S.lineality() == S.dim()
True
- The generators of the strictly convex component are obtained from
- the orthogonal projections of the original generators onto the
- orthogonal complement of the subspace component::
+ The generators of the components are obtained from orthogonal
+ projections of the original generators [Stoer-Witzgall]_::
sage: set_random_seed()
sage: K = random_cone(max_ambient_dim=8)
sage: (P,S) = motzkin_decomposition(K)
- sage: S_perp = S.linear_subspace().complement()
- sage: A = S_perp.matrix().transpose()
- sage: proj = A * (A.transpose()*A).inverse() * A.transpose()
- sage: expected = Cone([ proj*g for g in K ], K.lattice())
- sage: P.is_equivalent(expected)
+ sage: A = S.linear_subspace().complement().matrix()
+ sage: proj_S_perp = A.transpose() * (A*A.transpose()).inverse() * A
+ sage: expected_P = Cone([ proj_S_perp*g for g in K ], K.lattice())
+ sage: P.is_equivalent(expected_P)
+ True
+ sage: A = S.linear_subspace().matrix()
+ sage: proj_S = A.transpose() * (A*A.transpose()).inverse() * A
+ sage: expected_S = Cone([ proj_S*g for g in K ], K.lattice())
+ sage: S.is_equivalent(expected_S)
True
"""
- linspace_gens = [ copy(b) for b in K.linear_subspace().basis() ]
- linspace_gens += [ -b for b in linspace_gens ]
+ # The lines() method only returns one generator per line. For a true
+ # line, we also need a generator pointing in the opposite direction.
+ S_gens = [ direction*gen for direction in [1,-1] for gen in K.lines() ]
+ S = Cone(S_gens, K.lattice())
- S = Cone(linspace_gens, K.lattice())
-
- # Since ``S`` is a subspace, its dual is its orthogonal complement
- # (albeit in the wrong lattice).
+ # Since ``S`` is a subspace, the rays of its dual generate its
+ # orthogonal complement.
S_perp = Cone(S.dual(), K.lattice())
P = K.intersection(S_perp)
return (P,S)
+
def positive_operator_gens(K):
r"""
Compute generators of the cone of positive operators on this cone.
EXAMPLES:
- The trivial cone in a trivial space has no positive operators::
-
- sage: K = Cone([], ToricLattice(0))
- sage: positive_operator_gens(K)
- []
-
Positive operators on the nonnegative orthant are nonnegative matrices::
sage: K = Cone([(1,)])
[0 0], [0 0], [1 0], [0 1]
]
+ The trivial cone in a trivial space has no positive operators::
+
+ sage: K = Cone([], ToricLattice(0))
+ sage: positive_operator_gens(K)
+ []
+
+ Every operator is positive on the trivial cone::
+
+ sage: K = Cone([(0,)])
+ sage: positive_operator_gens(K)
+ [[1], [-1]]
+
+ sage: K = Cone([(0,0)])
+ sage: K.is_trivial()
+ True
+ sage: positive_operator_gens(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]
+ ]
+
Every operator is positive on the ambient vector space::
sage: K = Cone([(1,),(-1,)])
[0 0], [ 0 0], [0 0], [ 0 0], [1 0], [-1 0], [0 1], [ 0 -1]
]
+ A non-obvious application is to find the positive operators on the
+ right half-plane::
+
+ sage: K = Cone([(1,0),(0,1),(0,-1)])
+ sage: positive_operator_gens(K)
+ [
+ [1 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::
+ Each positive operator generator should send the generators of the
+ cone into the cone::
sage: set_random_seed()
sage: K = random_cone(max_ambient_dim=5)
sage: pi_of_K = positive_operator_gens(K)
- sage: all([K.contains(p*x) for p in pi_of_K for x in K.rays()])
+ sage: all([ K.contains(P*x) for P in pi_of_K for x in K ])
+ True
+
+ Each positive operator generator should send a random element of the
+ cone into the cone::
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_ambient_dim=5)
+ sage: pi_of_K = positive_operator_gens(K)
+ sage: all([ K.contains(P*K.random_element()) for P in pi_of_K ])
+ True
+
+ A random element of the positive operator cone should send the
+ generators of the cone into the cone::
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_ambient_dim=5)
+ sage: pi_of_K = positive_operator_gens(K)
+ sage: L = ToricLattice(K.lattice_dim()**2)
+ sage: pi_cone = Cone([ g.list() for g in pi_of_K ], lattice=L)
+ sage: P = matrix(K.lattice_dim(), pi_cone.random_element().list())
+ sage: all([ K.contains(P*x) for x in K ])
+ True
+
+ A random element of the positive operator cone should send a random
+ element of the cone into the cone::
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_ambient_dim=5)
+ sage: pi_of_K = positive_operator_gens(K)
+ sage: L = ToricLattice(K.lattice_dim()**2)
+ sage: pi_cone = Cone([ g.list() for g in pi_of_K ], lattice=L)
+ sage: P = matrix(K.lattice_dim(), pi_cone.random_element().list())
+ sage: K.contains(P*K.random_element())
True
The dimension of the cone of positive operators is given by the
projects / sage.d.git / blobdiff