def samplePos(mod, candInv, coincide, actname): lcs = mod.labeled_conjs conjs = [Clauses([lc.formula]) for lc in lcs] fcs = [icheck.ConjChecker(c, invert=False) for c in lcs] negateci, negateCoincide = negate_clauses(candInv), negate_clauses( coincide) assert isinstance(negateci, Clauses) and isinstance( negateCoincide, Clauses), "negation causes type change" preclause = and_clauses(negateci, negateCoincide, *conjs) print "preclause: ", preclause print "not coincide: ", negateCoincide # print "<plearn> checking for action+ ", actname res = sampleUtil(mod, preclause, fcs, actname) a = raw_input('tried for pos sample') return res
def isValid(self): ''' Checks if the current instance is a valid samplePoint. i.e. for negative sample it checks if the samplePoint satisfies negation of current invariant (fcs) in post state Assumptions : safety Condition and Candidate Inv and Coincide clause is Universally Quantified. ''' global module, candInv, coincide if self.label == '0': # nagative sample fcs = [icheck.ConjChecker(c) for c in module.labeled_conjs] # inverts the fmla fmlas = [ fc.cond().fmlas for fc in fcs ] # fc.cond().fmlas gives a list of ivy predicate logic object. else: # positive sample # return True # It will cause repeatation of some positive samples, but it will not affect the correctness of algorithm # comment the above return stmt to check validity of positive samples negateci, negateCoincide = negate_clauses(candInv), negate_clauses( coincide) condition = and_clauses(negateci, negateCoincide) fmlas = [condition.fmlas] # assert len(fmlas) == 1, "" for fmla in fmlas: # requires satisfying atleast one fmla, as they are in disjunction isfmlatrue = True for pred in fmla: ret = self.solveIvyfmla(pred) assert isinstance( ret, logic.Const), "return value is not a Const object" assert isinstance( ret.sort, BooleanSort), "return is not a boolean formla" assert ret.name in ["0", "1" ], "return value is not in correct format" # print "<plearn> pred: {} \t\t result: {}".format(pred, ret.name) if ret.name == "0": isfmlatrue = False break if isfmlatrue: return True return False
def clauses_imply_formula_cex(clauses, fmla): if clauses_imply_formula(clauses, fmla): return True return CounterExample( conjoin(clauses, negate_clauses(formula_to_clauses(fmla))))
""" tactic_name = convert_from_camel_case(tactic_cls.__name__) tactic_label = tactic_name.replace('_', ' ') # register the tactic with the ui ui_extensions_api.goal_node_actions.register(lambda goal: [( tactic_label, ui_extensions_api.apply_goal_tactic, tactic_name)]) # return unmodified return tactic_cls if __name__ == '__main__': from proof import AnalysisSession session = AnalysisSession('../src/ivy/test.ivy') set_context(session) a = get_big_action() s0 = arg_initial_node() s1 = arg_add_action_node(s0, a) arg_is_covered(s1, s0) arg_add_facts(s0, arg_get_fact(s0)) forward_image(arg_get_fact(s0), a) backward_image(arg_get_fact(s0), a) c = get_safety_property() g = goal_at_arg_node(negate_clauses(c), s1) d = get_diagram(g) x = refine_or_reverse(g)
def clauses_imply_formula_cex(clauses,fmla): if clauses_imply_formula(clauses,fmla): return True return CounterExample(conjoin(clauses,negate_clauses(formula_to_clauses(fmla))))
tactic_name = convert_from_camel_case(tactic_cls.__name__) tactic_label = tactic_name.replace("_", " ") # register the tactic with the ui ui_extensions_api.goal_node_actions.register( lambda goal: [(tactic_label, ui_extensions_api.apply_goal_tactic, tactic_name)] ) # return unmodified return tactic_cls if __name__ == "__main__": from proof import AnalysisSession session = AnalysisSession("../src/ivy/test.ivy") set_context(session) a = get_big_action() s0 = arg_initial_node() s1 = arg_add_action_node(s0, a) arg_is_covered(s1, s0) arg_add_facts(s0, arg_get_fact(s0)) forward_image(arg_get_fact(s0), a) backward_image(arg_get_fact(s0), a) c = get_safety_property() g = goal_at_arg_node(negate_clauses(c), s1) d = get_diagram(g) x = refine_or_reverse(g)
def apply(self): frames = ta._ivy_ag.states bad_states = negate_clauses(get_safety_property()) action = get_big_action() ta._ivy_ag.actions[repr(action)] = action init_frame = last_frame = frames[0] # TODO: test conjecture in initial with InterruptContext() as ic: while not ic.interrupted: # the property is true in all frames and all "clauses" are pushed # the goal stack is empty # check if we found an infuctive invariant for i in range(len(frames) - 1): if check_cover(frames[i + 1], frames[i]): return True # add new frame last_frame = ta.arg_add_action_node(last_frame, action, None) push_goal(goal_at_arg_node(bad_states, last_frame)) self.step(label='new frame') # push facts to last frame recalculate_facts(last_frame, ta.arg_get_conjuncts(arg_get_pred(last_frame))) while not ic.interrupted: current_goal = top_goal() if current_goal is None: # goal stack is empty break if remove_if_refuted(current_goal): continue if current_goal.node == init_frame: # no invariant print "No Invariant!" return False push_diagram(current_goal, False) dg = top_goal() if refine_or_reverse(dg, False): pass # dg is proved, # # propagate phase # for i in range(1, len(frames)): # facts_to_check = (set(arg_get_conjuncts(frames[i-1])) - # set(arg_get_conjuncts(frames[i]))) # recalculate_facts(frames[i], facts_to_check) else: # new goal pushed pass # propagate phase for i in range(1, len(frames)): facts_to_check = (set(arg_get_conjuncts(frames[i-1])) - set(arg_get_conjuncts(frames[i]))) recalculate_facts(frames[i], list(facts_to_check)) assert ic.interrupted print "UPDR Interrupted by SIGINT" return None
def interactive_updr(): frames = ta._ivy_ag.states if len(frames) != 1: raise InteractionError( "Interactive UPDR can only be started when the ARG " + "contains nothing but the initial state.") bad_states = negate_clauses(ta.get_safety_property()) action = ta.get_big_action() ta._ivy_ag.actions[repr(action)] = action init_frame = last_frame = frames[0] # TODO: test conjecture in initial while True: # the property is true in all frames and all "clauses" are pushed # the goal stack is empty # check if we found an infuctive invariant for i in range(len(frames) - 1): if t.check_cover(frames[i + 1], frames[i]): ta.step(msg="Inductive invariant found at frame {}".format(i), i=i) # return True # add new frame last_frame = ta.arg_add_action_node(last_frame, action, None) ta.push_goal(ta.goal_at_arg_node(bad_states, last_frame)) ta.step(msg="Added new frame") # push facts to last frame t.recalculate_facts(last_frame, ta.arg_get_conjuncts(ta.arg_get_pred(last_frame))) while True: current_goal = ta.top_goal() if current_goal is None: # goal stack is empty break if t.remove_if_refuted(current_goal): continue if current_goal.node == init_frame: # no invariant print "No Invariant!" # return False dg = ta.get_diagram(current_goal, False) options = OrderedDict() for c in simplify_clauses(dg.formula).conjuncts(): options[str(c)] = c user_selection = (yield UserSelectMultiple( options=options, title="Generalize Diagram", prompt="Choose which literals to take as the refutation goal", default=options.values())) assert user_selection is not None ug = ta.goal_at_arg_node(Clauses(list(user_selection)), current_goal.node) ta.push_goal(ug) ta.step(msg='Pushed user selected goal', ug=ug) goal = ta.top_goal() preds, action = ta.arg_get_preds_action(goal.node) assert action != 'join' assert len(preds) == 1 pred = preds[0] axioms = ta._ivy_interp.background_theory() theory = and_clauses( ivy_transrel.forward_image(pred.clauses, axioms, action.update(ta._ivy_interp, None)), axioms) goal_clauses = simplify_clauses(goal.formula) assert len(goal_clauses.defs) == 0 s = z3.Solver() s.add(clauses_to_z3(theory)) s.add(clauses_to_z3(goal_clauses)) is_sat = s.check() if is_sat == z3.sat: bi = ta.backward_image(goal.formula, action) x, y = False, ta.goal_at_arg_node(bi, pred) elif is_sat == z3.unsat: user_selection, user_is_sat = yield UserSelectCore( theory=theory, constrains=goal_clauses.fmlas, title="Refinement", prompt="Choose the literals to use", ) assert user_is_sat is False core = Clauses(user_selection) x, y = True, ivy_transrel.interp_from_unsat_core( goal_clauses, theory, core, None) else: assert False, is_sat t.custom_refine_or_reverse(goal, x, y, False) # propagate phase for i in range(1, len(frames)): facts_to_check = (set(ta.arg_get_conjuncts(frames[i - 1])) - set(ta.arg_get_conjuncts(frames[i]))) t.recalculate_facts(frames[i], list(facts_to_check))
def apply(self): frames = ta._ivy_ag.states bad_states = negate_clauses(get_safety_property()) action = get_big_action() ta._ivy_ag.actions[repr(action)] = action init_frame = last_frame = frames[0] # TODO: test conjecture in initial with InterruptContext() as ic: while not ic.interrupted: # the property is true in all frames and all "clauses" are pushed # the goal stack is empty # check if we found an infuctive invariant for i in range(len(frames) - 1): if check_cover(frames[i + 1], frames[i]): return True # add new frame last_frame = ta.arg_add_action_node(last_frame, action, None) push_goal(goal_at_arg_node(bad_states, last_frame)) self.step(label='new frame') # push facts to last frame recalculate_facts( last_frame, ta.arg_get_conjuncts(arg_get_pred(last_frame))) while not ic.interrupted: current_goal = top_goal() if current_goal is None: # goal stack is empty break if remove_if_refuted(current_goal): continue if current_goal.node == init_frame: # no invariant print "No Invariant!" return False push_diagram(current_goal, False) dg = top_goal() if refine_or_reverse(dg, False): pass # dg is proved, # # propagate phase # for i in range(1, len(frames)): # facts_to_check = (set(arg_get_conjuncts(frames[i-1])) - # set(arg_get_conjuncts(frames[i]))) # recalculate_facts(frames[i], facts_to_check) else: # new goal pushed pass # propagate phase for i in range(1, len(frames)): facts_to_check = (set(arg_get_conjuncts(frames[i - 1])) - set(arg_get_conjuncts(frames[i]))) recalculate_facts(frames[i], list(facts_to_check)) assert ic.interrupted print "UPDR Interrupted by SIGINT" return None
def interactive_updr(): frames = ta._ivy_ag.states if len(frames) != 1: raise InteractionError( "Interactive UPDR can only be started when the ARG " + "contains nothing but the initial state." ) bad_states = negate_clauses(ta.get_safety_property()) action = ta.get_big_action() ta._ivy_ag.actions[repr(action)] = action init_frame = last_frame = frames[0] # TODO: test conjecture in initial while True: # the property is true in all frames and all "clauses" are pushed # the goal stack is empty # check if we found an infuctive invariant for i in range(len(frames) - 1): if t.check_cover(frames[i + 1], frames[i]): ta.step(msg="Inductive invariant found at frame {}".format(i), i=i) # return True # add new frame last_frame = ta.arg_add_action_node(last_frame, action, None) ta.push_goal(ta.goal_at_arg_node(bad_states, last_frame)) ta.step(msg="Added new frame") # push facts to last frame t.recalculate_facts(last_frame, ta.arg_get_conjuncts(ta.arg_get_pred(last_frame))) while True: current_goal = ta.top_goal() if current_goal is None: # goal stack is empty break if t.remove_if_refuted(current_goal): continue if current_goal.node == init_frame: # no invariant print "No Invariant!" # return False dg = ta.get_diagram(current_goal, False) options = OrderedDict() for c in simplify_clauses(dg.formula).conjuncts(): options[str(c)] = c user_selection = ( yield UserSelectMultiple( options=options, title="Generalize Diagram", prompt="Choose which literals to take as the refutation goal", default=options.values(), ) ) assert user_selection is not None ug = ta.goal_at_arg_node(Clauses(list(user_selection)), current_goal.node) ta.push_goal(ug) ta.step(msg="Pushed user selected goal", ug=ug) goal = ta.top_goal() preds, action = ta.arg_get_preds_action(goal.node) assert action != "join" assert len(preds) == 1 pred = preds[0] axioms = ta._ivy_interp.background_theory() theory = and_clauses( ivy_transrel.forward_image(pred.clauses, axioms, action.update(ta._ivy_interp, None)), axioms ) goal_clauses = simplify_clauses(goal.formula) assert len(goal_clauses.defs) == 0 s = z3.Solver() s.add(clauses_to_z3(theory)) s.add(clauses_to_z3(goal_clauses)) is_sat = s.check() if is_sat == z3.sat: bi = ta.backward_image(goal.formula, action) x, y = False, ta.goal_at_arg_node(bi, pred) elif is_sat == z3.unsat: user_selection, user_is_sat = yield UserSelectCore( theory=theory, constrains=goal_clauses.fmlas, title="Refinement", prompt="Choose the literals to use", ) assert user_is_sat is False core = Clauses(user_selection) x, y = True, ivy_transrel.interp_from_unsat_core(goal_clauses, theory, core, None) else: assert False, is_sat t.custom_refine_or_reverse(goal, x, y, False) # propagate phase for i in range(1, len(frames)): facts_to_check = set(ta.arg_get_conjuncts(frames[i - 1])) - set(ta.arg_get_conjuncts(frames[i])) t.recalculate_facts(frames[i], list(facts_to_check))