def __init__(self, solvers_set, environment, logic, **options):
"""Creates a portfolio using the specified solvers.
Solver_set is an iterable. Elements of solver_set can be
1) a name of a solver
2) a tuple containing a name of a solver and dict of options
E.g.,
Portfolio(["msat", "z3"], incremental=True)
or
Porfolio([("msat", {"random_seed": 1}), ("msat", {"random_seed": 2})],
incremental=True)
Options specified in the Portfolio are shared among all
solvers, e.g., in the first example all solvers will receive
the option 'incremental=True'.
One process will be used for each of the solvers.
"""
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.solvers = []
self._process_solver_set(solvers_set)
# Check that the names are valid ?
all_solvers = set(self.environment.factory.all_solvers(logic=logic))
not_found = set(s for s, _ in self.solvers) - all_solvers
if len(not_found) != 0:
raise ValueError("Cannot find solvers %s" % not_found)
# After Solving, we only keep the solver that finished first.
# We can extract models from the solver, unsat cores, etc
self._ext_solver = None # Existing solver Process
self._ctrl_pipe = None # Ctrl Pipe to the existing solver
def __init__(self, solvers_set, environment, logic, **options):
"""Creates a portfolio using the specified solvers.
Solver_set is an iterable. Elements of solver_set can be
1) a name of a solver
2) a tuple containing a name of a solver and dict of options
E.g.,
Portfolio(["msat", "z3"], incremental=True)
or
Porfolio([("msat", {"random_seed": 1}), ("msat", {"random_seed": 2})],
incremental=True)
Options specified in the Portfolio are shared among all
solvers, e.g., in the first example all solvers will receive
the option 'incremental=True'.
One process will be used for each of the solvers.
"""
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.solvers = []
self._process_solver_set(solvers_set)
# Check that the names are valid ?
all_solvers = set(self.environment.factory.all_solvers())
not_found = set(s for s,_ in self.solvers) - all_solvers
if len(not_found) != 0:
raise ValueError("Cannot find solvers %s" % not_found)
# After Solving, we only keep the solver that finished first.
# We can extract models from the solver, unsat cores, etc
self._ext_solver = None # Existing solver Process
self._ctrl_pipe = None # Ctrl Pipe to the existing solver
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.solver = self._create_solver()
self.options(self)
self.mgr = environment.formula_manager
self.converter = SwitchConverter(environment, self.solver, self.mgr)
def __init__(self, environment, logic, user_options):
IncrementalTrackingSolver.__init__(self, environment=environment, logic=logic, user_options=user_options)
self.btor = boolector.Boolector()
self.btor.Set_opt("incremental", 1)
self.btor.Set_opt("model_gen", 1)
self.converter = BTORConverter(environment, self.btor)
self.mgr = environment.formula_manager
self.declarations = {}
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.btor = boolector.Boolector()
self.options(self)
self.converter = BTORConverter(environment, self.btor)
self.mgr = environment.formula_manager
self.declarations = {}
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.z3 = z3.SolverFor(str(logic))
self.options(self)
self.declarations = set()
self.converter = Z3Converter(environment, z3_ctx=self.z3.ctx)
self.mgr = environment.formula_manager
self._name_cnt = 0
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.z3 = z3.SolverFor(str(logic))
self.options(self)
self.declarations = set()
self.converter = Z3Converter(environment, z3_ctx=self.z3.ctx)
self.mgr = environment.formula_manager
self._name_cnt = 0
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.btor = boolector.Boolector()
self.options(self)
self.converter = BTORConverter(environment, self.btor)
self.mgr = environment.formula_manager
self.declarations = {}
return
# EOC BoolectorOptions
pass
def __init__(self, environment, logic, user_options=None, debugFile=None):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
user_options=user_options)
self.msat_config = mathsat.msat_create_default_config(str(logic))
self._prepare_config(self.options, debugFile)
self.msat_env = MSatEnv(self.msat_config)
mathsat.msat_destroy_config(self.msat_config)
self.realType = mathsat.msat_get_rational_type(self.msat_env())
self.intType = mathsat.msat_get_integer_type(self.msat_env())
self.boolType = mathsat.msat_get_bool_type(self.msat_env())
self.mgr = environment.formula_manager
self.converter = MSatConverter(environment, self.msat_env)
def __init__(self, environment, logic, user_options=None, debugFile=None):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
user_options=user_options)
self.msat_config = mathsat.msat_create_default_config(str(logic))
self._prepare_config(self.options, debugFile)
self.msat_env = mathsat.msat_create_env(self.msat_config)
self.realType = mathsat.msat_get_rational_type(self.msat_env)
self.intType = mathsat.msat_get_integer_type(self.msat_env)
self.boolType = mathsat.msat_get_bool_type(self.msat_env)
self.mgr = environment.formula_manager
self.converter = MSatConverter(environment, self.msat_env)
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.btor = boolector.Boolector()
self.btor.Set_opt("model_gen", 0)
# Disabling Incremental usage is not allowed.
# This needs to be set to 1
self.btor.Set_opt("incremental", 1)
if self.options.generate_models:
self.btor.Set_opt("model_gen", 1)
self.converter = BTORConverter(environment, self.btor)
self.mgr = environment.formula_manager
self.declarations = {}
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.btor = boolector.Boolector()
self.btor.Set_opt("model_gen", 0)
# Disabling Incremental usage is not allowed.
# This needs to be set to 1
self.btor.Set_opt("incremental", 1)
if self.options.generate_models:
self.btor.Set_opt("model_gen", 1)
self.converter = BTORConverter(environment, self.btor)
self.mgr = environment.formula_manager
self.declarations = {}
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
# LBYL to avoid a possible segmentation fault caused by z3.SolverFor
# See issue #465 (https://github.com/pysmt/pysmt/issues/465)
if str(logic) in Z3Solver.SOLVERFOR_LOGIC_NAMES:
self.z3 = z3.SolverFor(str(logic))
else:
self.z3 = z3.Solver()
self.options(self)
self.declarations = set()
self.converter = Z3Converter(environment, z3_ctx=self.z3.ctx)
self.mgr = environment.formula_manager
self._name_cnt = 0
return
def __init__(self, environment, logic, user_options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
user_options=user_options)
# Here we could use:
# self.z3 = z3.SolverFor(str(logic))
# But it seems to have problems with quantified formulae
self.z3 = z3.Solver()
if self.options.unsat_cores_mode is not None:
self.z3.set(unsat_core=True)
self.declarations = set()
self.converter = Z3Converter(environment)
self.mgr = environment.formula_manager
self._name_cnt = 0
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
try:
self.z3 = z3.SolverFor(str(logic))
except z3.Z3Exception:
self.z3 = z3.Solver()
except z3.z3types.Z3Exception:
self.z3 = z3.Solver()
self.options(self)
self.declarations = set()
self.converter = Z3Converter(environment, z3_ctx=self.z3.ctx)
self.mgr = environment.formula_manager
self._name_cnt = 0
self.qf = False
return
def __init__(self, environment, logic, **options):
IncrementalTrackingSolver.__init__(self,
environment=environment,
logic=logic,
**options)
self.declarations = set()
self.yices_config = yicespy.yices_new_config()
if yicespy.yices_default_config_for_logic(self.yices_config,
yices_logic(logic)) != 0:
warn("Error setting config for logic %s" % logic)
self.options(self)
self.yices = yicespy.yices_new_context(self.yices_config)
self.options.set_params(self)
yicespy.yices_free_config(self.yices_config)
self.converter = YicesConverter(environment)
self.mgr = environment.formula_manager
self.model = None
self.failed_pushes = 0
self.yices_assumptions = []
self.unsat_core = None
self.qf = False
return
