def test_init(self):
e = PyEnvironment([PyVar('x0'), PyVar('y')], [PyVar('z')])
x = PyLinexpr1(e)
x0 = PyLinexpr1(e, 0)
self.assertEqual(str(PyTexpr1(x)), '0.0')
self.assertEqual(str(PyTexpr1(x0)), '0.0 + 0.0 · x0 + 0.0 · y + 0.0 · z')
x.set_coeff(PyVar('x0'), PyDoubleScalarCoeff(-1))
x.set_coeff(PyVar('z'), PyDoubleScalarCoeff(-9))
x.set_cst(PyDoubleScalarCoeff(8))
self.assertEqual(str(PyTexpr1(x)), '8.0 - 1.0 · x0 - 9.0 · z')
def test_bound_texpr(self):
e = PyEnvironment([PyVar('x0'), PyVar('y')], [PyVar('z')])
man: PyManager = PyBoxMPQManager()
variables = [PyVar('x0'), PyVar('y')]
intervals = [PyMPQInterval(-3, 2), PyMPQInterval(-2, 2, 1, 1)]
b = PyBox(man, e, variables=variables, intervals=intervals)
x0 = PyTexpr1.var(e, PyVar('x0'))
x1 = PyTexpr1.var(e, PyVar('y'))
add = PyTexpr1.binop(TexprOp.AP_TEXPR_ADD, x0, x1,
TexprRtype.AP_RTYPE_REAL, TexprRdir.AP_RDIR_RND)
self.assertEqual(str(b.bound_texpr(add)), '[-5,4]')
def dict_to_texpr(todict, env):
texpr = PyTexpr1.cst(env, PyMPQScalarCoeff(PyMPQScalar(todict['_'])))
for var, val in reversed(list(todict.items())):
if var != '_':
coeff = PyTexpr1.cst(env, PyMPQScalarCoeff(PyMPQScalar(val)))
dim = PyTexpr1.var(env, PyVar(var))
term = PyTexpr1.binop(TexprOp.AP_TEXPR_MUL, coeff, dim,
TexprRtype.AP_RTYPE_REAL,
TexprRdir.AP_RDIR_RND)
texpr = PyTexpr1.binop(TexprOp.AP_TEXPR_ADD, term, texpr,
TexprRtype.AP_RTYPE_REAL,
TexprRdir.AP_RDIR_RND)
return texpr
def test_substitute(self):
e = PyEnvironment([PyVar('x0'), PyVar('y')], [PyVar('z')])
x0 = PyLinexpr1(e)
x0.set_coeff(PyVar('x0'), PyMPQScalarCoeff(1))
x0.set_cst(PyMPQScalarCoeff(3))
t0 = PyTexpr1(x0)
c0 = PyTcons1.make(t0, ConsTyp.AP_CONS_SUPEQ)
self.assertEqual(str(c0), '3 + 1 · x0 >= 0')
x1 = PyLinexpr1(e)
x1.set_coeff(PyVar('x0'), PyMPQScalarCoeff(1))
x1.set_cst(PyMPQScalarCoeff(-1))
t1 = PyTexpr1(x1)
c1 = PyTcons1.make(t1, ConsTyp.AP_CONS_SUPEQ)
self.assertEqual(str(c1), '-1 + 1 · x0 >= 0')
self.assertEqual(str(c0.substitute(PyVar('x0'), t1)),
'3 + 1 · (-1 + 1 · x0) >= 0')
def visit_LengthIdentifier(self,
expr: 'LengthIdentifier',
environment=None,
usub=False):
assert not usub
return PyTexpr1.cst(environment,
PyMPQIntervalCoeff(PyMPQInterval.top()))
def affine(self, left: List[PyVar],
right: List[PyTexpr1]) -> 'Symbolic1State':
array = list()
assignments = dict()
for lhs, expr in zip(left, right):
rhs = expr
for sym, val in self.symbols.values():
rhs = rhs.substitute(sym, val)
assignments[str(lhs)] = (lhs, rhs)
var = PyTexpr1.var(self.environment, lhs)
binop = PyTexpr1.binop(TexprOp.AP_TEXPR_SUB, var, rhs, rtype, rdir)
cond = PyTcons1.make(binop, ConsTyp.AP_CONS_EQ)
array.append(cond)
self.symbols = assignments
self.state = self.state.meet(PyTcons1Array(array))
return self
def test_make(self):
e = PyEnvironment([PyVar('x0'), PyVar('y')], [PyVar('z')])
x = PyLinexpr1(e)
x.set_coeff(PyVar('x0'), PyDoubleScalarCoeff(3))
x.set_coeff(PyVar('z'), PyDoubleScalarCoeff(-9))
x.set_cst(PyDoubleScalarCoeff(8))
c = PyTcons1.make(PyTexpr1(x), ConsTyp.AP_CONS_SUPEQ)
self.assertEqual(str(c), '8.0 + 3.0 · x0 - 9.0 · z >= 0')
def relu(self,
stmt: PyVar,
active: bool = False,
inactive: bool = False) -> 'BoxState':
self.flag = None
if active: # we only do the active case (h >= 0)
expr1 = PyTexpr1.var(self.environment, stmt)
cond = PyTcons1.make(expr1, ConsTyp.AP_CONS_SUPEQ)
abstract1 = self.domain(self.state.manager,
self.environment,
array=PyTcons1Array([cond]))
self.state = self.state.meet(abstract1)
self.flag = 1
return self
if inactive: # we only do the inactive case (h < 0)
expr1 = PyTexpr1.var(self.environment, stmt)
neg = PyTexpr1.unop(TexprOp.AP_TEXPR_NEG, expr1, rtype, rdir)
cond = PyTcons1.make(neg, ConsTyp.AP_CONS_SUP)
abstract1 = self.domain(self.state.manager,
self.environment,
array=PyTcons1Array([cond]))
zero = PyTexpr1.cst(self.environment, PyMPQScalarCoeff(0.0))
self.state = self.state.meet(abstract1).assign(stmt, zero)
self.flag = -1
return self
# we do both cases
_active, _inactive = deepcopy(self.state), deepcopy(self.state)
expr1 = PyTexpr1.var(self.environment, stmt)
cond1 = PyTcons1.make(expr1, ConsTyp.AP_CONS_SUPEQ)
abstract1 = self.domain(self.state.manager,
self.environment,
array=PyTcons1Array([cond1]))
_active = _active.meet(abstract1)
expr2 = PyTexpr1.var(self.environment, stmt)
neg = PyTexpr1.unop(TexprOp.AP_TEXPR_NEG, expr2, rtype, rdir)
cond2 = PyTcons1.make(neg, ConsTyp.AP_CONS_SUP)
abstract2 = self.domain(self.state.manager,
self.environment,
array=PyTcons1Array([cond2]))
zero = PyTexpr1.cst(self.environment, PyMPQScalarCoeff(0.0))
_inactive = _inactive.meet(abstract2).assign(stmt, zero)
if _active.is_bottom():
self.flag = -1
elif _inactive.is_bottom():
self.flag = 1
join = _active.join(_inactive)
self.state = join
return self
def test_substitute(self):
e = PyEnvironment([PyVar('x0'), PyVar('y')], [PyVar('z')])
x0 = PyLinexpr1(e)
x0.set_coeff(PyVar('x0'), PyMPQScalarCoeff(1))
x0.set_cst(PyMPQScalarCoeff(3))
t0 = PyTexpr1(x0)
self.assertEqual(str(t0), '3 + 1 · x0')
x1 = PyLinexpr1(e)
x1.set_coeff(PyVar('x0'), PyMPQScalarCoeff(1))
x1.set_cst(PyMPQScalarCoeff(-1))
t1 = PyTexpr1(x1)
self.assertEqual(str(t1), '-1 + 1 · x0')
self.assertEqual(str(t0.substitute(PyVar('x0'), t1)), '3 + 1 · (-1 + 1 · x0)')
x2 = PyLinexpr1(e)
x2.set_coeff(PyVar('x0'), PyMPQScalarCoeff(1))
x2.set_cst(PyMPQScalarCoeff(2))
t2 = PyTexpr1(x2)
self.assertEqual(str(t2), '2 + 1 · x0')
def visit_LiteralEvaluation(self,
stmt: 'LiteralEvaluation',
environment=None,
usub=False) -> PyTexpr1:
if usub:
cst = PyMPQScalarCoeff(-float(stmt.literal.val))
else:
cst = PyMPQScalarCoeff(float(stmt.literal.val))
return PyTexpr1.cst(environment, cst)
def test_deepcopy(self):
e = PyEnvironment([PyVar('x0'), PyVar('y')], [PyVar('z')])
x = PyLinexpr1(e)
x.set_coeff(PyVar('x0'), PyDoubleScalarCoeff(3))
x.set_coeff(PyVar('z'), PyDoubleScalarCoeff(-9))
x.set_cst(PyDoubleScalarCoeff(8))
c0 = PyTcons1.make(PyTexpr1(x), ConsTyp.AP_CONS_SUPEQ)
c1 = deepcopy(c0)
c2 = c0
self.assertNotEqual(id(c0), id(c1))
self.assertEqual(id(c0), id(c2))
def visit_Call(self, stmt: 'Call', environment=None, usub=False):
assert not usub
if stmt.name == 'usub':
return self.visit(stmt.arguments[0],
environment=environment,
usub=True)
elif stmt.name == 'add':
left = self.visit(stmt.arguments[0],
environment=environment,
usub=usub)
right = self.visit(stmt.arguments[1],
environment=environment,
usub=usub)
return PyTexpr1.binop(TexprOp.AP_TEXPR_ADD, left, right,
TexprRtype.AP_RTYPE_REAL,
TexprRdir.AP_RDIR_RND)
elif stmt.name == 'sub':
left = self.visit(stmt.arguments[0],
environment=environment,
usub=usub)
right = self.visit(stmt.arguments[1],
environment=environment,
usub=usub)
return PyTexpr1.binop(TexprOp.AP_TEXPR_SUB, left, right,
TexprRtype.AP_RTYPE_REAL,
TexprRdir.AP_RDIR_RND)
elif stmt.name == 'mult':
left = self.visit(stmt.arguments[0],
environment=environment,
usub=usub)
right = self.visit(stmt.arguments[1],
environment=environment,
usub=usub)
return PyTexpr1.binop(TexprOp.AP_TEXPR_MUL, left, right,
TexprRtype.AP_RTYPE_REAL,
TexprRdir.AP_RDIR_RND)
elif stmt.name == 'ReLU':
return PyVar(
stmt.arguments[0].variable.name
) # self.visit(stmt.arguments[0], environment=environment, usub=usub)
raise ValueError(f"Conversion of {stmt} to APRON is unsupported!")
def visit_BinaryArithmeticOperation(self, expr, environment=None, usub=False) -> PyTexpr1:
assert not usub
expr1 = self.visit(expr.left, environment)
expr2 = self.visit(expr.right, environment)
op2op = {
BinaryArithmeticOperation.Operator.Add: TexprOp.AP_TEXPR_ADD,
BinaryArithmeticOperation.Operator.Sub: TexprOp.AP_TEXPR_SUB,
BinaryArithmeticOperation.Operator.Mult: TexprOp.AP_TEXPR_MUL,
BinaryArithmeticOperation.Operator.Div: TexprOp.AP_TEXPR_DIV
}
op = op2op[expr.operator]
return PyTexpr1.binop(op, expr1, expr2, TexprRtype.AP_RTYPE_REAL, TexprRdir.AP_RDIR_RND)
def visit_Input(self, expr, environment=None, usub=False) -> PyTexpr1:
assert not usub
return PyTexpr1.cst(environment, PyMPQIntervalCoeff(PyMPQInterval.top()))
def visit_VariableIdentifier(self, expr, environment=None, usub=False) -> PyTexpr1:
assert not usub
return PyTexpr1.var(environment, PyVar(expr.name))
def visit_Literal(self, expr: 'Literal', environment=None, usub=False) -> PyTexpr1:
if usub:
cst = PyMPQScalarCoeff(-float(expr.val))
else:
cst = PyMPQScalarCoeff(float(expr.val))
return PyTexpr1.cst(environment, cst)
def visit_Slicing(self, expr: 'Slicing', environment=None, usub=False):
assert not usub
return PyTexpr1.var(environment, PyVar(expr.target.name))
def visit_Subscription(self,
expr: 'Subscription',
environment=None,
usub=False):
assert not usub
return PyTexpr1.var(environment, PyVar(expr.target.name))
def unsat(cls, environment: PyEnvironment):
x = PyTexpr1.cst(environment, PyDoubleScalarCoeff(-1.0))
return cls.make(x, ConsTyp.AP_CONS_SUPEQ)
def visit_VariableAccess(self,
stmt: 'VariableAccess',
environment=None,
usub=False) -> PyTexpr1:
assert not usub
return PyTexpr1.var(environment, PyVar(stmt.variable.name))
