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
