def update_blackboard(self, B): """ Saturates a Blackboard B with additive inferences. """ timer.start(timer.PADD) messages.announce_module('polyhedron additive module') # learn_additive_sign_info(blackboard) comparisons = get_additive_information(B) h_matrix = lrs_util.create_h_format_matrix(comparisons, B.num_terms) messages.announce('Halfplane matrix:', messages.DEBUG) messages.announce(h_matrix, messages.DEBUG) v_matrix, v_lin_set = lrs_util.get_vertices(h_matrix) messages.announce('Vertex matrix:', messages.DEBUG) #messages.announce(str(v_matrix), messages.DEBUG) for l in v_matrix: messages.announce(str(l), messages.DEBUG) messages.announce('Linear set:', messages.DEBUG) messages.announce(str(v_lin_set), messages.DEBUG) new_comparisons = get_2d_comparisons(v_matrix, v_lin_set) for c in new_comparisons: B.assert_comparison(c) timer.stop(timer.PADD)
def update_blackboard(self, B): """ Instantiates all stored axioms with respect to B and asserts new clauses. """ timer.start(timer.FUN) messages.announce_module('axiom module') n = B.num_terms + len(B.equalities.keys()) + len(B.zero_equalities) #if n == self.num_eqs: # messages.announce("No new information for the axiom module to use.", messages.DEBUG) # timer.stop(timer.FUN) # return self.num_eqs = n for a in self.axioms: messages.announce("Instantiating axiom: {}".format(a), messages.DEBUG) if a.unifiable: clauses = instantiate(a, self.used_envs, B) for c in clauses: B.assert_clause(*c) else: clauses = instantiate_triggerless(a, self.used_envs, B) for c in clauses: B.assert_clause(*c) timer.stop(timer.FUN)
def update_blackboard(self, B): """ Adds axioms for sin, cos, tan, floor """ timer.start(timer.BUILTIN) ts = [B.term_defs[i] for i in range(B.num_terms)] funcs = [t.func.name for t in ts if isinstance(t, terms.FuncTerm)] if (not self.added['sin'] and 'sin' in funcs): self.am.add_axioms(sin_axioms) self.added['sin'] = True if (not self.added['cos'] and 'cos' in funcs): self.am.add_axioms(cos_axioms) self.added['cos'] = True if (not self.added['tan'] and 'tan' in funcs): self.am.add_axioms(tan_axioms) self.added['tan'] = True if (not self.added['floor'] and 'floor' in funcs): self.am.add_axioms(floor_axioms) self.added['floor'] = True if (not self.added['abs'] and 'abs' in funcs): self.am.add_axioms(abs_axioms) self.added['abs'] = True timer.stop(timer.BUILTIN)
def update_blackboard(self, B): """ Learns equalities and inequalities from additive information in B, and asserts them to B. """ timer.start(timer.FMADD) messages.announce_module('Fourier-Motzkin additive module') eqs, comps = get_additive_information(B) for i in range(B.num_terms): # at this point, eqs and comps have all comparisons with indices >= i i_eqs, i_comps = eqs, comps # determine all comparisons with IVar(i) and IVar(j) with j >= i for j in range(i + 1, B.num_terms): # at this point, i_eqs and i_comps have all comparisons with i and indices >= j ij_eqs, ij_comps = i_eqs, i_comps # determine all comparisons between IVar(i) and IVar(j) for k in range(j + 1, B.num_terms): ij_eqs, ij_comps = elim(ij_eqs, ij_comps, k) assert_comparisons_to_blackboard(ij_eqs, ij_comps, B) # done with IVar(j) i_eqs, i_comps = elim(i_eqs, i_comps, j) # add this point, i_eqs and i_comps contain only comparisons with IVar(i) alone assert_comparisons_to_blackboard(i_eqs, i_comps, B) # done with IVar(i) eqs, comps = elim(eqs, comps, i) timer.stop(timer.FMADD)
def update_blackboard(self, B): """ Adds axioms corresponding to each nth root function present. """ messages.announce_module('nth root value module') timer.start(timer.ROOT) #nth_roots = [] def is_nth_root_term(i): """ Returns True if t_i is of the form abs(t_j). """ return (isinstance(B.term_defs[i], terms.FuncTerm) and isinstance(B.term_defs[i].func, terms.NthRoot)) def root_degree(i): """ If t_i is of the form NthRoot(n, t_j), returns n. """ return B.term_defs[i].func.n nth_roots = set([root_degree(i) for i in range(B.num_terms) if is_nth_root_term(i)]) x = terms.Var('x') for n in nth_roots: if n % 2 == 0: self.am.add_axiom(formulas.Forall([x], formulas.Implies(x >= 0, terms.root(n, x) ** n == x))) self.am.add_axiom(formulas.Forall([x], formulas.Implies(x >= 0, terms.root(n, x) >= 0))) else: self.am.add_axiom(formulas.Forall([x], terms.root(n, x) ** n == x)) timer.stop(timer.ROOT)
def update_blackboard(self, B): """ Learns sign information and equalities and inequalities from multiplicative information in B, and asserts them to B. """ timer.start(timer.FMMUL) messages.announce_module('Fourier-Motzkin multiplicative module') mul_util.derive_info_from_definitions(B) mul_util.preprocess_cancellations(B) eqs, comps = get_multiplicative_information(B) # t0 = 1; ignore for i in range(1, B.num_terms): # at this point, eqs and comps have all comparisons with indices >= i i_eqs, i_comps = eqs, comps # determine all comparisons with IVar(i) and IVar(j) with j >= i for j in range(i + 1, B.num_terms): # at this point, i_eqs and i_comps have all comparisons with i and indices >= j ij_eqs, ij_comps = i_eqs, i_comps # determine all comparisons between IVar(i) and IVar(j) for k in range(j + 1, B.num_terms): ij_eqs, ij_comps = elim(ij_eqs, ij_comps, k) #print 'comps:', ij_comps assert_comparisons_to_blackboard(ij_eqs, ij_comps, B) # done with IVar(j) i_eqs, i_comps = elim(i_eqs, i_comps, j) # add this point, i_eqs and i_comps contain only comparisons with IVar(i) alone assert_comparisons_to_blackboard(i_eqs, i_comps, B) # done with IVar(i) eqs, comps = elim(eqs, comps, i) timer.stop(timer.FMMUL)
def update_blackboard(self, B): """ Saturates a Blackboard B with multiplicative inferences. """ timer.start(timer.PMUL) messages.announce_module('polyhedron multiplicative module') mul_util.derive_info_from_definitions(B) mul_util.preprocess_cancellations(B) m_comparisons = mul_util.get_multiplicative_information(B) # Each ti in m_comparisons really represents |t_i|. p = add_of_mul_comps(m_comparisons, B.num_terms) a_comparisons, prime_of_index, num_terms = p a_comparisons = [terms.comp_eval[c[1]](c[0], 0) for c in a_comparisons] h_matrix = lrs_util.create_h_format_matrix(a_comparisons, num_terms) messages.announce('Halfplane matrix:', messages.DEBUG) messages.announce(h_matrix, messages.DEBUG) v_matrix, v_lin_set = lrs_util.get_vertices(h_matrix) messages.announce('Vertex matrix:', messages.DEBUG) for l in v_matrix: messages.announce(str(l), messages.DEBUG) messages.announce('Linear set:', messages.DEBUG) messages.announce(str(v_lin_set), messages.DEBUG) new_comparisons = get_mul_comparisons(v_matrix, v_lin_set, B.num_terms, prime_of_index) for m1, m2, coeff, comp in new_comparisons: c = mul_util.process_mul_comp(m1, m2, coeff, comp, B) if c is not None: B.assert_comparison(c) timer.stop(timer.PMUL)
def update_blackboard(self, B): """ Learns sign information and equalities and inequalities from multiplicative information in B, and asserts them to B. """ timer.start(timer.FMMUL) messages.announce_module('Fourier-Motzkin multiplicative module') mul_util.derive_info_from_definitions(B) mul_util.preprocess_cancellations(B) eqs, comps = get_multiplicative_information(B) # t0 = 1; ignore for i in range(1, B.num_terms): # at this point, eqs and comps have all comparisons with indices >= i i_eqs, i_comps = eqs, comps # determine all comparisons with IVar(i) and IVar(j) with j >= i for j in range(i + 1, B.num_terms): # at this point, i_eqs and i_comps have all comparisons with i and indices >= j ij_eqs, ij_comps = i_eqs, i_comps # determine all comparisons between IVar(i) and IVar(j) for k in range(j + 1, B.num_terms): ij_eqs, ij_comps = elim(ij_eqs, ij_comps, k) #print 'comps:', ij_comps assert_comparisons_to_blackboard(ij_eqs, ij_comps, B) # done with IVar(j) i_eqs, i_comps = elim(i_eqs, i_comps, j) # add this point, i_eqs and i_comps contain only comparisons with IVar(i) alone assert_comparisons_to_blackboard(i_eqs, i_comps, B) # done with IVar(i) eqs, comps = elim(eqs, comps, i) timer.stop(timer.FMMUL)
def update_blackboard(self, B): """ Saturates a Blackboard B with additive inferences. """ timer.start(timer.PADD) messages.announce_module('polyhedron additive module') # learn_additive_sign_info(blackboard) comparisons = get_additive_information(B) h_matrix = lrs_util.create_h_format_matrix(comparisons, B.num_terms) messages.announce('Halfplane matrix:', messages.DEBUG) messages.announce(h_matrix, messages.DEBUG) v_matrix, v_lin_set = lrs_util.get_vertices(h_matrix) messages.announce('Vertex matrix:', messages.DEBUG) #messages.announce(str(v_matrix), messages.DEBUG) for l in v_matrix: messages.announce(str(l), messages.DEBUG) messages.announce('Linear set:', messages.DEBUG) messages.announce(str(v_lin_set), messages.DEBUG) new_comparisons = get_2d_comparisons(v_matrix, v_lin_set) for c in new_comparisons: B.assert_comparison(c) timer.stop(timer.PADD)
def update_blackboard(self, B): """ Asserts identities about minm terms """ messages.announce_module('minimum module') timer.start(timer.MINM) for i in range(B.num_terms): if isinstance( B.term_defs[i], terms.FuncTerm) and B.term_defs[i].func_name == 'minm': # t_i is of the form minm(...) args = B.term_defs[i].args # assert that t_i is le all of its arguments for a in args: B.assert_comparison(terms.IVar(i) <= a) # see if we can infer the sign # TODO: optimize if all(B.implies_comparison(a > 0) for a in args): B.assert_comparison(terms.IVar(i) > 0) elif all(B.implies_comparison(a >= 0) for a in args): B.assert_comparison(terms.IVar(i) >= 0) if any(B.implies_comparison(a < 0) for a in args): B.assert_comparison(terms.IVar(i) < 0) elif any(B.implies_comparison(a <= 0) for a in args): B.assert_comparison(terms.IVar(i) <= 0) # see if any multiple of another problem term is known to be less than all the # arguments. for j in range(B.num_terms): if j != i: comp_range = geometry.ComparisonRange( geometry.neg_infty, geometry.infty, True, True, True) for a in args: new_comp_range = B.le_coeff_range( j, a.term.index, a.coeff) comp_range = comp_range & new_comp_range if comp_range.is_empty(): break if not comp_range.is_empty(): if comp_range.lower.type == geometry.VAL: c = comp_range.lower.val if comp_range.lower_strict: B.assert_comparison( c * terms.IVar(j) < terms.IVar(i)) else: B.assert_comparison( c * terms.IVar(j) <= terms.IVar(i)) if comp_range.upper.type == geometry.VAL: c = comp_range.upper.val if comp_range.upper_strict: B.assert_comparison( c * terms.IVar(j) < terms.IVar(i)) else: B.assert_comparison( c * terms.IVar(j) <= terms.IVar(i)) timer.stop(timer.MINM)
def update_blackboard(self, B): """ Asserts identities about exp and log terms found in B. """ timer.start(timer.EXP) messages.announce_module('exponential module') if any(isinstance(t, terms.FuncTerm) and t.func == terms.exp for t in B.term_defs.values()): B.assert_comparison(terms.exp(0) == 1) if any(isinstance(t, terms.FuncTerm) and t.func == terms.log for t in B.term_defs.values()): B.assert_comparison(terms.log(1) == 0) exp_factor_constant(B) exp_factor_sum(B) log_factor_exponent(B) log_factor_product(B) timer.stop(timer.EXP)
def update_blackboard(self, B): """ Asserts identities about minm terms """ messages.announce_module('minimum module') timer.start(timer.MINM) for i in range(B.num_terms): if isinstance(B.term_defs[i], terms.FuncTerm) and B.term_defs[i].func_name == 'minm': # t_i is of the form minm(...) args = B.term_defs[i].args # assert that t_i is le all of its arguments for a in args: B.assert_comparison(terms.IVar(i) <= a) # see if we can infer the sign # TODO: optimize if all(B.implies_comparison(a > 0) for a in args): B.assert_comparison(terms.IVar(i) > 0) elif all(B.implies_comparison(a >= 0) for a in args): B.assert_comparison(terms.IVar(i) >= 0) if any(B.implies_comparison(a < 0) for a in args): B.assert_comparison(terms.IVar(i) < 0) elif any(B.implies_comparison(a <= 0) for a in args): B.assert_comparison(terms.IVar(i) <= 0) # see if any multiple of another problem term is known to be less than all the # arguments. for j in range(B.num_terms): if j != i: comp_range = geometry.ComparisonRange(geometry.neg_infty, geometry.infty, True, True, True) for a in args: new_comp_range = B.le_coeff_range(j, a.term.index, a.coeff) comp_range = comp_range & new_comp_range if comp_range.is_empty(): break if not comp_range.is_empty(): if comp_range.lower.type == geometry.VAL: c = comp_range.lower.val if comp_range.lower_strict: B.assert_comparison(c * terms.IVar(j) < terms.IVar(i)) else: B.assert_comparison(c * terms.IVar(j) <= terms.IVar(i)) if comp_range.upper.type == geometry.VAL: c = comp_range.upper.val if comp_range.upper_strict: B.assert_comparison(c * terms.IVar(j) < terms.IVar(i)) else: B.assert_comparison(c * terms.IVar(j) <= terms.IVar(i)) timer.stop(timer.MINM)
def update_blackboard(self, B): """ Asserts identities about exp and log terms found in B. """ timer.start(timer.EXP) messages.announce_module('exponential module') if any(isinstance(t, terms.FuncTerm) and t.func == terms.exp for t in B.term_defs.values()): B.assert_comparison(terms.exp(0) == 1) if any(isinstance(t, terms.FuncTerm) and t.func == terms.log for t in B.term_defs.values()): B.assert_comparison(terms.log(1) == 0) exp_factor_constant(B) exp_factor_sum(B) #exp_factor_both(B) log_factor_exponent(B) log_factor_product(B) timer.stop(timer.EXP)
def update_blackboard(self, B): """ Adds axioms corresponding to each nth root function present. """ messages.announce_module('nth root value module') timer.start(timer.ROOT) #nth_roots = [] def is_nth_root_term(i): """ Returns True if t_i is of the form abs(t_j). """ return (isinstance(B.term_defs[i], terms.FuncTerm) and isinstance(B.term_defs[i].func, terms.NthRoot)) def root_degree(i): """ If t_i is of the form NthRoot(n, t_j), returns n. """ return B.term_defs[i].func.n nth_roots = set([ root_degree(i) for i in range(B.num_terms) if is_nth_root_term(i) ]) x = terms.Var('x') for n in nth_roots: if n % 2 == 0: self.am.add_axiom( formulas.Forall([x], formulas.Implies(x >= 0, terms.root(n, x)**n == x))) self.am.add_axiom( formulas.Forall([x], formulas.Implies(x >= 0, terms.root(n, x) >= 0))) else: self.am.add_axiom( formulas.Forall([x], terms.root(n, x)**n == x)) timer.stop(timer.ROOT)
def update_blackboard(self, B): """ Checks the blackboard B for function terms with equal arguments, and asserts that the function terms are equal. """ def eq_func_terms(f1, f2): """ Returns true if f1 and f2 have the same name and arity, and all args are equal. """ if f1.func_name != f2.func_name or len(f1.args) != len(f2.args): return False for i in range(len(f1.args)): arg1, arg2 = f1.args[i], f2.args[i] if arg1.coeff == 0: eq = B.implies(arg2.term.index, terms.EQ, 0, 0) or arg2.coeff == 0 else: eq = B.implies(arg1.term.index, terms.EQ, fractions.Fraction(arg2.coeff, arg1.coeff), arg2.term.index) if not eq: return False return True timer.start(timer.CCM) messages.announce_module('congruence closure module') func_classes = {} for i in (d for d in range(B.num_terms) if isinstance(B.term_defs[d], terms.FuncTerm)): name = B.term_defs[i].func_name func_classes[name] = func_classes.get(name, []) + [i] for name in func_classes: tinds = func_classes[name] for (i, j) in itertools.combinations(tinds, 2): # ti and tj are function terms with the same symbols. check if they're equal. f1, f2 = B.term_defs[i], B.term_defs[j] if eq_func_terms(f1, f2): B.assert_comparison(terms.IVar(i) == terms.IVar(j)) timer.stop(timer.CCM)
def update_blackboard(self, B): """ Adds axioms for sin, cos, tan, floor """ timer.start(timer.BUILTIN) ts = [B.term_defs[i] for i in range(B.num_terms)] funcs = [t.func.name for t in ts if isinstance(t, terms.FuncTerm)] if (not self.added['sin'] and 'sin' in funcs): self.am.add_axioms(sin_axioms) self.added['sin'] = True if (not self.added['cos'] and 'cos' in funcs): self.am.add_axioms(cos_axioms) self.added['cos'] = True if (not self.added['tan'] and 'tan' in funcs): self.am.add_axioms(tan_axioms) self.added['tan'] = True if (not self.added['floor'] and 'floor' in funcs): self.am.add_axioms(floor_axioms) self.added['floor'] = True if (not self.added['abs'] and 'abs' in funcs): self.am.add_axioms(abs_axioms) self.added['abs'] = True if (not self.added['exp'] and 'exp' in funcs): self.am.add_axioms(exp_axioms) self.added['exp'] = True if (not self.added['log'] and 'log' in funcs): self.am.add_axioms(log_axioms) self.added['log'] = True timer.stop(timer.BUILTIN)
def update_blackboard(self, B): """ Saturates a Blackboard B with multiplicative inferences. """ timer.start(timer.PMUL) messages.announce_module('polyhedron multiplicative module') mul_util.derive_info_from_definitions(B) mul_util.preprocess_cancellations(B) m_comparisons = mul_util.get_multiplicative_information(B) # Each ti in m_comparisons really represents |t_i|. p = add_of_mul_comps(m_comparisons, B.num_terms) a_comparisons, prime_of_index, num_terms = p a_comparisons = [terms.comp_eval[c[1]](c[0], 0) for c in a_comparisons] h_matrix = lrs_util.create_h_format_matrix(a_comparisons, num_terms) messages.announce('Halfplane matrix:', messages.DEBUG) messages.announce(h_matrix, messages.DEBUG) v_matrix, v_lin_set = lrs_util.get_vertices(h_matrix) messages.announce('Vertex matrix:', messages.DEBUG) for l in v_matrix: messages.announce(str(l), messages.DEBUG) messages.announce('Linear set:', messages.DEBUG) messages.announce(str(v_lin_set), messages.DEBUG) new_comparisons = get_mul_comparisons(v_matrix, v_lin_set, B.num_terms, prime_of_index) for m1, m2, coeff, comp in new_comparisons: c = mul_util.process_mul_comp(m1, m2, coeff, comp, B) if c is not None: B.assert_comparison(c) timer.stop(timer.PMUL)
def update_blackboard(self, B): """ Instantiates all stored axioms with respect to B and asserts new clauses. """ timer.start(timer.FUN) messages.announce_module('axiom module') n = B.num_terms + len(B.equalities.keys()) + len(B.zero_equalities) #if n == self.num_eqs: # messages.announce("No new information for the axiom module to use.", messages.DEBUG) # timer.stop(timer.FUN) # return self.num_eqs = n for a in self.axioms: messages.announce("Instantiating axiom: {}".format(a), messages.DEBUG) if a.unifiable: clauses = instantiate(a, self.used_envs, B) for c in clauses: B.assert_clause(*c) else: clauses = instantiate_triggerless(a, self.used_envs, B) for c in clauses: B.assert_clause(*c) timer.stop(timer.FUN)
def update_blackboard(self, B): """ Adds variations on the triangle inequality. Looks for expressions abs(c1 * t1 + ... + ck * tk) for which each ti either occurs in an abs term, or has a known sign. In that case, adds inequalities corresponding to abs(c1 * t1 + ... + ck * tk) <= abs(c1 * t1) + ... + abs(ck * tk) abs(c1 * t1 + ... + ck * tk) >= abs(cj * tj) - (abs(c1 * t1) + ... + abs(ck * tk)) """ messages.announce_module('absolute value module') timer.start(timer.ABS) def is_abs_term(i): """ Returns True if t_i is of the form abs(t_j). """ return (isinstance(B.term_defs[i], terms.FuncTerm) and B.term_defs[i].func_name == 'abs') def abs_arg_index(i): """ If t_i is of the form abs(t_j), returns j. """ return B.term_defs[i].args[0].term.index def is_sum_term(i): """ Return True if t_i is a sum. """ return isinstance(B.term_defs[i], terms.AddTerm) def sum_args(i): """ Assuming t_i is a sum, returns the arguments. """ return B.term_defs[i].args # indices i of terms t_i of the form abs(t_j) abs_indices = [i for i in range(B.num_terms) if is_abs_term(i)] # indices j of terms occurring in the context abs(t_j) abs_wrapped_indices = [abs_arg_index(i) for i in abs_indices] # indices of terms of the form abs(c1 * t1 + ... + ck * tk) abs_sum_indices = [i for i in abs_indices if is_sum_term(abs_arg_index(i))] def abs_present(i): """ Returns True if t_i occurs in the context abs(t_i) or has known sign, which is to say, something equivalent to abs(t_i) is already a problem term. """ return i in abs_wrapped_indices or B.weak_sign(i) == 1 or B.weak_sign(i) == -1 def abs_of(i): """ Assuming abs_present(i), returns an expression equal to abs(t_i). """ if B.weak_sign(i) == 1: return terms.IVar(i) elif B.weak_sign(i) == -1: return terms.IVar(i) * -1 else: return terms.IVar(next(j for j in abs_indices if abs_arg_index(j) == i)) for i in abs_sum_indices: args = sum_args(abs_arg_index(i)) if all(abs_present(a.term.index) for a in args): abs_of_args = [a.coeff * abs_of(a.term.index) for a in args] sum_of_abs_of_args = reduce(lambda x, y: x + y, abs_of_args, 0) B.assert_comparison(terms.IVar(i) <= sum_of_abs_of_args) for a in abs_of_args: B.assert_comparison(terms.IVar(i) >= a * 2 - sum_of_abs_of_args) timer.stop(timer.ABS)
def update_blackboard(self, B): """ Adds variations on the triangle inequality. Looks for expressions abs(c1 * t1 + ... + ck * tk) for which each ti either occurs in an abs term, or has a known sign. In that case, adds inequalities corresponding to abs(c1 * t1 + ... + ck * tk) <= abs(c1 * t1) + ... + abs(ck * tk) abs(c1 * t1 + ... + ck * tk) >= abs(cj * tj) - (abs(c1 * t1) + ... + abs(ck * tk)) """ messages.announce_module('absolute value module') timer.start(timer.ABS) def is_abs_term(i): """ Returns True if t_i is of the form abs(t_j). """ return (isinstance(B.term_defs[i], terms.FuncTerm) and B.term_defs[i].func_name == 'abs') def abs_arg_index(i): """ If t_i is of the form abs(t_j), returns j. """ return B.term_defs[i].args[0].term.index def is_sum_term(i): """ Return True if t_i is a sum. """ return isinstance(B.term_defs[i], terms.AddTerm) def sum_args(i): """ Assuming t_i is a sum, returns the arguments. """ return B.term_defs[i].args # indices i of terms t_i of the form abs(t_j) abs_indices = [i for i in range(B.num_terms) if is_abs_term(i)] # indices j of terms occurring in the context abs(t_j) abs_wrapped_indices = [abs_arg_index(i) for i in abs_indices] # indices of terms of the form abs(c1 * t1 + ... + ck * tk) abs_sum_indices = [ i for i in abs_indices if is_sum_term(abs_arg_index(i)) ] def abs_present(i): """ Returns True if t_i occurs in the context abs(t_i) or has known sign, which is to say, something equivalent to abs(t_i) is already a problem term. """ return i in abs_wrapped_indices or B.weak_sign( i) == 1 or B.weak_sign(i) == -1 def abs_of(i): """ Assuming abs_present(i), returns an expression equal to abs(t_i). """ if B.weak_sign(i) == 1: return terms.IVar(i) elif B.weak_sign(i) == -1: return terms.IVar(i) * -1 else: return terms.IVar( next(j for j in abs_indices if abs_arg_index(j) == i)) for i in abs_sum_indices: args = sum_args(abs_arg_index(i)) if all(abs_present(a.term.index) for a in args): abs_of_args = [a.coeff * abs_of(a.term.index) for a in args] sum_of_abs_of_args = reduce(lambda x, y: x + y, abs_of_args, 0) B.assert_comparison(terms.IVar(i) <= sum_of_abs_of_args) for a in abs_of_args: B.assert_comparison( terms.IVar(i) >= a * 2 - sum_of_abs_of_args) timer.stop(timer.ABS)