def setUp(self):
# Data.
c = picos.new_param("c", cvxopt.matrix([1, 2, 3, 4, 5]))
A = picos.new_param("A", [
cvxopt.matrix([1, 0, 0, 0, 0]).T,
cvxopt.matrix([0, 0, 2, 0, 0]).T,
cvxopt.matrix([0, 0, 0, 2, 0]).T,
cvxopt.matrix([1, 0, 0, 0, 0]).T,
cvxopt.matrix([1, 0, 2, 0, 0]).T,
cvxopt.matrix([0, 1, 1, 1, 0]).T,
cvxopt.matrix([1, 2, 0, 0, 0]).T,
cvxopt.matrix([1, 0, 3, 0, 1]).T
])
self.n = n = len(A)
self.m = m = c.size[0]
# Primal problem.
self.P = P = picos.Problem()
self.u = u = P.add_variable("u", m)
P.set_objective("min", c | u)
self.C = P.add_list_of_constraints(
[abs(A[i] * u) < 1 for i in range(n)], "i", "[n]")
# Dual problem.
self.D = D = picos.Problem()
self.z = z = [D.add_variable("z[{}]".format(i)) for i in range(n)]
self.mu = mu = D.add_variable("mu", n)
D.set_objective("min", 1 | mu)
D.add_list_of_constraints([abs(z[i]) < mu[i] for i in range(n)], "i",
"[n]")
D.add_constraint(
picos.sum([A[i].T * z[i] for i in range(n)], "i", "[n]") == c)
def DOBSS(AttackerRF, DefenderRF, Prob):
prob = pic.Problem()
l = len(DefenderRF[0])
m = len(DefenderRF[0][0])
tnum = len(DefenderRF)
x = prob.add_variable('x', l, lower=0, upper=1)
na = prob.add_variable('na', (tnum, m), 'binary')
v = prob.add_variable('v', tnum)
rfa = pic.new_param('rfa', AttackerRF)
rfd = pic.new_param('rfd', DefenderRF)
pr = pic.new_param('pr', Prob)
prob.add_constraint(pic.sum([x[i] for i in range(l)], 'i', '[l]') == 1)
for j in range(0, tnum):
prob.add_constraint(
pic.sum([na[j, i] for i in range(m)], 'i', '[m]') == 1)
for j in range(0, tnum):
prob.add_list_of_constraints(
[v[j] - (x.T * rfa[j])[i] > 0 for i in range(m)], 'i', '[m]')
prob.add_list_of_constraints([
v[j] - (x.T * rfa[j])[i] < 1000000 * (1 - na[j, i])
for i in range(m)
], 'i', '[m]')
obj = 0
for j in range(0, tnum):
obj = obj + pr[j] * x.T * rfd[j] * (na[j, :]).T
#obj = pic.sum([pr[p]*x.T*rfd[p]*(na[p,:]).T for p in range(tnum)],'p','[tnum]')
prob.set_objective('max', obj)
prob.solve(verbose=0)
return np.array(x), np.array(obj)
def calc_update(graph, alive_points, alpha, beta, eta, s, verbose=False):
# Update coloring for alive variables
incidence = graph.incidence[alive_points]
(living_n, m) = np.shape(incidence)
# Calculates each dangerosity of S_j
dangerosity = np.zeros(m, dtype=int)
max_k = beta.size - 1
for j in range(m):
k = max(0, np.searchsorted(beta, abs(eta[j])) - 1)
if (k == max_k):
raise AlgorithmFailure
else:
dangerosity[j] = k
# print("dangerosity =", dangerosity)
sdp = pic.Problem()
Xp = sdp.add_variable("X", (living_n, living_n), vtype='symmetric')
if verbose:
print('incidence mat. of alive points =')
print(incidence)
vs = [incidence[:, j] for j in range(m)]
vvs = [
pic.new_param('vv' + str(j), np.outer(vs[j], vs[j])) for j in range(m)
]
iden = pic.new_param('I', np.identity(living_n, dtype=int))
if verbose:
# print("I =", iden)
print('vs =', vs)
print('vvs =', [np.outer(vs[j], vs[j]) for j in range(m)])
sdp.add_constraint(iden | Xp > living_n * 0.5)
sdp.add_list_of_constraints(
[vvs[j] | Xp < alpha[dangerosity[j]] for j in range(m)])
sdp.add_list_of_constraints([Xp[i, i] < 1 for i in range(living_n)])
sdp.add_constraint(Xp >> 0)
sdp.set_objective('find', 0)
if verbose:
print(sdp)
sdp.solve(verbose=0)
v = np.linalg.cholesky(Xp.value)
g = np.array([np.random.normal() for i in range(living_n)])
gamma = np.zeros(graph.n)
short_idx = 0
for (i, flag) in enumerate(alive_points):
if flag:
gamma[i] = s * np.dot(g, v[:, short_idx])
short_idx += 1
if verbose:
print('v =', v)
print('gamma =', gamma)
return gamma
def unpack_params_picos(params):
'''
:param params: list [c, q, xi_0, b]
:return:
'''
c = pic.new_param('c', params[0])
q = pic.new_param('q', params[1])
xi_0 = pic.new_param('xi_0', params[2])
b = pic.new_param('b', params[3])
B = pic.new_param('B', np.diag(params[3]))
return c, q, xi_0, b, B
def calc_update(graph, alive_points, coloring, verbose=False):
# Updates alive variables
incidence = graph.incidence[alive_points]
(remaining_n, l) = np.shape(incidence)
sdp = pic.Problem()
Xp = sdp.add_variable("X", (remaining_n, remaining_n), vtype='symmetric')
a = 6
big_set_flags = (np.sum(incidence == 1, axis=0) >= a * graph.degree)
alive_coloring = coloring[alive_points]
if verbose:
print('incidence mat. of alive points =')
print(incidence)
vs = [incidence[:, i] for i in range(l)]
xs = [vs[i] * alive_coloring for i in range(l)]
vvs = [
pic.new_param('vv' + str(i), np.outer(vs[i], vs[i])) for i in range(l)
]
iden = pic.new_param('I', np.identity(remaining_n))
xxs = [
pic.new_param('xx' + str(i), np.outer(xs[i], xs[i])) for i in range(l)
]
if verbose:
print('vs =')
print(vs)
print('xs =')
print(xs)
print('vvs =')
print([np.outer(vs[i], vs[i]) for i in range(l)])
print('xxs =')
print([np.outer(xs[i], xs[i]) for i in range(l)])
sdp.add_list_of_constraints(
[vvs[i] | Xp == 0 for i in range(l) if big_set_flags[i]])
sdp.add_list_of_constraints([(vvs[i] - 2 * iden) | Xp < 0 for i in range(l)
if not big_set_flags[i]])
sdp.add_list_of_constraints([(xxs[i] - 2 * iden) | Xp < 0 for i in range(l)
if not big_set_flags[i]])
sdp.add_list_of_constraints([Xp[i, i] < 1 for i in range(remaining_n)])
sdp.add_constraint(Xp >> 0)
sdp.set_objective('max', pic.trace(Xp))
sdp.solve(verbose=0)
U = np.linalg.cholesky(Xp.value)
if verbose:
print(sdp)
print('U =')
print(U)
return (np.linalg.cholesky(Xp.value))
def solve_SAA(params, Xi, r):
N = Xi.shape[0]
Xi_pic = [pic.new_param('xi_' + str(i + 1), Xi[i]) for i in range(N)]
# Unpack problem parameters
c, q, xi_0, b, B = unpack_params_picos(params)
r = pic.new_param('r', r)
# Unpack artificial parameters
E, c_tilde, E_tilde_arr, E_arr, e5 = define_art_params(
c.get_value(), q.get_value(), xi_0)
E, c_tilde, E_tilde_arr, E_arr, e5 = convert_art_params_picos(
E, c_tilde, E_tilde_arr, E_arr, e5)
# Get dimensions.
x_dim = len(c)
xi_dim = len(xi_0)
num_piecewise_lin_f = len(E_tilde_arr)
# Initialize picos problem.
pb = pic.Problem()
# Add variables.
x_tilde = pb.add_variable("x_tilde", x_dim + 1)
t = pb.add_variable("t", N)
eta1_arr = [
pb.add_variable("eta1_" + str(i + 1), xi_dim) for i in range(2)
]
eta2_arr = [pb.add_variable("eta2_" + str(i + 1), 10) for i in range(2)]
# Add constraints.
for i in range(N):
for j in range(num_piecewise_lin_f):
pb.add_constraint((E_tilde_arr[j] * Xi_pic[i]) | x_tilde <= t[i])
for j in range(2):
pb.add_constraint(
abs(B.T * E_arr[j].T * x_tilde - B.T *
(eta1_arr[j] - eta2_arr[j])) <= MAX_MAN_HOUR -
(x_tilde.T * E_arr[j] * xi_0 / r) -
((eta1_arr[j] + eta2_arr[j]) | b / r))
# positivity of lagrange multipliers
pb.add_constraint(eta1_arr[j] >= 0)
pb.add_constraint(eta2_arr[j] >= 0)
pb.add_constraint(E.T * x_tilde >= 0)
pb.add_constraint(e5 | x_tilde == -1)
# Set objective.
pb.set_objective("min", (1 / N) * (1 | t) - (c_tilde | x_tilde))
solution = pb.solve(solver='cvxopt')
opt_val = -pb.obj_value()
opt_sol = np.array(solution['cvxopt_sol']['x'][:x_dim]).reshape(-1).round(
5) # round 5 digits
return opt_sol, opt_val
def convert_art_params_picos(E, c_tilde, E_tilde_arr, E_arr, e5):
E = pic.new_param('E', E)
c_tilde = pic.new_param('c_tilde', c_tilde)
E_tilde_arr = [pic.new_param('E_tilde_1', E_tilde_arr[0]),
pic.new_param('E_tilde_2', E_tilde_arr[1]),
pic.new_param('E_tilde_3', E_tilde_arr[2]),
pic.new_param('E_tilde_4', E_tilde_arr[3])]
E_arr = [pic.new_param('E_1', E_arr[0]), pic.new_param('E_2', E_arr[1])]
e5 = pic.new_param('e5', e5)
return E, c_tilde, E_tilde_arr, E_arr, e5
def lin_fbcon(A, B, solv):
## A, B are knwon matrices of the LTI system
#solv: choose the solver for example mosek, sdpa, cvxopt
# The solvers need to be installed separatelly
# http://picos.zib.de/intro.html#solvers
#size of matrices A and B
[n, n] = np.shape(A)
[n, m] = np.shape(B)
#starting the optimization problem
F = pic.Problem()
#Add parameters and variables
A = pic.new_param('A', A)
B = pic.new_param('B', B)
P = F.add_variable('P', (n, n), 'symmetric')
Q = F.add_variable('Q', (m, n))
F.add_constraint(P * A.T - Q.T * B.T + A * P - B * Q << 0)
F.add_constraint(P >> 0)
#optimzation objective
#by default the objetive is to maximize the trace of P
#comment the next line if the objetive is just to find any solution
F.set_objective('max', 'I' | P)
print(F)
#solving the LMI, with selected solver
F.solve(solver=solv, verbose=0)
P = np.matrix(P.value)
Q = np.matrix(Q.value)
print('optimal matrix P:')
print(P)
print('matrix Q:')
print(Q)
print("\n the Eigenvalues of P are:")
print(LA.eigvals(P))
print("\nSolution test")
#print(LA.eigvals(A.T*P+P*A))
K = Q * P.I
print('The gain matrix K is:')
print(K)
return K
def sdp(P, k):
"""Solve the SDP relaxation.
Parameters
----------
P : np.array
m*N matrix of N m-dimensional points stacked columnwise
k : int
Number of clusters
Returns
-------
The SDP minimizer S_D
"""
N = P.shape[1]
# Compute pairwise distances
D = scipy.spatial.distance.pdist(P.T)
D = scipy.spatial.distance.squareform(D)
# Create the semi-definite program
sdp = pic.Problem()
Dparam = pic.new_param("D", D)
X = sdp.add_variable("X", (N, N), vtype="symmetric")
sdp.add_constraint(pic.trace(X) == k)
sdp.add_constraint(X * "|1|({},1)".format(N) == 1)
sdp.add_constraint(X > 0)
sdp.add_constraint(X >> 0)
sdp.minimize(Dparam | X)
# Extract the SDP solution
X_D = np.array(X.value)
return X_D
def lin_lyap(A):
# matrix A in nxn
n = np.shape(A)
print n
F = pic.Problem()
A = pic.new_param("A", A)
P = F.add_variable('P', n, 'symmetric')
#objetive maximize the trace of P
# if the objective is just to find a solution, then comment the next line
F.set_objective('max', 'I' | P) #('I' | Z.real) works as well
F.add_constraint(A.H * P + P * A << 0)
F.add_constraint(P >> 0)
print F
F.solve(solver='mosek', verbose=0)
#print 'fidelity: F(P,Q) = {0:.4f}'.format(F.obj_value())
print 'optimal matrix P:'
P = np.array(P.value)
A = np.array(A.value)
print P
print "\n the Eigenvalues of P are:"
print LA.eigvals(P)
print "\nSolution test"
print LA.eigvals(np.transpose(A) * P + P * A)
return P
def f(rho1, sig2, gam1, gam2, d2, cov=True):
# rho -> sigma under GP (set cov=False)/ GPC map? Output \approx 1 --> yes, output<1 --> no.
# dim(rho1) = dim(gam1)
# dim(sig2) = dim(gam2) = d2
id_d2 = pic.new_param('id_d2', np.eye(d2))
## def problem & variables ##
p = pic.Problem()
X1 = p.add_variable('X1', (3, 3), 'hermitian')
X2 = p.add_variable('X2', (d2, d2), 'hermitian')
X3 = p.add_variable('X3', (d2, d2), 'hermitian')
p.add_constraint((sig2 | X2) + (gam2 | X3) == 1)
if cov == True:
p.add_constraint(
pic.kron(id_d2, X1) - dephase2(pic.kron(X2, rho1)) -
pic.kron(X3, gam1) >> 0.)
else:
p.add_constraint(
pic.kron(id_d2, X1) - pic.kron(X2, rho1) -
pic.kron(X3, gam1) >> 0.)
p.add_constraint(X1 >> 0)
p.add_constraint(X2 >> 0)
p.add_constraint(X3 >> 0)
## objective fn & solve ##
p.set_objective('min', pic.trace(X1))
p.solve(verbose=0, solver='cvxopt')
return p.obj_value().real
def maxcut_ipm_solver(C):
"""
Solve the Max-Cut SDP problem with Interior Point Method
:param C: (2d array[float], NxN) - Weight Matrix representd the graph to be partitioned
:return: (2d array[float], NxN) - SDP solution,
(1d array[integer]) - Final objective value,
(float) - Final elapsed time
"""
N = C.shape[0]
# SDP Creation =====================================================================================================
max_cut = pic.Problem()
C = pic.new_param('C', C)
X = max_cut.add_variable('X', (N, N), 'symmetric')
max_cut.add_constraint(pic.tools.diag_vect(X) == 1)
max_cut.add_constraint(X >> 0)
max_cut.set_objective('max', C | (1 - X))
# Solve SDP ========================================================================================================
start_time = time.time()
max_cut.solve(verbose=0) # Solve SDP
elapsed_time = time.time() - start_time # Calculate execution time
return np.array(X.value), 0.5 * max_cut.obj_value(), elapsed_time
def solveCompleteGame(DefenderRF, AttackerRF, PureStrategyList, BoundList,
Prob):
rewardmax = -10000000
deltamax = []
for i in range(0, len(PureStrategyList)):
#print(BoundList[i])
if (np.array(BoundList[i].value) < np.array(rewardmax)):
continue
try:
prob = pic.Problem()
m = len(DefenderRF[0][0])
l = len(DefenderRF[0])
t = len(DefenderRF)
delta = prob.add_variable('delta', l, lower=0, upper=1)
rfa = pic.new_param('rfa', AttackerRF)
rfd = pic.new_param('rfd', DefenderRF)
probs = pic.new_param('prob', Prob)
sigma = pic.new_param('sigma', PureStrategyList[i])
purestrategylist = pic.new_param('purestrategylist',
PureStrategyList)
prob.add_constraint(
pic.sum([delta[j] for j in range(l)], 'j', '[l]') == 1)
attrew = pic.sum([
probs[p] * delta.T * rfa[p] * (sigma[p, :]).T for p in range(t)
], 'p', '[t]')
for k in range(0, len(PureStrategyList)):
prob.add_constraint(attrew > pic.sum([
probs[p] * delta.T * rfa[p] * (purestrategylist[k][p, :]).T
for p in range(t)
], 'p', '[t]'))
obj = 0
for j in range(0, t):
obj = obj + probs[j] * delta.T * rfd[j] * (sigma[j, :]).T
#obj = pic.sum([probs[p]*delta.T*rfd[p]*(sigma[p,:]).T for p in range(t)],'p','[t]')
prob.set_objective('max', obj)
#print(prob)
prob.solve(verbose=0)
print(obj)
if ((obj.value[0]) > rewardmax):
rewardmax = (obj.value[0])
deltamax = np.array(delta)
except:
print("boohoo")
return deltamax, rewardmax
def get_GW_cut(self, graph):
########################################################################
# RETURNS AVERAGE GEOMANNS WILLIAMSON CUT FOR A GIVEN GRAPH
########################################################################
G = graph
N = len(G.nodes())
# Allocate weights to the edges.
for (i, j) in G.edges():
G[i][j]['weight'] = 1.0
maxcut = pic.Problem()
# Add the symmetric matrix variable.
X = maxcut.add_variable('X', (N, N), 'symmetric')
# Retrieve the Laplacian of the graph.
LL = 1 / 4. * nx.laplacian_matrix(G).todense()
L = pic.new_param('L', LL)
# Constrain X to have ones on the diagonal.
maxcut.add_constraint(pic.tools.diag_vect(X) == 1)
# Constrain X to be positive semidefinite.
maxcut.add_constraint(X >> 0)
# Set the objective.
maxcut.set_objective('max', L | X)
# Solve the problem.
maxcut.solve(verbose=0, solver='cvxopt')
# Use a fixed RNG seed so the result is reproducable.
cvx.setseed(1)
# Perform a Cholesky factorization.
V = X.value
cvxopt.lapack.potrf(V)
for i in range(N):
for j in range(i + 1, N):
V[i, j] = 0
# Do up to 100 projections. Stop if we are within a factor 0.878 of the SDP
# optimal value.
count = 0
obj_sdp = maxcut.obj_value()
obj = 0
while (obj < 0.878 * obj_sdp):
r = cvx.normal(N, 1)
x = cvx.matrix(np.sign(V * r))
o = (x.T * L * x).value
if o > obj:
x_cut = x
obj = o
count += 1
x = x_cut
return obj, count
def solveRestrictedGame(DefenderRF, AttackerRF):
PureStrategyList = generatePureStrategy(AttackerRF)
Delete = []
Bound = [10000000] * len(PureStrategyList)
rewardmax = -10000000
deltamax = []
count = 0
for i in range(0, len(PureStrategyList)):
try:
prob = pic.Problem()
m = len(DefenderRF[0])
l = len(DefenderRF)
t = 1
delta = prob.add_variable('delta', l, lower=0, upper=1)
rfa = pic.new_param('rfa', AttackerRF)
rfd = pic.new_param('rfd', DefenderRF)
sigma = pic.new_param('sigma', PureStrategyList[i])
purestrategylist = pic.new_param('purestrategylist',
PureStrategyList)
prob.add_constraint(
pic.sum([delta[j] for j in range(l)], 'j', '[l]') == 1)
attrew = delta.T * rfa * (sigma)
#print(purestrategylist)
for k in range(0, len(PureStrategyList)):
prob.add_constraint(attrew > delta.T * rfa *
(purestrategylist[k].T))
obj = delta.T * rfd * (sigma)
prob.set_objective('max', obj)
prob.solve(verbose=0)
print(obj)
if (np.array(obj) > rewardmax):
rewardmax = np.array(obj)
deltamax = np.array(delta)
Bound[count] = np.array(obj)
count += 1
except:
Delete.append(PureStrategyList[i])
print("boohoo")
for i in range(0, len(Delete)):
PureStrategyList.remove(Delete[i])
return PureStrategyList, Bound[0:len(PureStrategyList)], deltamax
def get_CBT_norm(J, n, m, rev=False):
import cvxopt as cvx
import picos as pic
# Get completely bounded trace norm of Choi-matrix J representing quantum channel from number_of_qubits-dimensional space to m-dimensional space
J = cvx.matrix(J)
prob = pic.Problem(verbose=0)
X = prob.add_variable("X", (n * m, n * m), vtype='complex')
I = pic.new_param('I', np.eye(m))
rho0 = prob.add_variable("rho0", (n, n), vtype='hermitian')
rho1 = prob.add_variable("rho1", (n, n), vtype='hermitian')
prob.add_constraint(rho0 >> 0)
prob.add_constraint(rho1 >> 0)
prob.add_constraint(pic.trace(rho0) == 1)
prob.add_constraint(pic.trace(rho1) == 1)
if (rev == True):
# TODO FBM: tests which conention is good.
# TODO FBM: add reference to paper
# This is convention REVERSED with respect to the paper,
# and seems that this is a proper one????
C0 = pic.kron(rho0, I)
C1 = pic.kron(rho1, I)
else:
C0 = pic.kron(I, rho0)
C1 = pic.kron(I, rho1)
F = pic.trace((J.H) * X) + pic.trace(J * (X.H))
prob.add_constraint(((C0 & X) // (X.H & C1)) >> 0)
prob.set_objective('max', F)
prob.solve(verbose=0)
if prob.status.count("optimal") > 0:
# print('solution optimal')
1
elif (prob.status.count("optimal") == 0):
print('uknown_if_solution_optimal')
else:
print('solution not found')
cbt_norm = prob.obj_value() / 2
if (abs(np.imag(cbt_norm)) >= 0.00001):
raise ValueError
else:
cbt_norm = np.real(cbt_norm)
return cbt_norm
def f(rho1, sig2, beta=1, H1=[0, 1, 2], H2=[0, 1], cov=True, GP=True):
## rho -> sigma under CPTP/ GP/ GPC/ Cov map?
## output \approx 1 --> yes, output < 1 --> no.
## dim(rho1) = dim(H1) = d1
## dim(sig2) = dim(H2) = d2
## default: qutrit-qubit CPG, equally-spaced energy levels, inv.temp=1
d1 = len(H1)
d2 = len(H2)
id_d2 = pic.new_param('id_d2', np.eye(d2))
## def problem & variables ##
p = pic.Problem()
X1 = p.add_variable('X1', (d1, d1), 'hermitian')
X2 = p.add_variable('X2', (d2, d2), 'hermitian')
X3 = p.add_variable('X3', (d2, d2), 'hermitian')
## Gibbs-state:
def g(x):
return np.exp(-beta * x)
exp_array1 = np.array(list(map(g, H1)))
exp_array2 = np.array(list(map(g, H2)))
gam1 = pic.diag(np.true_divide(exp_array1, np.sum(exp_array1)))
gam2 = pic.diag(np.true_divide(exp_array2, np.sum(exp_array2)))
#g2_0 = gam2[0].value
### constraints ###
if GP == False:
p.add_constraint((sig2 | X2) == 1)
if cov == True:
p.add_constraint(
pic.kron(id_d2, X1) -
dephase(pic.kron(X2, rho1), H1, H2) >> 0.)
else:
p.add_constraint(pic.kron(id_d2, X1) - pic.kron(X2, rho1) >> 0.)
else:
p.add_constraint((sig2 | X2) + (gam2 | X3) == 1)
p.add_constraint(X3 >> 0)
if cov == True:
p.add_constraint(
pic.kron(id_d2, X1) - dephase(pic.kron(X2, rho1), H1, H2) -
pic.kron(X3, gam1) >> 0.)
else:
p.add_constraint(
pic.kron(id_d2, X1) - pic.kron(X2, rho1) -
pic.kron(X3, gam1) >> 0.)
p.add_constraint(X1 >> 0)
p.add_constraint(X2 >> 0)
### objective fn & solve ###
p.set_objective('min', pic.trace(X1))
p.solve(verbose=0, solver='cvxopt')
return p.obj_value().real
def ellipsoid_bounds(P):
dimension = len(P)
radius_dim = []
for d in range(dimension):
d_vec = []
for temp in range(0, d):
d_vec.append(0)
d_vec.append(1)
for temp in range(d, dimension - 1):
d_vec.append(0)
A = cvx.matrix(P)
c = cvx.matrix([1])
#create the problem, variables and params
prob = pic.Problem()
AA = cvx.sparse(A, tc='d') #each AA[i].T is a 3 x 5 observation matrix
AA = pic.new_param('A', AA)
cc = pic.new_param('c', c)
ss = pic.new_param('s', cvx.matrix(d_vec))
x = prob.add_variable('x', AA.size[1])
# mu = prob.add_variable('mu',1)
#define the constraints and objective function
prob.add_list_of_constraints(
[x.T * AA * x < cc], #constraints
)
prob.set_objective('max', ss | x)
#solve the problem and retrieve the optimal weights of the optimal design.
# print prob
prob.solve(verbose=0, solver='cvxopt')
x = x.value
radius_dim.append(x[d])
return radius_dim
def setUp(self):
# Set the dimensionality.
self.n = n = 4
# Define parameters.
ones = picos.new_param("ones", [1.0] * n)
I = picos.diag(ones)
# Primal problem.
self.P = P = picos.Problem()
self.x = x = P.add_variable("x", n)
P.set_objective("max", 0.5 * x.T * I * x - (1 | x) - 0.5)
P.add_constraint(0.5 * x.T * I * x + (0 | x) - 0.5 <= 0)
def solve_picos(self):
#http://www.orsj.or.jp/archive2/or63-12/or63_12_755.pdf
#とけてるのかどうかわからん
p = pic.Problem()
X = p.add_variable('X', (self.n, self.n), 'symmetric')
gL = nx.laplacian_matrix(self.G, weight='w', nodelist=self.G.nodes)
gL = gL.toarray().astype(np.double)
L = pic.new_param('L', 1 / 4 * gL)
p.add_constraint(pic.diag_vect(X) == 1)
p.add_constraint(X >> 0)
p.set_objective('max', L | X)
p.solve()
print('bound from the SDP relaxation: {0}'.format(p.obj_value()))
def calc_update(graph):
incidence = graph.incidence
print(incidence)
(n, l) = np.shape(incidence)
sdp = pic.Problem()
Xp = sdp.add_variable("X", (n, n), vtype = 'symmetric')
a = 6
degree = graph.degree()
big_set_flags = (np.sum(incidence == 1, axis = 0) >= a*degree)
coloring = np.asarray(np.random.rand(n))*0.4-0.2
vs = [incidence[:, i] for i in range(l)]
xs = [vs[i]*coloring for i in range(l)]
vvs = [pic.new_param('vv'+str(i), np.outer(vs[i], vs[i])) for i in range(l)]
iden = pic.new_param('I', np.identity(n))
xxs = [pic.new_param('xx'+str(i), np.outer(xs[i], xs[i])) for i in range(l)]
# print('vs =')
# print(vs)
# print('xs =')
# print(xs)
# print('vvs =')
# print([np.outer(vs[i], vs[i]) -2*np.identity(n) for i in range(l)])
# print('xxs =')
# print([np.outer(xs[i], xs[i]) -2*np.identity(n) for i in range(l)])
sdp.add_list_of_constraints([vvs[i] | Xp == 0 for i in range(l) if big_set_flags[i]])
sdp.add_list_of_constraints([(vvs[i] - 2*iden) | Xp < 0 for i in range(l) if not big_set_flags[i]])
sdp.add_list_of_constraints([(xxs[i] - 2*iden) | Xp < 0 for i in range(l) if not big_set_flags[i]])
sdp.add_list_of_constraints([Xp[i, i] < 1 for i in range(n)])
sdp.add_constraint(Xp >> 0)
sdp.set_objective('max', pic.trace(Xp))
sdp.solve()
print(Xp.value)
U = np.linalg.cholesky(Xp.value)
print(U)
return U, np.asarray(Xp.value)
def cut(G):
N = len(G.nodes())
maxcut = pic.Problem()
X = maxcut.add_variable('X', (N, N), 'symmetric')
# objective
L = pic.new_param('L', 1/4. * nx.laplacian_matrix(G).toarray())
maxcut.set_objective('max', L | X)
# constraints
maxcut.add_constraint(pic.tools.diag_vect(X) == 1)
maxcut.add_constraint(X >> 0)
maxcut.solve(verbose=0)
return random_projection(unified(X.value), L, maxcut.obj_value())
def extendibility(rho, dim_A, dim_B, k=2, verbose=0):
'''
Checks if the state ρ is k-extendible.
--------------------------------------
Given an input state ρ ∈ 𝓗_A ⊗ 𝓗_B. Try to find an extension σ_AB_1..B_k ∈ 𝓗_A ⊗ 𝓗_B^(⊗k), such that (σ_AB)_i=ρ
Not that the extensions are only the B-system.
:param ρ: The state we want to check
:param dim_A: Dimensions of system A
:param dim_B: Dimensions of system B
:param k: The extendibility order
'''
#Define variables, and create problem
rho = picos.new_param('ρ', rho)
problem = picos.Problem()
sigma_AB = problem.add_variable(
'σ_AB',
(dim_A * binom(dim_B + k - 1, k), dim_A * binom(dim_B + k - 1, k)),
'hermitian')
#Set objective to a feasibility problem. The second argument is ignored by picos, so set some random scalar function.
problem.set_objective('find', picos.trace(sigma_AB))
#Add constrains
problem.add_constraint(sigma_AB >> 0)
problem.add_constraint(picos.trace(sigma_AB) == 1)
problem.add_constraint(bose_trace(sigma_AB, dim_A, dim_B, k) == rho)
print("\nChecking for %d extendibility..." % (k))
#Solve the SDP either silently or verbose
if verbose:
try:
print(problem)
problem.solve(verbose=verbose, solver='mosek')
print(problem.status)
check_exstendibility(rho, sigma_AB, dim_A, dim_B,
k) #Run a solution check if the user wants
except UnicodeEncodeError:
print(
"!!!Can't print the output due to your terminal not supporting unicode encoding!!!\nThis can be solved by setting verbose=0, or running the function using ipython instead."
)
else:
problem.solve(verbose=verbose, solver='mosek')
print(problem.status)
return sigma_AB
def add_constraints(self, matrix, rhs_vector, equality_vector):
"""Adds to constraint to the problem using the matrix.
Arguments
---------
matrix: m x n constraint matrix, where n is the number of variables
and m is the number of constraints
rhs_vector: list of length m, the number of constraints,
equality_vector: list of m integers. The number rel[i] defines the
relation, rel[i] < 0, rel[i] == 0, rel[i] > 0
gives the sign of the (in)equality
sum(matrix[i][:]) <= rhs_vector[i], if equ_vector[i] < 0
sum(matrix[i][:]) == rhs_vector[i], if equ_vector[i] = 0
"""
num_equ, num_vars = matrix.size
if not (num_equ == len(rhs_vector) == len(equality_vector)) or \
num_equ == 0 or \
num_vars != self.variables.size[0]:
raise ValueError(
'Dimensions do not match or are zero. '
'A: %ix%i. b: %i. rel: %i' %
(num_equ, num_vars, len(rhs_vector), len(equality_vector)))
rhs_vector = pic.new_param('rhs_vec', rhs_vector)
equality_vector = np.array(equality_vector)
# get indices of ineqs and eqs
inequality_idx = np.where(equality_vector)[0]
equality_vector[inequality_idx] = 1
equality_idx = np.where(1 - equality_vector)[0]
# add lists of constraints
self.pic_problem.add_list_of_constraints([
matrix[int(idx), :] * self.variables == rhs_vector[int(idx)]
for idx in equality_idx
])
self.pic_problem.add_list_of_constraints([
matrix[int(idx), :] * self.variables < rhs_vector[int(idx)]
for idx in inequality_idx
])
self.matrix = matrix[:]
Ms[i,j] = M[i,j] / p
else:
Ms[i,j] = 0
return Ms
r = 4
k = 10
M = adv(r,k)
mu = r*k/3
print M
N1 = M.shape[0]
N2 = M.shape[1]
Ms = samp(M,11.0/N2)
print Ms
A = pic.new_param('A', Ms)
J = pic.new_param('J', np.ones(shape=(N1,N2)))
sdp = pic.Problem()
#M = sdp.add_variable('M',(N,N))
#W1 = sdp.add_variable('W1',(N,N),'symmetric')
#W2 = sdp.add_variable('W2',(N,N),'symmetric')
#sdp.add_constraint([[W1,M],[M.T,W2]]>>0)
U = sdp.add_variable('U',(N1+N2,N1+N2),'symmetric')
Mr = U[0:N1,N1:N1+N2]
W1 = U[0:N1,0:N1]
W2 = U[N1:N1+N2,N1:N1+N2]
sdp.add_constraint(U>>0)
sdp.add_constraint(Mr>0)
sdp.add_constraint(Mr<J)
sdp.set_objective('max', (A | Mr) - 0.5 * mu * (trace(W1)+trace(W2)))
print sdp
k = k - (r+1)
r = r + 1
maxval = 0
for t in range(T):
A = np.zeros(shape=(N,N))
I = np.eye(N)
for k in range(m):
i,j = unpack(k)
u = 2 * randint(0,1) - 1
A[i,j] = u
A[j,i] = u
print ''
print 'A:'
print A
A = pic.new_param('A', A)
#J = pic.new_param('J', np.ones(shape=(N,N)))
sdp = pic.Problem()
P = sdp.add_variable('P',(N,N),'symmetric')
sdp.add_constraint(P>>0)
sdp.add_constraint(P<<I)
sdp.set_objective('max', A | P)
print sdp
sdp.solve(verbose = 1, maxit=50)
val = sdp.obj_value()
print 'value: {0}'.format(val)
solution = P.value
np.set_printoptions(precision=3,threshold='nan',linewidth=1000,suppress=True)
print 'solution:'
print solution
for i,e in enumerate(G.edges()):
c[e]=((-2)**i)%17 #an arbitrary sequence of numbers
#-------------#
# min cut #
#-------------#
mincut=pic.Problem()
#source and sink nodes
s=16
t=10
#convert the capacities as a picos expression
cc=pic.new_param('c',c)
#cut variable
d={}
for e in G.edges():
d[e]=mincut.add_variable('d[{0}]'.format(e),1)
#potentials
p=mincut.add_variable('p',N)
#potential inequality
mincut.add_list_of_constraints(
[d[i,j] > p[i]-p[j]
for (i,j) in G.edges()], #list of constraints
['i','j'],'edges') #indices and set they belong to
print ''
N = A.shape[0]
if N != A.shape[1]:
raise Exception('matrix is not square')
for i in range(N):
for j in range(N):
if random() < p:
A[i,j] = A[i,j] / p
else:
A[i,j] = 0
print 'Ar:'
print A
print ''
I = np.eye(N)
A = pic.new_param('A', A)
J = pic.new_param('J', np.ones(shape=(N,N)))
sdp = pic.Problem()
#M = sdp.add_variable('M',(N,N))
#W1 = sdp.add_variable('W1',(N,N),'symmetric')
#W2 = sdp.add_variable('W2',(N,N),'symmetric')
#sdp.add_constraint([[W1,M],[M.T,W2]]>>0)
U = sdp.add_variable('U',(2*N,2*N),'symmetric')
M = U[0:N,N:2*N]
W1 = U[0:N,0:N]
W2 = U[N:2*N,N:2*N]
sdp.add_constraint(U>>0)
sdp.add_constraint(M>0)
sdp.add_constraint(M<J)
sdp.set_objective('max', (A | M) - mu * (trace(W1)+trace(W2)))
print sdp
[1 ,-5,-5]])
#size of the data
s = len(A)
m = A[0].size[0]
l = [ Ai.size[1] for Ai in A ]
r = K.size[1]
#creates a problem and the optimization variables
prob = pic.Problem()
mu = prob.add_variable('mu',s)
Z = [prob.add_variable('Z[' + str(i) + ']', (l[i],r))
for i in range(s)]
#convert the constants into params of the problem
A = pic.new_param('A',A)
K = pic.new_param('K',K)
#add the constraints
prob.add_constraint( pic.sum([ A[i]*Z[i] for i in range(s)], #summands
'i', #name of the index
'[s]' #set to which the index belongs
) == K
)
prob.add_list_of_constraints( [ abs(Z[i]) < mu[i] for i in range(s)], #constraints
'i', #index of the constraints
'[s]' #set to which the index belongs
)
#sets the objective
prob.set_objective('min', 1 | mu ) # scalar product of the vector of all ones with mu
M = 3
X = sdp.add_variable('X',(2*(M+N)+1,2*(M+N)+1),'symmetric')
sdp.add_constraint(X>>0)
sdp.add_constraint(X[0,0]<=1)
sdp.add_constraint(X>=0)
for i in range(N+M):
sdp.add_constraint(X[i+1,i+1]==X[i+1,0])
sdp.add_constraint(X[i+1,i+1]==X[i+1,i+N+M+1])
sdp.add_constraint(X[i+N+M+1,i+N+M+1]==X[i+N+M+1,0])
for i in range(M):
sdp.add_constraint(X[i+N+M+1,i+N+M+1]==1)
for j in range(M,N+M):
sdp.add_constraint(X[i+1,j+N+M+1]==0)
diagC = np.array([0] + [1] * M + [0]*(2*N+M))
C = pic.new_param('C',np.diag(diagC))
diagD = np.array([0] + [0] * M + [1] * N + [0] * (N+M))
D = pic.new_param('D',np.diag(diagD))
sdp.add_constraint(D|X >= 2);
sdp.set_objective('max', C | X)
print sdp
sdp.solve(verbose = 1, maxit=50)
print 'value: {0}'.format(sdp.obj_value())
solution = X.value
np.set_printoptions(precision=3,threshold='nan',linewidth=1000,suppress=True)
print 'solution:'
print np.array(solution)
[0,3,2,0,0],
[1,0,0,2,0]])
]
c = cvx.matrix([1,2,3,4,5])
#create the problems
#--------------------------------------#
# D-optimal design #
#--------------------------------------#
prob_D = pic.Problem()
AA=[cvx.sparse(a,tc='d') for a in A]
s=len(AA)
m=AA[0].size[0]
AA=pic.new_param('A',AA)
mm=pic.new_param('m',m)
L=prob_D.add_variable('L',(m,m))
V=[prob_D.add_variable('V['+str(i)+']',AA[i].T.size) for i in range(s)]
w=prob_D.add_variable('w',s)
u={}
for k in ['01','23','4.','0123','4...','01234']:
u[k] = prob_D.add_variable('u['+k+']',1)
prob_D.add_constraint(
pic.sum([AA[i]*V[i]
for i in range(s)],'i','[s]')
== L)
#L lower inferior
prob_D.add_list_of_constraints( [L[i,j] == 0
for i in range(m)
for j in range(i+1,m)],['i','j'],'upper triangle')
import cvxopt.lapack
import numpy as np
#make G undirected
G=nx.Graph(G)
#allocate weights to the edges
for (i,j) in G.edges():
G[i][j]['weight']=c[i,j]+c[j,i]
maxcut = pic.Problem()
X=maxcut.add_variable('X',(N,N),'symmetric')
#Laplacian of the graph
L=pic.new_param('L',1/4.*nx.laplacian(G))
#ones on the diagonal
maxcut.add_constraint(pic.tools.diag_vect(X)==1)
#X positive semidefinite
maxcut.add_constraint(X>>0)
#objective
maxcut.set_objective('max',L|X)
#print maxcut
maxcut.solve(verbose = 0)
#Cholesky factorization
V=X.value
print minus
X = sdp.add_variable('X',(2*N+1,2*N+1),'symmetric')
sdp.add_constraint(X>>0)
sdp.add_constraint(X[2*N,2*N]<=1)
sdp.add_constraint(X>=0)
for i in range(N):
sdp.add_constraint(X[i,i]==X[i,2*N])
sdp.add_constraint(X[i,i]==X[i,i+N])
sdp.add_constraint(X[i+N,i+N]==X[i+N,2*N])
for (i,j) in plus:
sdp.add_constraint(X[i,i]==X[i,j+N])
for (i,j) in minus:
sdp.add_constraint(X[i,j+N]==0)
diag = np.array([1]*N + [0]*(N+1))
C = pic.new_param('C',np.diag(diag))
print X
print C
sdp.set_objective('max', C | X)
print sdp
sdp.solve(verbose = 1, maxit=50)
print 'value: {0}'.format(sdp.obj_value())
solution = X.value
np.set_printoptions(precision=2,threshold='nan',linewidth=1000,suppress=True)
print 'solution:'
print np.array(solution)
[1 ,-5,-5]])
#size of the data
s = len(A)
m = A[0].size[0]
l = [ Ai.size[1] for Ai in A ]
r = K.size[1]
#creates a problem and the optimization variables
prob = pic.Problem()
mu = prob.add_variable('mu',s)
Z = [prob.add_variable('Z[' + str(i) + ']', (l[i],r))
for i in range(s)]
#convert the constants into params of the problem
A = pic.new_param('A',A)
K = pic.new_param('K',K)
#add the constraints
prob.add_constraint( pic.sum([ A[i]*Z[i] for i in range(s)], #summands
'i', #name of the index
'[s]' #set to which the index belongs
) == K
)
prob.add_list_of_constraints( [ abs(Z[i]) < mu[i] for i in range(s)], #constraints
'i', #index of the constraints
'[s]' #set to which the index belongs
)
#sets the objective
prob.set_objective('min', 1 | mu ) # scalar product of the vector of all ones with mu