+def Z_transformation_gens(K):
+ r"""
+ Compute generators of the cone of Z-transformations on this cone.
+
+ OUTPUT:
+
+ A list of `n`-by-``n`` matrices where ``n == K.lattice_dim()``.
+ Each matrix ``L`` in the list should have the property that
+ ``(L*x).inner_product(s) <= 0`` whenever ``(x,s)`` is an element the
+ discrete complementarity set of ``K``. Moreover, any nonnegative
+ linear combination of these matrices shares the same property.
+
+ EXAMPLES:
+
+ Z-transformations on the nonnegative orthant are just Z-matrices.
+ That is, matrices whose off-diagonal elements are nonnegative::
+
+ sage: K = Cone([(1,0),(0,1)])
+ sage: Z_transformation_gens(K)
+ [
+ [ 0 -1] [ 0 0] [-1 0] [1 0] [ 0 0] [0 0]
+ [ 0 0], [-1 0], [ 0 0], [0 0], [ 0 -1], [0 1]
+ ]
+ sage: K = Cone([(1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)])
+ sage: all([ z[i][j] <= 0 for z in Z_transformation_gens(K)
+ ....: for i in range(z.nrows())
+ ....: for j in range(z.ncols())
+ ....: if i != j ])
+ True
+
+ The trivial cone in a trivial space has no Z-transformations::
+
+ sage: K = Cone([], ToricLattice(0))
+ sage: Z_transformation_gens(K)
+ []
+
+ Z-transformations on a subspace are Lyapunov-like and vice-versa::
+
+ sage: K = Cone([(1,0),(-1,0),(0,1),(0,-1)])
+ sage: K.is_full_space()
+ True
+ sage: lls = span([ vector(l.list()) for l in K.lyapunov_like_basis() ])
+ sage: zs = span([ vector(z.list()) for z in Z_transformation_gens(K) ])
+ sage: zs == lls
+ True
+
+ TESTS:
+
+ The Z-property is possessed by every Z-transformation::
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_ambient_dim=6)
+ sage: Z_of_K = Z_transformation_gens(K)
+ sage: dcs = K.discrete_complementarity_set()
+ sage: all([(z*x).inner_product(s) <= 0 for z in Z_of_K
+ ....: for (x,s) in dcs])
+ True
+
+ The lineality space of Z is LL::
+
+ sage: set_random_seed()
+ sage: K = random_cone(min_ambient_dim=1, max_ambient_dim=6)
+ sage: lls = span([ vector(l.list()) for l in K.lyapunov_like_basis() ])
+ sage: z_cone = Cone([ z.list() for z in Z_transformation_gens(K) ])
+ sage: z_cone.linear_subspace() == lls
+ True
+
+ And thus, the lineality of Z is the Lyapunov rank::
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_ambient_dim=6)
+ sage: Z_of_K = Z_transformation_gens(K)
+ sage: L = ToricLattice(K.lattice_dim()**2)
+ sage: z_cone = Cone([ z.list() for z in Z_of_K ], lattice=L)
+ sage: z_cone.lineality() == K.lyapunov_rank()
+ True
+
+ The lineality spaces of pi-star and Z-star are equal:
+
+ sage: set_random_seed()
+ sage: K = random_cone(max_ambient_dim=5)
+ sage: pi_of_K = positive_operator_gens(K)
+ sage: Z_of_K = Z_transformation_gens(K)
+ sage: L = ToricLattice(K.lattice_dim()**2)
+ sage: pi_star = Cone([p.list() for p in pi_of_K], lattice=L).dual()
+ sage: z_star = Cone([ z.list() for z in Z_of_K], lattice=L).dual()
+ sage: pi_star.linear_subspace() == z_star.linear_subspace()
+ True
+ """
+ # Matrices are not vectors in Sage, so we have to convert them
+ # to vectors explicitly before we can find a basis. We need these
+ # two values to construct the appropriate "long vector" space.
+ F = K.lattice().base_field()
+ n = K.lattice_dim()
+
+ # These tensor products contain generators for the dual cone of
+ # the cross-positive transformations.
+ tensor_products = [ s.tensor_product(x)
+ for (x,s) in K.discrete_complementarity_set() ]
+
+ # Turn our matrices into long vectors...
+ W = VectorSpace(F, n**2)
+ vectors = [ W(m.list()) for m in tensor_products ]
+
+ # Create the *dual* cone of the cross-positive operators,
+ # expressed as long vectors..
+ Sigma_dual = Cone(vectors, lattice=ToricLattice(W.dimension()))
+
+ # Now compute the desired cone from its dual...
+ Sigma_cone = Sigma_dual.dual()
+
+ # And finally convert its rays back to matrix representations.
+ # But first, make them negative, so we get Z-transformations and
+ # not cross-positive ones.
+ M = MatrixSpace(F, n)
+ return [ -M(v.list()) for v in Sigma_cone.rays() ]
+
+
+def Z_cone(K):
+ gens = Z_transformation_gens(K)
+ L = None
+ if len(gens) == 0:
+ L = ToricLattice(0)
+ return Cone([ g.list() for g in gens ], lattice=L)
+
+def pi_cone(K):
+ gens = positive_operator_gens(K)
+ L = None
+ if len(gens) == 0:
+ L = ToricLattice(0)
+ return Cone([ g.list() for g in gens ], lattice=L)