def graph_implementation(arg_objs, size, data=None): """Reduces the atom to an affine expression and list of constraints. Parameters ---------- arg_objs : list LinExpr for each argument. size : tuple The size of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ A = arg_objs[0] rows, cols = A.size # Create the equivalent problem: # minimize (trace(U) + trace(V))/2 # subject to: # [U A; A.T V] is positive semidefinite X = lu.create_var((rows+cols, rows+cols)) constraints = [] # Fix X using the fact that A must be affine by the DCP rules. # X[0:rows,rows:rows+cols] == A index.block_eq(X, A, constraints, 0, rows, rows, rows+cols) half = lu.create_const(0.5, (1, 1)) trace = lu.mul_expr(half, lu.trace(X), (1, 1)) # Add SDP constraint. return (trace, [SDP(X)] + constraints)
def graph_implementation(arg_objs, size, data=None): """Reduces the atom to an affine expression and list of constraints. Parameters ---------- arg_objs : list LinExpr for each argument. size : tuple The size of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ A = arg_objs[0] rows, cols = A.size # Create the equivalent problem: # minimize (trace(U) + trace(V))/2 # subject to: # [U A; A.T V] is positive semidefinite X = lu.create_var((rows + cols, rows + cols)) constraints = [] # Fix X using the fact that A must be affine by the DCP rules. # X[0:rows,rows:rows+cols] == A index.block_eq(X, A, constraints, 0, rows, rows, rows + cols) half = lu.create_const(0.5, (1, 1)) trace = lu.mul_expr(half, lu.trace(X), (1, 1)) # Add SDP constraint. return (trace, [SDP(X)] + constraints)
def graph_implementation(arg_objs, size, data=None): """Reduces the atom to an affine expression and list of constraints. Parameters ---------- arg_objs : list LinExpr for each argument. size : tuple The size of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ X = arg_objs[0] # n by m matrix. P = arg_objs[1] # n by n matrix. n, m = X.size # Create a matrix with Schur complement T - X.T*P^-1*X. M = lu.create_var((n + m, n + m)) T = lu.create_var((m, m)) constraints = [] # Fix M using the fact that P must be affine by the DCP rules. # M[0:n, 0:n] == P. index.block_eq(M, P, constraints, 0, n, 0, n) # M[0:n, n:n+m] == X index.block_eq(M, X, constraints, 0, n, n, n + m) # M[n:n+m, n:n+m] == T index.block_eq(M, T, constraints, n, n + m, n, n + m) # Add SDP constraint. return (lu.trace(T), constraints + [SDP(M)])
def graph_implementation(arg_objs, size, data=None): """Sum the diagonal entries of the linear expression. Parameters ---------- arg_objs : list LinExpr for each argument. size : tuple The size of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ return (lu.trace(arg_objs[0]), [])
def graph_implementation(arg_objs, size, data=None): """Sum the diagonal entries of the linear expression. Parameters ---------- arg_objs : list LinExpr for each argument. size : tuple The size of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ return (lu.trace(arg_objs[0]), [])
def graph_implementation(self, arg_objs, shape: Tuple[int, ...], data=None) -> Tuple[lo.LinOp, List[Constraint]]: """Sum the diagonal entries of the linear expression. Parameters ---------- arg_objs : list LinExpr for each argument. shape : tuple The shape of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ return (lu.trace(arg_objs[0]), [])
def graph_implementation(arg_objs, size, data=None): """Reduces the atom to an affine expression and list of constraints. Parameters ---------- arg_objs : list LinExpr for each argument. size : tuple The size of the resulting expression. data : Additional data required by the atom. Returns ------- tuple (LinOp for objective, list of constraints) """ X = arg_objs[0] # n by m matrix. P = arg_objs[1] # n by n matrix. n, m = X.size # Create a matrix with Schur complement T - X.T*P^-1*X. M = lu.create_var((n + m, n + m)) T = lu.create_var((m, m)) constraints = [] # Fix M using the fact that P must be affine by the DCP rules. # M[0:n, 0:n] == P. index.block_eq(M, P, constraints, 0, n, 0, n) # M[0:n, n:n+m] == X index.block_eq(M, X, constraints, 0, n, n, n+m) # M[n:n+m, n:n+m] == T index.block_eq(M, T, constraints, n, n+m, n, n+m) # Add SDP constraint. return (lu.trace(T), constraints + [SDP(M)])