def init_case_splits (p, hyps, tags = None): if 'init_case_splits' in p.cached_analysis: return p.cached_analysis['init_case_splits'] if tags == None: tags = p.pairing.tags poss = logic.possible_graph_divs (p) if len (set ([p.node_tags[n][0] for n in poss])) < 2: return None rep = rep_graph.mk_graph_slice (p) assert all ([p.nodes[n].kind == 'Cond' for n in poss]) pc_map = logic.dict_list ([(rep.get_pc ((c, ())), c) for n in poss for c in p.nodes[n].get_conts () if c not in p.loop_data]) no_loop_restrs = tuple ([(n, vc_num (0)) for n in p.loop_heads ()]) err_pc_hyps = [rep_graph.pc_false_hyp ((('Err', no_loop_restrs), tag)) for tag in p.pairing.tags] knowledge = EqSearchKnowledge (rep, hyps + err_pc_hyps, list (pc_map)) last_knowledge[0] = knowledge pc_ids = knowledge.classify_vs () id_n_map = logic.dict_list ([(i, n) for (pc, i) in pc_ids.iteritems () for n in pc_map[pc]]) tag_div_ns = [[[n for n in ns if p.node_tags[n][0] == t] for t in tags] for (i, ns) in id_n_map.iteritems ()] split_pairs = [(l_ns[0], r_ns[0]) for (l_ns, r_ns) in tag_div_ns if l_ns and r_ns] p.cached_analysis['init_case_splits'] = split_pairs return split_pairs
def check_pairs (pairs, loops = True, report_mode = False, only_build_problem = False): num_pairs = len (pairs) printout ('Checking %d function pair problems' % len (pairs)) results = [(pair, toplevel_check (pair, check_loops = loops, report = report_mode, count = (i, num_pairs), only_build_problem = only_build_problem)) for (i, pair) in enumerate (pairs)] result_dict = logic.dict_list ([(result_codes[r][1], pair) for (pair, r) in results]) if not only_build_problem: printout ('Results: %s' % [(pair.name, r) for (pair, r) in results]) printout ('Result summary:') success = result_dict.get ('Success', []) if only_build_problem: printout (' - %d problems build' % len (success)) else: printout (' - %d proofs checked' % len (success)) skipped = result_dict.get ('Skipped', []) printout (' - %d proofs skipped' % len (skipped)) fails = [pair.name for pair in result_dict.get ('Failed', [])] print_coverage_report (set (skipped), set (success + fails)) printout (' - failures: %s' % fails) return syntax.foldr1 (comb_results, ['True'] + [r for (_, r) in results])
def v_id_eq_hyps (v_ids): groups = logic.dict_list ([(k, v) for (v, k) in v_ids.iteritems ()]) hyps = [] for vs in groups.itervalues (): for v in vs[1:]: hyps.append (mk_eq (v, vs[0])) return hyps
def most_common_path (head, knowledge): rep = knowledge.rep [tag, _] = knowledge.tags data = logic.dict_list ([(tuple (entry_path_no_loops (rep, tag, m, head)), m) for m in knowledge.model_trace]) if len (data) < 2: return (None, None, None) (_, path) = max ([(len (data[path]), path) for path in data]) models = data[path] facts = knowledge.facts other_n_vcs = set.intersection (* [set (path2) for path2 in data if path2 != path]) n_vcs = [] pcs = set () for n_vc in path: if n_vc in other_n_vcs: continue if rep.p.loop_id (n_vc[0]): continue pc = rep.get_pc (n_vc) if pc not in pcs: pcs.add (pc) n_vcs.append (n_vc) assert n_vcs return (models, facts, n_vcs)
def update_v_ids_for_model2 (knowledge, v_ids, m): # first update the live variables ev = lambda v: eval_model_expr (m, knowledge.rep.solv, v) groups = logic.dict_list ([((k, ev (v)), v) for (v, k) in v_ids.iteritems ()]) v_ids.clear () for (i, kt) in enumerate (sorted (groups)): for v in groups[kt]: v_ids[v] = i