def test_most_generic(self):
self.assertTrue(QF_LIA < LIA)
self.assertTrue(LIA < UFLIRA)
self.assertTrue(UFLIRA > QF_LIA)
self.assertTrue(UFLIRA >= UFLIRA)
self.assertFalse(LRA >= LIA)
self.assertFalse(LRA <= LIA)
mgl = most_generic_logic([QF_LIA, LIA, LRA, UFLIRA])
self.assertEqual(mgl, UFLIRA)
self.assertFalse(QF_BV >= QF_UFLIRA)
self.assertFalse(QF_BV <= QF_UFLIRA)
with self.assertRaises(NoLogicAvailableError):
most_generic_logic(PYSMT_LOGICS)
def test_most_generic(self):
self.assertTrue(QF_LIA < LIA)
self.assertTrue(LIA < UFLIRA)
self.assertTrue(UFLIRA > QF_LIA)
self.assertTrue(UFLIRA >= UFLIRA)
self.assertFalse(LRA >= LIA)
self.assertFalse(LRA <= LIA)
mgl = most_generic_logic([QF_LIA, LIA, LRA, UFLIRA])
self.assertEqual(mgl, UFLIRA)
self.assertFalse(QF_BV >= QF_UFLIRA)
self.assertFalse(QF_BV <= QF_UFLIRA)
self.assertTrue(NRA > LRA)
with self.assertRaises(NoLogicAvailableError):
most_generic_logic(PYSMT_LOGICS)
def Solver(name: str, logic: tp.Optional[logics.Logic] = None) -> SolverT:
'''
Convience function for building a pysmt solver object with a switch backend.
Similar to `pysmt.shortcuts.Solver`.
'''
try:
cls = SWITCH_SOLVERS[name]
except KeyError:
raise NoSolverAvailableError(
f"Solver '{name}' is not available") from None
if isinstance(logic, str):
logic = logics.convert_logic_from_string(logic)
elif logic is None:
# Try to use the most general logic supported
try:
logic = logics.most_generic_logic(cls.LOGICS)
except NoLogicAvailableError:
# supported logics do not have a single "upper bound"
# Check for some reasonable ones
if logics.QF_UFLIRA in cls.LOGICS:
logic = logics.QF_UFLIRA
elif logics.QF_AUFBV in cls.LOGICS:
logic = logics.QF_AUFBV
else:
# use the first one
logic = cls.LOGICS[0]
return cls(environment=get_env(), logic=logic)
def test_most_generic(self):
self.assertTrue(QF_LIA < LIA)
self.assertTrue(LIA < UFLIRA)
self.assertTrue(UFLIRA > QF_LIA)
self.assertTrue(UFLIRA >= UFLIRA)
self.assertFalse(LRA >= LIA)
self.assertFalse(LRA <= LIA)
mgl = most_generic_logic([QF_LIA, LIA, LRA, UFLIRA])
self.assertEqual(mgl, UFLIRA)
self.assertFalse(QF_BV >= QF_UFLIRA)
self.assertFalse(QF_BV <= QF_UFLIRA)
self.assertTrue(NRA > LRA)
self.assertTrue(QF_BOOL < QF_IDL)
with self.assertRaises(NoLogicAvailableError):
most_generic_logic(PYSMT_LOGICS)
t = Theory(arrays=True, arrays_const=True, integer_arithmetic=True)
self.assertIsNotNone(t)
def test_most_generic(self):
self.assertTrue(QF_LIA < LIA)
self.assertTrue(LIA < UFLIRA)
self.assertTrue(UFLIRA > QF_LIA)
self.assertTrue(UFLIRA >= UFLIRA)
self.assertFalse(LRA >= LIA)
self.assertFalse(LRA <= LIA)
mgl = most_generic_logic([QF_LIA, LIA, LRA, UFLIRA])
self.assertEqual(mgl, UFLIRA)
self.assertFalse(QF_BV >= QF_UFLIRA)
self.assertFalse(QF_BV <= QF_UFLIRA)
self.assertTrue(NRA > LRA)
with self.assertRaises(NoLogicAvailableError):
most_generic_logic(PYSMT_LOGICS)
t = Theory(arrays=True,
arrays_const=True,
integer_arithmetic=True)
self.assertIsNotNone(t)
def _get_solver_class(self,
solver_list,
solver_type,
preference_list,
default_logic,
name=None,
logic=None):
if len(solver_list) == 0:
raise NoSolverAvailableError("No %s is available" % solver_type)
logic = convert_logic_from_string(logic)
if name is not None:
if name not in solver_list:
raise NoSolverAvailableError("%s '%s' is not available" % \
(solver_type, name))
if logic is not None and \
name not in self._filter_solvers(solver_list, logic=logic):
raise NoSolverAvailableError(
"%s '%s' does not support logic %s" %
(solver_type, name, logic))
SolverClass = solver_list[name]
if logic is None:
try:
logic = most_generic_logic(SolverClass.LOGICS)
except NoLogicAvailableError:
if default_logic in SolverClass.LOGICS:
logic = default_logic
else:
raise NoLogicAvailableError(
"Cannot automatically select a logic")
closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
return SolverClass, closer_logic
if logic is None:
logic = default_logic
solvers = self._filter_solvers(solver_list, logic=logic)
if solvers is not None and len(solvers) > 0:
# Pick the first solver based on preference list
SolverClass = self._pick_favorite(preference_list, solver_list,
solvers)
closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
return SolverClass, closer_logic
else:
raise NoSolverAvailableError("No %s is available for logic %s" %
(solver_type, logic))
def _get_solver_class(self, solver_list, solver_type, preference_list,
default_logic, name=None, logic=None):
if len(solver_list) == 0:
raise NoSolverAvailableError("No %s is available" % solver_type)
logic = convert_logic_from_string(logic)
if name is not None:
if name not in solver_list:
raise NoSolverAvailableError("%s '%s' is not available" % \
(solver_type, name))
if logic is not None and \
name not in self._filter_solvers(solver_list, logic=logic):
raise NoSolverAvailableError("%s '%s' does not support logic %s"%
(solver_type, name, logic))
SolverClass = solver_list[name]
if logic is None:
try:
logic = most_generic_logic(SolverClass.LOGICS)
except NoLogicAvailableError:
if default_logic in SolverClass.LOGICS:
logic = default_logic
else:
raise NoLogicAvailableError("Cannot automatically select a logic")
closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
return SolverClass, closer_logic
if logic is None:
logic = default_logic
solvers = self._filter_solvers(solver_list, logic=logic)
if solvers is not None and len(solvers) > 0:
# Pick the first solver based on preference list
SolverClass = self._pick_favorite(preference_list, solver_list, solvers)
closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
return SolverClass, closer_logic
else:
raise NoSolverAvailableError("No %s is available for logic %s" %
(solver_type, logic))
def get_solver(self, quantified=False, name=None, logic=None):
assert quantified is False or logic is None, \
"Cannot specify both quantified and logic."
if quantified is True:
logic = self.default_logic.get_quantified_version
if name is not None:
if name in self._all_solvers:
if logic is None:
SolverClass = self._all_solvers[name]
logic = most_generic_logic(SolverClass.LOGICS)
else:
if name in self.all_solvers(logic=logic):
SolverClass = self._all_solvers[name]
else:
raise NoSolverAvailableError("Solver '%s' does not" \
" support logic %s" %
(name, logic))
closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
return SolverClass(environment=self.environment,
logic=closer_logic,
options=None)
else:
raise NoSolverAvailableError("Solver %s is not available" %
name)
if logic is None:
logic = self.default_logic
solvers = self.all_solvers(logic=logic)
if solvers is not None and len(solvers) > 0:
# Pick the first solver based on preference list
SolverClass = self.pick_favorite_solver(solvers)
closer_logic = get_closer_logic(SolverClass.LOGICS, logic)
return SolverClass(environment=self.environment,
logic=closer_logic,
options=None)
else:
raise NoSolverAvailableError("No solver is available for logic %s" %\
logic)
