def __init__(self): super().__init__('or', -1, (exprtypes.BoolType(), ), exprtypes.BoolType()) self.smt_function = lambda *children: z3.Or(children, children[0].ctx) self.eval_children = lambda *children: any(children) self.commutative = True self.associative = True
def __init__(self): super().__init__('xor', 2, (exprtypes.BoolType(), exprtypes.BoolType()), exprtypes.BoolType()) self.smt_function = z3.Xor self.eval_children = lambda a, b: a != b self.commutative = True self.associative = True
def add_dummy_pred(expr): arg_var = exprs.VariableExpression( exprs.VariableInfo(exprtypes.BoolType(), 'd', 0)) dummy_macro_func = semantics_types.MacroFunction( dummy_pred_name, 1, (exprtypes.BoolType(), ), exprtypes.BoolType(), arg_var, [arg_var]) expr = exprs.FunctionExpression(dummy_macro_func, (expr, )) return expr
def simplify_basic(syn_ctx, expr): if not exprs.is_function_expression(expr): return expr func_name = expr.function_info.function_name if func_name not in ['and', 'or', 'not', 'ite']: return expr true = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType())) false = exprs.ConstantExpression(exprs.Value(False, exprtypes.BoolType())) if func_name == 'and': cond_children = [simplify_basic(syn_ctx, c) for c in expr.children] cond_true_children = [c for c in cond_children if c != true] cond_false_children = [c for c in cond_children if c == false] if len(cond_false_children) > 0: return false elif len(cond_true_children) == 0: return true elif len(cond_true_children) == 1: return cond_true_children[0] else: return syn_ctx.make_function_expr('and', *cond_true_children) elif func_name == 'or': cond_children = [simplify_basic(syn_ctx, c) for c in expr.children] cond_true_children = [c for c in cond_children if c == true] cond_false_children = [c for c in cond_children if c != false] if len(cond_true_children) > 0: return true elif len(cond_false_children) == 0: return false elif len(cond_false_children) == 1: return cond_false_children[0] else: return syn_ctx.make_function_expr('or', *cond_false_children) elif func_name == 'not': child = simplify_basic(syn_ctx, expr.children[0]) if child == true: return false elif child == false: return true else: return expr else: #ITE cond = simplify_basic(syn_ctx, expr.children[0]) if cond == true: return simplify_basic(syn_ctx, expr.children[1]) elif cond == false: return simplify_basic(syn_ctx, expr.children[2]) else: return syn_ctx.make_function_expr( 'ite', cond, simplify_basic(syn_ctx, expr.children[1]), simplify_basic(syn_ctx, expr.children[2]))
def z3value_to_value(value, var_info): if (var_info.variable_type == exprtypes.BoolType()): return exprs.Value(bool(value), exprtypes.BoolType()) elif (var_info.variable_type == exprtypes.IntType()): # TODO: Why are these int(str(value)) instead of value.as_long() return exprs.Value(int(str(value)), exprtypes.IntType()) elif (var_info.variable_type.type_code == exprtypes.TypeCodes.bit_vector_type): return exprs.Value( BitVector(int(str(value)), var_info.variable_type.size), var_info.variable_type) else: raise basetypes.UnhandledCaseError('solvers.In model_to_point')
def __init__(self): super().__init__('str.suffixof', 2, (exprtypes.StringType(), exprtypes.StringType()), exprtypes.BoolType()) # self.smt_function = z3.SuffixOf # self.eval_children = str.endswith self.eval_children = lambda a, b: str.endswith(b, a)
def _dummy_spec(self, synth_fun): func = semantics_types.SynthFunction( 'pred_indicator_' + str(random.randint(1, 10000000)), synth_fun.function_arity, synth_fun.domain_types, exprtypes.BoolType()) args = [ exprs.FormalParameterExpression(func, argtype, i) for i, argtype in enumerate(synth_fun.domain_types) ] indicator_expr = exprs.FunctionExpression(func, tuple(args)) eval_ctx = evaluation.EvaluationContext() def compute_indicator(term, points): eval_ctx.set_interpretation(func, term) retval = [] for point in points: eval_ctx.set_valuation_map(point) try: retval.append( evaluation.evaluate_expression_raw( indicator_expr, eval_ctx)) except (basetypes.UnboundLetVariableError, basetypes.PartialFunctionError): # Can't mess up on predicates return [False] * len(points) return retval return func, compute_indicator
def _process_rule(non_terminals, nt_type, syn_ctx, arg_vars, var_map, synth_fun, rule_data): ph_let_bound_vars, let_bound_vars = [], [] if type(rule_data) == tuple: value = sexp_to_value(rule_data) ret = grammars.ExpressionRewrite(exprs.ConstantExpression(value)) elif rule_data[0] == 'Constant': typ = sexp_to_type(rule_data[1]) ret = grammars.NTRewrite('Constant' + str(typ), typ) elif rule_data[0] in [ 'Variable', 'InputVariable', 'LocalVariable' ]: raise NotImplementedError('Variable rules in grammars') elif type(rule_data) == str: if rule_data in [ a.variable_info.variable_name for a in arg_vars ]: (parameter_position, variable) = next((i, x) for (i, x) in enumerate(arg_vars) if x.variable_info.variable_name == rule_data) expr = exprs.FormalParameterExpression(synth_fun, variable.variable_info.variable_type, parameter_position) ret = grammars.ExpressionRewrite(expr) elif rule_data in non_terminals: ret = grammars.NTRewrite(rule_data, nt_type[rule_data]) elif rule_data in var_map: ret = grammars.ExpressionRewrite(var_map[rule_data]) else: # Could be a 0 arity function func = syn_ctx.make_function(rule_data) if func != None: ret = grammars.ExpressionRewrite(syn_ctx.make_function_expr(rule_data)) else: # Could be a let bound variable bound_var_ph = exprs.VariableExpression(exprs.VariableInfo(exprtypes.BoolType(), 'ph_' + rule_data)) ph_let_bound_vars.append(bound_var_ph) ret = grammars.ExpressionRewrite(bound_var_ph) elif type(rule_data) == list: function_name = rule_data[0] if function_name != 'let': function_args = [] for child in rule_data[1:]: ph_lbv, lbv, arg = _process_rule(non_terminals, nt_type, syn_ctx, arg_vars, var_map, synth_fun, child) ph_let_bound_vars.extend(ph_lbv) let_bound_vars.extend(lbv) function_args.append(arg) function_arg_types = tuple([ x.type for x in function_args ]) function = syn_ctx.make_function(function_name, *function_arg_types) else: def child_processing_func(rd, syn_ctx, new_var_map): ph_lbv, lbv, a = _process_rule(non_terminals, nt_type, syn_ctx, arg_vars, new_var_map, synth_fun, rd) ph_let_bound_vars.extend(ph_lbv) let_bound_vars.extend(lbv) return a def get_return_type(r): return r.type function, function_args = sexp_to_let(rule_data, syn_ctx, child_processing_func, get_return_type, var_map) let_bound_vars.extend(function.binding_vars) assert function is not None ret = grammars.FunctionRewrite(function, *function_args) else: raise Exception('Unknown right hand side: %s' % rule_data) return ph_let_bound_vars, let_bound_vars, ret
def _constant_to_string(constant_type, constant_value): if constant_type == exprtypes.BoolType(): return str(constant_value).lower() elif constant_type == exprtypes.IntType(): return str(constant_value) elif constant_type == exprtypes.StringType(): return '"%s"' % constant_value else: return utils.bitvector_to_string(constant_value, constant_type.size)
def sexp_to_type(sexp): if type(sexp) == list and sexp[0] == 'BitVec': assert type(sexp[1]) == tuple and sexp[1][0] == 'Int' length = sexp[1][1] return exprtypes.BitVectorType(length) elif sexp == 'Int': return exprtypes.IntType() elif sexp == 'Bool': return exprtypes.BoolType() elif sexp == 'String': return exprtypes.StringType() else: raise Exception("Unknown type: %s" % str(sexp))
def rewrite_pred(syn_ctx, pred, boolean_combs, comparators, neg, consts, constant_multiplication): liaineq = LIAInequality.from_expr(pred).to_positive_form() if liaineq.is_valid(): if len(consts) > 0: return exprs.ConstantExpression( exprs.Value(True, exprtypes.BoolType())) else: return None (left, op, right) = (liaineq.left, liaineq.op, liaineq.right) negate = {'<': '>=', '>': '<=', '>=': '<', '<=': '>'} flip = {'<': '>', '>': '<', '>=': '<=', '<=': '>='} addNot = False if op not in comparators: if op in negate and negate[op] in comparators: (left, op, right) = (left, negate[op], right) addNot = True elif op in flip and flip[op] in comparators: (left, op, right) = (right, flip[op], left) elif op == '=' and ('<=' in comparators or '>=' in comparators): new_op = '<=' if '<=' in comparators else '>=' p1 = syn_ctx.make_function_expr(new_op, pred.children[0], pred.children[1]) p2 = syn_ctx.make_function_expr(new_op, pred.children[1], pred.children[0]) return syn_ctx.make_function_expr( 'and', rewrite_pred(syn_ctx, p1, boolean_combs, comparators, neg, consts, constant_multiplication), rewrite_pred(syn_ctx, p2, boolean_combs, comparators, neg, consts, constant_multiplication)) else: return None liaineq = LIAInequality(left, op, right).to_positive_form() left_term = rewrite_lia_term(syn_ctx, liaineq.left, neg, consts, constant_multiplication) right_term = rewrite_lia_term(syn_ctx, liaineq.right, neg, consts, constant_multiplication) if left_term is None or right_term is None: return None ret = syn_ctx.make_function_expr(liaineq.op, left_term, right_term) if addNot: ret = syn_ctx.make_function_expr('not', ret) return ret
def string_to_constant_rewrite(topsymb): if topsymb.isdigit() or (topsymb.startswith('-') and len(topsymb) >= 2 and topsymb[1:].isdigit): num = -1 * int(topsymb[1:]) if topsymb.startswith('-') else int( topsymb) return grammars.ExpressionRewrite( exprs.ConstantExpression(exprs.Value(num, exprtypes.IntType()))) elif topsymb.startswith('#x'): # bitvector num = int('0' + topsymb[1:], 16) bitsize = (len(topsymb) - 2) * 4 return grammars.ExpressionRewrite( exprs.ConstantExpression( exprs.Value(num, exprtypes.BitVectorType(bitsize)))) else: # boolean return grammars.ExpressionRewrite( exprs.ConstantExpression( exprs.Value(bool(topsymb), exprtypes.BoolType())))
def make_false_expr(self): """Makes an expression representing the boolean constant FALSE.""" return exprs.ConstantExpression( exprs.Value(False, exprtypes.BoolType()))
def make_true_expr(self): """Makes an expression representing the Boolean constant TRUE.""" return exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType()))
def _generate_test_generators(): from core import synthesis_context from semantics import semantics_core from semantics import semantics_lia syn_ctx = synthesis_context.SynthesisContext( semantics_core.CoreInstantiator(), semantics_lia.LIAInstantiator()) var_a_info = syn_ctx.make_variable(exprtypes.IntType(), 'varA', 0) var_b_info = syn_ctx.make_variable(exprtypes.IntType(), 'varB', 1) var_c_info = syn_ctx.make_variable(exprtypes.IntType(), 'varC', 2) var_a = exprs.VariableExpression(var_a_info) var_b = exprs.VariableExpression(var_b_info) var_c = exprs.VariableExpression(var_c_info) zero_value = exprs.Value(0, exprtypes.IntType()) one_value = exprs.Value(1, exprtypes.IntType()) zero_exp = exprs.ConstantExpression(zero_value) one_exp = exprs.ConstantExpression(one_value) var_generator = LeafGenerator([var_a, var_b, var_c], 'Variable Generator') const_generator = LeafGenerator([zero_exp, one_exp], 'Constant Generator') leaf_generator = AlternativesGenerator([var_generator, const_generator], 'Leaf Term Generator') generator_factory = RecursiveGeneratorFactory() start_generator_ph = generator_factory.make_placeholder('Start') start_bool_generator_ph = generator_factory.make_placeholder('StartBool') add_fun = syn_ctx.make_function('add', exprtypes.IntType(), exprtypes.IntType()) sub_fun = syn_ctx.make_function('sub', exprtypes.IntType(), exprtypes.IntType()) ite_fun = syn_ctx.make_function('ite', exprtypes.BoolType(), exprtypes.IntType(), exprtypes.IntType()) and_fun = syn_ctx.make_function('and', exprtypes.BoolType(), exprtypes.BoolType()) or_fun = syn_ctx.make_function('or', exprtypes.BoolType(), exprtypes.BoolType()) not_fun = syn_ctx.make_function('not', exprtypes.BoolType()) le_fun = syn_ctx.make_function('le', exprtypes.IntType(), exprtypes.IntType()) ge_fun = syn_ctx.make_function('ge', exprtypes.IntType(), exprtypes.IntType()) eq_fun = syn_ctx.make_function('eq', exprtypes.IntType(), exprtypes.IntType()) start_generator = \ generator_factory.make_generator('Start', AlternativesGenerator, ([leaf_generator] + [FunctionalGenerator(add_fun, [start_generator_ph, start_generator_ph]), FunctionalGenerator(sub_fun, [start_generator_ph, start_generator_ph]), FunctionalGenerator(ite_fun, [start_bool_generator_ph, start_generator_ph, start_generator_ph])],)) generator_factory.make_generator('StartBool', AlternativesGenerator, ([ FunctionalGenerator( and_fun, [start_bool_generator_ph, start_bool_generator_ph]), FunctionalGenerator( or_fun, [start_bool_generator_ph, start_bool_generator_ph]), FunctionalGenerator(not_fun, [start_bool_generator_ph]), FunctionalGenerator(le_fun, [start_generator_ph, start_generator_ph]), FunctionalGenerator(eq_fun, [start_generator_ph, start_generator_ph]), FunctionalGenerator(ge_fun, [start_generator_ph, start_generator_ph]) ], )) return start_generator
from parsers import parser from core import synthesis_context from semantics import semantics_core from semantics import semantics_types from core import synthesis_context import random import pickle import itertools # import numpy as np # import matplotlib.pyplot as plt # import networkx as nx from sphogs.sphog_utils import * from utils import z3smt max_score = 9999999.0 original_expr_to_compare = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType())) class PriorityQueue: def __init__(self): self.heap = [] self.elements = set([]) self.nelem = 0 def empty(self): return (self.nelem == 0) def get(self): pri, d = heapq.heappop(self.heap) self.nelem -= 1 self.elements.remove(d) return pri, d
# # # Code: from eusolver import BitSet from semantics import semantics_core from unifiers.unifiers import UnifierInterface from exprs import evaluation from exprs import exprs from exprs import exprtypes from utils.lia_utils import LIAInequality _expr_to_str = exprs.expression_to_string _true_expr = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType(), -1)) _false_expr = exprs.ConstantExpression(exprs.Value(False, exprtypes.BoolType(), -1)) def simplify_inequality(inequality): if LIAInequality.from_expr(inequality).is_valid(): return _true_expr return inequality def _filter_to_intro_vars(clauses, intro_vars): only_intro_var_clauses = [] for clause in clauses: new_clause = [] for disjunct in clause: variables = exprs.get_all_variables(disjunct) for v in variables: if v not in intro_vars:
def __init__(self): super().__init__('str.contains', 2, (exprtypes.StringType(), exprtypes.StringType()), exprtypes.BoolType()) # self.smt_function = z3.Contains self.eval_children = lambda a, b: str.find(a, b) != -1
def __init__(self): super().__init__('str.prefixof', 2, (exprtypes.StringType(), exprtypes.StringType()), exprtypes.BoolType()) # self.smt_function = z3.PrefixOf self.eval_children = str.startswith
def __init__(self, range_type): super().__init__('ite', 3, (exprtypes.BoolType(), range_type, range_type), range_type) self.smt_function = z3.If self.eval_children = lambda a, b, c: b if a else c
def __init__(self): super().__init__('not', 1, (exprtypes.BoolType(), ), exprtypes.BoolType()) self.smt_function = z3.Not self.eval_children = lambda child: not child
def __init__(self): super().__init__('=>', 2, (exprtypes.BoolType(), exprtypes.BoolType()), exprtypes.BoolType()) self.smt_function = z3.Implies self.eval_children = lambda a, b: (not a) or b
def __init__(self): super().__init__('>', 2, (exprtypes.IntType(), exprtypes.IntType()), exprtypes.BoolType()) self.eval_children = lambda a, b: a > b self.smt_function = lambda a, b: a > b
def __init__(self, bv_size): super().__init__('bvsgt', 2, (exprtypes.BitVectorType(bv_size), exprtypes.BitVectorType(bv_size)), exprtypes.BoolType()) self.smt_function = lambda a, b: a > b self.eval_children = lambda a, b: a.sgt(b)
def make_default_grammar(syn_ctx, theory, return_type, args): int_type = exprtypes.IntType() bool_type = exprtypes.BoolType() if theory == 'LIA': [start, start_bool, const] = ['Start', 'StartBool', 'ConstantIntegerType'] nts = [start, start_bool, const] nt_type = {start: int_type, start_bool: bool_type, const: int_type} rules = {start: [], start_bool: [], const: []} ntr_start = NTRewrite(start, int_type) ntr_startbool = NTRewrite(start_bool, bool_type) ntr_const = NTRewrite(const, int_type) [ add_func, sub_func, mul_func, div_func, mod_func ] = \ [ syn_ctx.make_function(name, int_type, int_type) for name in [ 'add', 'sub', 'mul', 'div', 'mod' ] ] ite_func = syn_ctx.make_function('ite', bool_type, int_type, int_type) [ and_func, or_func ] = \ [ syn_ctx.make_function(name, bool_type, bool_type) for name in [ 'and', 'or' ] ] not_func = syn_ctx.make_function('not', bool_type) [ eq_func, ne_func, le_func, lt_func, ge_func, gt_func ] = \ [ syn_ctx.make_function(name, int_type, int_type) for name in [ '=', 'ne', '<=', '<', '>=', '>' ] ] # Start rules: # Args for arg in args: if exprs.get_expression_type(arg) == int_type: rules[start].append(ExpressionRewrite(arg)) elif exprs.get_expression_type(arg) == bool_type: rules[start_bool].append(ExpressionRewrite(arg)) # Constants rules[start].append( ExpressionRewrite( exprs.ConstantExpression(exprs.Value(1, int_type)))) rules[start].append( ExpressionRewrite( exprs.ConstantExpression(exprs.Value(0, int_type)))) rules[start].append(ntr_const) # Start + Start, Start - Start, rules[start].append(FunctionRewrite(add_func, ntr_start, ntr_start)) rules[start].append(FunctionRewrite(sub_func, ntr_start, ntr_start)) # Start * Constant, Start / Constant, Start mod Constant rules[start].append(FunctionRewrite(mul_func, ntr_start, ntr_start)) rules[start].append(FunctionRewrite(div_func, ntr_start, ntr_start)) rules[start].append(FunctionRewrite(mod_func, ntr_start, ntr_start)) # ITE rules[start].append( FunctionRewrite(ite_func, ntr_startbool, ntr_start, ntr_start)) # Start bool rules # And, or, not rules[start_bool].append( ExpressionRewrite( exprs.ConstantExpression(exprs.Value(False, bool_type)))) rules[start_bool].append( ExpressionRewrite( exprs.ConstantExpression(exprs.Value(True, bool_type)))) rules[start_bool].append( FunctionRewrite(and_func, ntr_startbool, ntr_startbool)) rules[start_bool].append( FunctionRewrite(or_func, ntr_startbool, ntr_startbool)) rules[start_bool].append(FunctionRewrite(not_func, ntr_startbool)) # comparison ops rules[start_bool].append(FunctionRewrite(eq_func, ntr_start, ntr_start)) rules[start_bool].append(FunctionRewrite(ne_func, ntr_start, ntr_start)) rules[start_bool].append(FunctionRewrite(le_func, ntr_start, ntr_start)) rules[start_bool].append(FunctionRewrite(lt_func, ntr_start, ntr_start)) rules[start_bool].append(FunctionRewrite(ge_func, ntr_start, ntr_start)) rules[start_bool].append(FunctionRewrite(gt_func, ntr_start, ntr_start)) # Constant rules rules[const].append( ExpressionRewrite( exprs.ConstantExpression(exprs.Value(1, int_type)))) rules[const].append( ExpressionRewrite( exprs.ConstantExpression(exprs.Value(0, int_type)))) rules[const].append(FunctionRewrite(add_func, ntr_const, ntr_const)) rules[const].append(FunctionRewrite(add_func, ntr_const, ntr_const)) rules[const].append(FunctionRewrite(sub_func, ntr_const, ntr_const)) if return_type == int_type: ret = Grammar(nts, nt_type, rules, start) elif return_type == bool_type: ret = Grammar(nts, nt_type, rules, start_bool) else: raise NotImplementedError ret.from_default = True return ret elif theory == 'BV': from semantics import semantics_bv from semantics import semantics_core print("ARSAYS: Default bit-vec grammar shouldn't be used!") (start, start_bool) = ('Start', 'StartBool') bv_size = 64 nts = [start, start_bool] (bv_type, bool_type) = (exprtypes.BitVectorType(bv_size), exprtypes.BoolType()) nt_type = {start: bv_type, start_bool: bool_type} rules = {start: [], start_bool: []} ntr_start = NTRewrite(start, bv_type) ntr_start_bool = NTRewrite(start_bool, bool_type) rules[start].extend( map( lambda x: ExpressionRewrite( exprs.ConstantExpression(exprs.Value(x, bv_type))), [0, 1])) for func in [ semantics_bv.BVNot(bv_size), semantics_bv.BVAdd(bv_size), semantics_bv.BVAnd(bv_size), semantics_bv.BVOr(bv_size), semantics_bv.BVNeg(bv_size), semantics_bv.BVAdd(bv_size), semantics_bv.BVMul(bv_size), semantics_bv.BVSub(bv_size), semantics_bv.BVUDiv(bv_size), semantics_bv.BVSDiv(bv_size), semantics_bv.BVSRem(bv_size), semantics_bv.BVURem(bv_size), semantics_bv.BVShl(bv_size), semantics_bv.BVLShR(bv_size), semantics_bv.BVAShR(bv_size), semantics_bv.BVUlt(bv_size), semantics_bv.BVUle(bv_size), semantics_bv.BVUge(bv_size), semantics_bv.BVUgt(bv_size), semantics_bv.BVSle(bv_size), semantics_bv.BVSlt(bv_size), semantics_bv.BVSge(bv_size), semantics_bv.BVSgt(bv_size), semantics_bv.BVXor(bv_size), semantics_bv.BVXNor(bv_size), semantics_bv.BVNand(bv_size), semantics_bv.BVNor(bv_size), # semantics_bv.BVComp(bv_size) semantics_core.EqFunction(bv_type) ]: assert all([t == bv_type for t in func.domain_types]) args = [ntr_start] * len(func.domain_types) if func.range_type == bv_type: rules[start].append(FunctionRewrite(func, *args)) elif func.range_type == bool_type: rules[start_bool].append(FunctionRewrite(func, *args)) else: assert False ite_func = semantics_core.IteFunction(bv_type) rules[start].append( FunctionRewrite(ite_func, ntr_start_bool, ntr_start, ntr_start)) if return_type == bv_type: ret = Grammar(nts, nt_type, rules, start) elif return_type == bool_type: ret = Grammar(nts, nt_type, rules, start_bool) else: raise NotImplementedError ret.from_default = True return ret elif theory == 'SLIA': raise NotImplementedError else: raise NotImplementedError
from core import synthesis_context from semantics import semantics_core from semantics import semantics_types from core import synthesis_context import random import pickle import itertools # import numpy as np # import matplotlib.pyplot as plt # import networkx as nx from phogs.phog_utils import * from utils import z3smt max_score = 9999999.0 original_expr_to_compare = exprs.ConstantExpression( exprs.Value(True, exprtypes.BoolType())) class PriorityQueue: def __init__(self): self.heap = [] self.elements = set([]) self.nelem = 0 def empty(self): return (self.nelem == 0) def get(self): pri, d = heapq.heappop(self.heap) self.nelem -= 1 self.elements.remove(d)
# # # Code: from eusolver import BitSet from semantics import semantics_core from unifiers.unifiers import UnifierInterface from exprs import evaluation from exprs import exprs from exprs import exprtypes from utils.lia_utils import LIAInequality _expr_to_str = exprs.expression_to_string _true_expr = exprs.ConstantExpression(exprs.Value(True, exprtypes.BoolType())) _false_expr = exprs.ConstantExpression(exprs.Value(False, exprtypes.BoolType())) def simplify_inequality(inequality): if LIAInequality.from_expr(inequality).is_valid(): return _true_expr return inequality def _filter_to_intro_vars(clauses, intro_vars): only_intro_var_clauses = [] for clause in clauses: new_clause = [] for disjunct in clause:
def decompose(self, macro_instantiator): start_nt = self.start reverse_mapping = [] term_productions = [] pred_productions = [] for rewrite in self.rules[start_nt]: ph_vars, nts, orig_expr_template = rewrite.to_template_expr() ph_var_nt_map = dict(zip(ph_vars, nts)) expr_template = macro_instantiator.instantiate_all( orig_expr_template) ifs = exprs.find_all_applications(expr_template, 'ite') # Either there are no ifs or it is an concrete expression if len(ifs) == 0 or len(nts) == 0: term_productions.append(rewrite) continue elif len(ifs) > 1 and ifs[0] != expr_template: return None [cond, thent, elset] = ifs[0].children cond_ph_vars = exprs.get_all_variables(cond) & set(ph_vars) then_ph_vars = exprs.get_all_variables(thent) & set(ph_vars) else_ph_vars = exprs.get_all_variables(elset) & set(ph_vars) if (len(cond_ph_vars & then_ph_vars) > 0 or len(cond_ph_vars & else_ph_vars) > 0 or len(else_ph_vars & then_ph_vars) > 0): return None if ( thent not in ph_vars or \ elset not in ph_vars or \ ph_var_nt_map[thent] != start_nt or \ ph_var_nt_map[elset] != start_nt): return None cond_rewrite = expr_template_to_rewrite(cond, ph_var_nt_map, self) # Make dummy function to recognize predicate arg_var = exprs.VariableExpression( exprs.VariableInfo(exprtypes.BoolType(), 'd', 0)) dummy_macro_func = semantics_types.MacroFunction( 'dummy_pred_id_' + str(random.randint(1, 1000000)), 1, (exprtypes.BoolType(), ), exprtypes.BoolType(), arg_var, [arg_var]) pred_production = FunctionRewrite(dummy_macro_func, cond_rewrite) pred_productions.append(pred_production) reverse_mapping.append( (dummy_macro_func, cond, orig_expr_template, expr_template)) if len(pred_productions) == 0: return None # Non-terminals [term_start, pred_start] = [x + start_nt for x in ['Term', 'Pred']] [term_nts, pred_nts ] = [self.non_terminals + [x] for x in [term_start, pred_start]] term_nts.remove(start_nt) pred_nts.remove(start_nt) # Non-terminal types term_nt_type, pred_nt_type = self.nt_type.copy(), self.nt_type.copy() term_nt_type.pop(start_nt) term_nt_type[term_start] = self.nt_type[start_nt] pred_nt_type.pop(start_nt) pred_nt_type[pred_start] = exprtypes.BoolType() # Rules term_rules = {} term_rules[term_start] = [ rew.rename_nt(start_nt, term_start) for rew in term_productions ] for nt in self.non_terminals: if nt != start_nt: term_rules[nt] = [ rew.rename_nt(start_nt, term_start) for rew in self.rules[nt] ] pred_rules = {} pred_rules[pred_start] = [ rew.rename_nt(start_nt, term_start) for rew in pred_productions ] for nt in self.non_terminals: if nt != start_nt: pred_rules[nt] = [ rew.rename_nt(start_nt, term_start) for rew in self.rules[nt] ] # pred_rules[term_start] = term_rules[term_start] # pred_nt_type[term_start] = term_nt_type[term_start] pred_rules = {**term_rules, **pred_rules} pred_nt_type = {**term_nt_type, **pred_nt_type} term_grammar = Grammar(term_nts, term_nt_type, term_rules, term_start) pred_grammar = Grammar(pred_nts + [term_start], pred_nt_type, pred_rules, pred_start) # print(pred_grammar) return term_grammar, pred_grammar, reverse_mapping
def __init__(self, domain_type): super().__init__('ne', 2, (domain_type, domain_type), exprtypes.BoolType()) self.smt_function = lambda a, b: a != b self.eval_children = lambda a, b: a != b self.commutative = True