def test_substitute_memoization(self): a = Symbol("A", BOOL) b = Symbol("B", BOOL) f = And(a, b) g = f.substitute({a:Bool(True)}) h = f.substitute({a:Bool(False)}) self.assertNotEqual(h, g)
def test_get_implicant_unsat(self): varA = Symbol("A", BOOL) varB = Symbol("B", BOOL) f = And(varA, Not(varB)) g = f.substitute({varB: varA}) for solver in get_env().factory.all_solvers(logic=QF_BOOL): res = get_implicant(g, solver_name=solver) self.assertIsNone(res, "Formula was expected to be UNSAT")
def test_get_implicant_unsat(self): varA = Symbol("A", BOOL) varB = Symbol("B", BOOL) f = And(varA, Not(varB)) g = f.substitute({varB:varA}) for solver in get_env().factory.all_solvers(logic=QF_BOOL): res = get_implicant(g, solver_name=solver) self.assertIsNone(res, "Formula was expected to be UNSAT")
def test_is_sat(self): varA = Symbol("A", BOOL) varB = Symbol("B", BOOL) f = And(varA, Not(varB)) g = f.substitute({varB:varA}) self.assertUnsat(g, logic=QF_BOOL, msg="Formula was expected to be UNSAT") for solver in get_env().factory.all_solvers(): self.assertUnsat(g, solver_name=solver, msg="Formula was expected to be UNSAT")
def test_create_and_solve(self): solver = Solver(logic=QF_BOOL) varA = Symbol("A", BOOL) varB = Symbol("B", BOOL) f = And(varA, Not(varB)) g = f.substitute({varB: varA}) solver.add_assertion(g) res = solver.solve() self.assertFalse(res, "Formula was expected to be UNSAT") h = And(g, Bool(False)) simp_h = h.simplify() self.assertEqual(simp_h, Bool(False))
def test_create_and_solve(self): solver = Solver(logic=QF_BOOL) varA = Symbol("A", BOOL) varB = Symbol("B", BOOL) f = And(varA, Not(varB)) g = f.substitute({varB:varA}) solver.add_assertion(g) res = solver.solve() self.assertFalse(res, "Formula was expected to be UNSAT") h = And(g, Bool(False)) simp_h = h.simplify() self.assertEqual(simp_h, Bool(False))
# Checking satisfiability of a formula. # # This example shows: # 1. How to build a formula # 2. How to perform substitution # 3. Printing # 4. Satisfiability checking from pysmt.shortcuts import Symbol, And, Not, is_sat varA = Symbol("A") # Default type is Boolean varB = Symbol("B") f = And([varA, Not(varB)]) g = f.substitute({varB:varA}) res = is_sat(f) assert res # SAT print("f := %s is SAT? %s" % (f, res)) res = is_sat(g) print("g := %s is SAT? %s" % (g, res)) assert not res # UNSAT
def process_prospectives(self): print("\nProcessing prospectives") for nv, (action, cond) in self.nexinfer.items(): print("\tprocessing %s in %s" % (nv, action)) action_suffix = self.action2suffix[action] action_nvars = And(action_suffix).get_free_variables() action_nvars = action_nvars.intersection( self.system._nex2pre.keys()) action_pvars = set() for n in action_nvars: action_pvars.add(self.system._nex2pre[n]) action_prefix = self.action2prefix[action] concs_global = [] concs = [] for c in action_prefix: cvars = c.get_free_variables() common = cvars.intersection(action_pvars) if len(common) == 0: statevars = cvars.intersection(self.system._states) statevars = statevars.difference(self.system._globals) if len(statevars) == 0: concs_global.append(c) else: concs.append(c) if (len(concs) + len(concs_global)) == 0: print("\t\tskipping %s since no static precondition found" % nv) continue qvars = set() if cond.is_forall(): cqvars = cond.quantifier_vars() for v in cqvars: qvars.add(v) cond = cond.arg(0) if not (cond.is_iff() or cond.is_equals()): continue lhs = cond.arg(0) rhs = cond.arg(1) lvars = lhs.get_free_variables() rvars = rhs.get_free_variables() if nv in rvars: lhs, rhs = rhs, lhs lvars, rvars = rvars, lvars if nv in rvars: continue ldvars = lvars.difference(qvars) if len(ldvars) != 1: continue ldvar = next(iter(ldvars)) if nv != ldvar: continue if len(qvars) != 0: if not lhs.is_function_application(): continue nsym = lhs.function_name() if nv != nsym: continue if len(self.action2def) != 0: rhs = rhs.substitute(self.action2def[action]) rconds = [] rval = self.process_assign(rhs, rconds) premise = [] qsubs = {} for c in rconds: if c.is_iff() or c.is_equals(): lc = c.arg(0) rc = c.arg(1) if rc.is_symbol(): if rc in qvars: lc, rc = rc, lc if lc.is_symbol(): if lc in qvars: if rc in self.system._others: qsubs[rc] = lc continue premise.append(c) eq = EqualsOrIff(lhs, rval) premise.insert(0, eq) prem = And(premise) qsubs[nv] = self.system._nex2pre[nv] prem = prem.substitute(qsubs) ivars = prem.get_free_variables() ivars = ivars.intersection(self.system._others) if len(ivars) != 0: for v in ivars: vname = "Q" + str(v) vname = vname.replace(":", "") vnew = Symbol(vname, v.symbol_type()) qsubs[v] = vnew qvars.add(vnew) prem = prem.substitute(qsubs) if len(concs_global) != 0: concs.append(None) for conc in concs: if conc == None: conc = And(concs_global) else: if len(concs_global) != 0: conc = And(conc, And(concs_global)) conc = conc.substitute(qsubs) ivars = conc.get_free_variables() ivars = ivars.intersection(self.system._others) evars = [] if len(ivars) != 0: esubs = {} for v in ivars: vname = "Q" + str(v) vname = vname.replace(":", "") vnew = Symbol(vname, v.symbol_type()) esubs[v] = vnew evars.append(vnew) conc = conc.substitute(esubs) # conc = Exists(evars, conc) # evars = [] # print("evars ", evars) # print("conc ", conc) inference = Implies(prem, conc) qvars2 = [] # if len(qvars) != 0: # for u in qvars: # ut = u.symbol_type() # for e in evars: # et = e.symbol_type() # if not self.strat.allowed_arc(ut, et): # qvars2.append(u) uqvars = qvars.difference(qvars2) # for u in qvars2: # if u in qvars: # qvars.remove(u) # print("qvars2 ", qvars2) # print("uqvars ", uqvars) if len(qvars2) != 0: inference = ForAll(qvars2, inference) if len(evars) != 0: inference = Exists(evars, inference) if len(uqvars) != 0: inference = ForAll(uqvars, inference) iname = "syntax" + str(len(self.system._infers) + 1) self.system._infers[inference] = iname print("\t\tinferred %s: %s" % (iname, inference))
# Checking satisfiability of a formula. # # This example shows: # 1. How to build a formula # 2. How to perform substitution # 3. Printing # 4. Satisfiability checking from pysmt.shortcuts import Symbol, And, Not, is_sat varA = Symbol("A") # Default type is Boolean varB = Symbol("B") f = And([varA, Not(varB)]) g = f.substitute({varB: varA}) res = is_sat(f) assert res # SAT print("f := %s is SAT? %s" % (f, res)) res = is_sat(g) print("g := %s is SAT? %s" % (g, res)) assert not res # UNSAT