def isValid(self):
"""Check if this building block class induces valid inequalities."""
# qRange = np.arange(1, self.q)
# for loVals in itertools.product((0,1), repeat=self.q-1):
# maskModQ = np.dot(qRange, loVals) % self.q
# if maskModQ != 0:
# rhs = -np.dot(loVals, self.vals[self.lo, 1:])
# lhs = self.vals[0, self.q - maskModQ]
# if lhs > rhs:
# #print(mask, maskModQ, lhs, rhs)
# return False
# return True
import gurobimh as g
model = g.Model()
model.setParam('OutputFlag', 0)
zVars = [
model.addVar(vtype=g.GRB.INTEGER,
ub=self.vals[0, self.sigma],
name='y{}'.format(i)) for i in range(1, self.p)
]
xVars = [
model.addVar(vtype=g.GRB.BINARY, name='x{}'.format(i))
for i in range(1, self.p)
]
modQVar = model.addVar(vtype=g.GRB.INTEGER,
lb=-g.GRB.INFINITY,
ub=g.GRB.INFINITY,
name='z')
model.update()
model.addConstr(
g.LinExpr(self.vals[self.sigma, 1:], zVars) +
g.LinExpr(self.vals[0, 1:], xVars) >= 1)
model.addConstr(g.quicksum(xVars) == 1)
qRange = list(range(1, self.p))
model.addConstr(
g.LinExpr(qRange, zVars) + g.LinExpr(qRange, xVars) +
self.p * modQVar == 0)
model.optimize()
if model.Status == g.GRB.INFEASIBLE:
return True
else:
# print('invalid y/x:')
# print([x.X for x in xVars])
# print([y.X for y in zVars])
return False
def __init__(self, code, gurobiParams=None, gurobiVersion=None, ml=False, name=None):
if name is None:
name = 'Explicit{}Decoder'.format('ML' if ml else 'LP')
self.ml = ml
GurobiDecoder.__init__(self, code, name, gurobiParams, gurobiVersion, integer=ml)
self.timer = utils.Timer()
assert code.q == 2, 'only binary codes are supported'
from lpdec.polytopes import feldmanInequalities
A, b = feldmanInequalities(code.parityCheckMatrix)
for i in range(len(b)):
self.model.addConstr(gu.LinExpr(A[i], self.xlist), gu.GRB.LESS_EQUAL, b[i])
self.model.update()
def test_add_empty_expression(self):
num_vars = 100
m = grb.Model()
m.setParam('OutputFlag', 0)
x = [m.addVar() for i in range(num_vars)]
m.update()
expr = grb.quicksum(x)
self.assertEquals((expr + grb.LinExpr()).size(), num_vars)
self.assertEquals((expr - grb.LinExpr()).size(), num_vars)
expr += grb.LinExpr()
self.assertEquals(expr.size(), num_vars)
expr -= grb.LinExpr()
self.assertEquals(expr.size(), num_vars)
expr += grb.LinExpr(100)
self.assertEquals(expr.getConstant(), 100)
expr -= grb.LinExpr(10)
self.assertEquals(expr.getConstant(), 90)
def isDominatedBy(self, others):
"""Strong dominance check using linear programming"""
if len(others) == 0:
return False
import gurobimh as g
model = g.Model()
model.setParam('OutputFlag', 0)
vars = [
model.addVar(lb=0) for _ in range(3 * len(others) * (self.p - 1))
]
model.update()
Ahi = np.empty((self.p - 1, len(others) * (self.p - 1)))
Alo = np.empty((self.p - 1, len(others) * (self.p - 1)))
for i, cls in enumerate(others):
for automorphism in range(1, self.p):
for j in range(1, self.p):
Ahi[j - 1, i * (self.p - 1) + automorphism -
1] = cls.vals[0, automorphism * j % self.p]
Alo[j - 1, i * (self.p - 1) + automorphism -
1] = cls.vals[cls.sigma, automorphism * j % self.p]
# b = np.hstack((self.vals[0, 1:], self.vals[self.lo, 1:], self.vals[self.lo, 1:]))
# A = np.array(np.bmat([[Ahi, Alo, Alo], [Alo, Ahi, Alo], [Alo, Alo, Ahi]]))
# test simpler
b = np.hstack((self.vals[0, 1:], self.vals[self.sigma, 1:]))
A = np.vstack((Ahi, Alo))
# print('A=',A)
# print('b=',b)
for i, row in enumerate(A):
model.addConstr(g.LinExpr(row, vars) >= b[i])
model.update()
model.optimize()
# if model.status != g.GRB.INFEASIBLE:
# print('others', [o.m for o in others])
# print('solution', [v.X for v in vars])
return model.Status != g.GRB.INFEASIBLE