Z3
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Public Member Functions | Data Fields
Solver Class Reference
+ Inheritance diagram for Solver:

Public Member Functions

def __init__
 
def __del__
 
def set
 
def push
 
def pop
 
def reset
 
def assert_exprs
 
def add
 
def append
 
def insert
 
def assert_and_track
 
def check
 
def model
 
def unsat_core
 
def proof
 
def assertions
 
def statistics
 
def reason_unknown
 
def help
 
def param_descrs
 
def __repr__
 
def sexpr
 
def to_smt2
 
- Public Member Functions inherited from Z3PPObject
def use_pp
 

Data Fields

 ctx
 
 solver
 

Detailed Description

Solver API provides methods for implementing the main SMT 2.0 commands: push, pop, check, get-model, etc.

Definition at line 5775 of file z3py.py.

Constructor & Destructor Documentation

def __init__ (   self,
  solver = None,
  ctx = None 
)

Definition at line 5778 of file z3py.py.

5779  def __init__(self, solver=None, ctx=None):
5780  assert solver == None or ctx != None
5781  self.ctx = _get_ctx(ctx)
5782  self.solver = None
5783  if solver == None:
5784  self.solver = Z3_mk_solver(self.ctx.ref())
5785  else:
5786  self.solver = solver
5787  Z3_solver_inc_ref(self.ctx.ref(), self.solver)
Z3_solver Z3_API Z3_mk_solver(Z3_context c)
Create a new (incremental) solver. This solver also uses a set of builtin tactics for handling the fi...
void Z3_API Z3_solver_inc_ref(Z3_context c, Z3_solver s)
Increment the reference counter of the given solver.
def __init__
Definition: z3py.py:5778
def __del__ (   self)

Definition at line 5788 of file z3py.py.

5789  def __del__(self):
5790  if self.solver != None:
5791  Z3_solver_dec_ref(self.ctx.ref(), self.solver)
def __del__
Definition: z3py.py:5788
void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s)
Decrement the reference counter of the given solver.

Member Function Documentation

def __repr__ (   self)
Return a formatted string with all added constraints.

Definition at line 6080 of file z3py.py.

6081  def __repr__(self):
6082  """Return a formatted string with all added constraints."""
6083  return obj_to_string(self)
def __repr__
Definition: z3py.py:6080
def add (   self,
  args 
)
Assert constraints into the solver.

>>> x = Int('x')
>>> s = Solver()
>>> s.add(x > 0, x < 2)
>>> s
[x > 0, x < 2]

Definition at line 5881 of file z3py.py.

5882  def add(self, *args):
5883  """Assert constraints into the solver.
5884 
5885  >>> x = Int('x')
5886  >>> s = Solver()
5887  >>> s.add(x > 0, x < 2)
5888  >>> s
5889  [x > 0, x < 2]
5890  """
5891  self.assert_exprs(*args)
def assert_exprs
Definition: z3py.py:5862
def add
Definition: z3py.py:5881
def append (   self,
  args 
)
Assert constraints into the solver.

>>> x = Int('x')
>>> s = Solver()
>>> s.append(x > 0, x < 2)
>>> s
[x > 0, x < 2]

Definition at line 5892 of file z3py.py.

5893  def append(self, *args):
5894  """Assert constraints into the solver.
5895 
5896  >>> x = Int('x')
5897  >>> s = Solver()
5898  >>> s.append(x > 0, x < 2)
5899  >>> s
5900  [x > 0, x < 2]
5901  """
5902  self.assert_exprs(*args)
def assert_exprs
Definition: z3py.py:5862
def append
Definition: z3py.py:5892
def assert_and_track (   self,
  a,
  p 
)
Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.

If `p` is a string, it will be automatically converted into a Boolean constant.

>>> x = Int('x')
>>> p3 = Bool('p3')
>>> s = Solver()
>>> s.set(unsat_core=True)
>>> s.assert_and_track(x > 0,  'p1')
>>> s.assert_and_track(x != 1, 'p2')
>>> s.assert_and_track(x < 0,  p3)
>>> print(s.check())
unsat
>>> c = s.unsat_core()
>>> len(c)
2
>>> Bool('p1') in c
True
>>> Bool('p2') in c
False
>>> p3 in c
True

Definition at line 5914 of file z3py.py.

5915  def assert_and_track(self, a, p):
5916  """Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.
5917 
5918  If `p` is a string, it will be automatically converted into a Boolean constant.
5919 
5920  >>> x = Int('x')
5921  >>> p3 = Bool('p3')
5922  >>> s = Solver()
5923  >>> s.set(unsat_core=True)
5924  >>> s.assert_and_track(x > 0, 'p1')
5925  >>> s.assert_and_track(x != 1, 'p2')
5926  >>> s.assert_and_track(x < 0, p3)
5927  >>> print(s.check())
5928  unsat
5929  >>> c = s.unsat_core()
5930  >>> len(c)
5931  2
5932  >>> Bool('p1') in c
5933  True
5934  >>> Bool('p2') in c
5935  False
5936  >>> p3 in c
5937  True
5938  """
5939  if isinstance(p, str):
5940  p = Bool(p, self.ctx)
5941  _z3_assert(isinstance(a, BoolRef), "Boolean expression expected")
5942  _z3_assert(isinstance(p, BoolRef) and is_const(p), "Boolean expression expected")
5943  Z3_solver_assert_and_track(self.ctx.ref(), self.solver, a.as_ast(), p.as_ast())
def is_const
Definition: z3py.py:1006
void Z3_API Z3_solver_assert_and_track(Z3_context c, Z3_solver s, Z3_ast a, Z3_ast p)
Assert a constraint a into the solver, and track it (in the unsat) core using the Boolean constant p...
def Bool
Definition: z3py.py:1381
def assert_and_track
Definition: z3py.py:5914
def assert_exprs (   self,
  args 
)
Assert constraints into the solver.

>>> x = Int('x')
>>> s = Solver()
>>> s.assert_exprs(x > 0, x < 2)
>>> s
[x > 0, x < 2]

Definition at line 5862 of file z3py.py.

Referenced by Solver.add(), Fixedpoint.add(), Optimize.add(), Solver.append(), Fixedpoint.append(), and Fixedpoint.insert().

5863  def assert_exprs(self, *args):
5864  """Assert constraints into the solver.
5865 
5866  >>> x = Int('x')
5867  >>> s = Solver()
5868  >>> s.assert_exprs(x > 0, x < 2)
5869  >>> s
5870  [x > 0, x < 2]
5871  """
5872  args = _get_args(args)
5873  s = BoolSort(self.ctx)
5874  for arg in args:
5875  if isinstance(arg, Goal) or isinstance(arg, AstVector):
5876  for f in arg:
5877  Z3_solver_assert(self.ctx.ref(), self.solver, f.as_ast())
5878  else:
5879  arg = s.cast(arg)
5880  Z3_solver_assert(self.ctx.ref(), self.solver, arg.as_ast())
def BoolSort
Definition: z3py.py:1346
void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a)
Assert a constraint into the solver.
def assert_exprs
Definition: z3py.py:5862
def assertions (   self)
Return an AST vector containing all added constraints.

>>> s = Solver()
>>> s.assertions()
[]
>>> a = Int('a')
>>> s.add(a > 0)
>>> s.add(a < 10)
>>> s.assertions()
[a > 0, a < 10]

Definition at line 6027 of file z3py.py.

Referenced by Solver.to_smt2().

6028  def assertions(self):
6029  """Return an AST vector containing all added constraints.
6030 
6031  >>> s = Solver()
6032  >>> s.assertions()
6033  []
6034  >>> a = Int('a')
6035  >>> s.add(a > 0)
6036  >>> s.add(a < 10)
6037  >>> s.assertions()
6038  [a > 0, a < 10]
6039  """
6040  return AstVector(Z3_solver_get_assertions(self.ctx.ref(), self.solver), self.ctx)
Z3_ast_vector Z3_API Z3_solver_get_assertions(Z3_context c, Z3_solver s)
Return the set of asserted formulas as a goal object.
def assertions
Definition: z3py.py:6027
def check (   self,
  assumptions 
)
Check whether the assertions in the given solver plus the optional assumptions are consistent or not.

>>> x = Int('x')
>>> s = Solver()
>>> s.check()
sat
>>> s.add(x > 0, x < 2)
>>> s.check()
sat
>>> s.model()
[x = 1]
>>> s.add(x < 1)
>>> s.check()
unsat
>>> s.reset()
>>> s.add(2**x == 4)
>>> s.check()
unknown

Definition at line 5944 of file z3py.py.

Referenced by Solver.model(), Solver.proof(), Solver.reason_unknown(), Solver.statistics(), and Solver.unsat_core().

5945  def check(self, *assumptions):
5946  """Check whether the assertions in the given solver plus the optional assumptions are consistent or not.
5947 
5948  >>> x = Int('x')
5949  >>> s = Solver()
5950  >>> s.check()
5951  sat
5952  >>> s.add(x > 0, x < 2)
5953  >>> s.check()
5954  sat
5955  >>> s.model()
5956  [x = 1]
5957  >>> s.add(x < 1)
5958  >>> s.check()
5959  unsat
5960  >>> s.reset()
5961  >>> s.add(2**x == 4)
5962  >>> s.check()
5963  unknown
5964  """
5965  assumptions = _get_args(assumptions)
5966  num = len(assumptions)
5967  _assumptions = (Ast * num)()
5968  for i in range(num):
5969  _assumptions[i] = assumptions[i].as_ast()
5970  r = Z3_solver_check_assumptions(self.ctx.ref(), self.solver, num, _assumptions)
5971  return CheckSatResult(r)
Z3_lbool Z3_API Z3_solver_check_assumptions(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[])
Check whether the assertions in the given solver and optional assumptions are consistent or not...
def check
Definition: z3py.py:5944
def help (   self)
Display a string describing all available options.

Definition at line 6072 of file z3py.py.

Referenced by Solver.set().

6073  def help(self):
6074  """Display a string describing all available options."""
6075  print(Z3_solver_get_help(self.ctx.ref(), self.solver))
def help
Definition: z3py.py:6072
Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s)
Return a string describing all solver available parameters.
def insert (   self,
  args 
)
Assert constraints into the solver.

>>> x = Int('x')
>>> s = Solver()
>>> s.insert(x > 0, x < 2)
>>> s
[x > 0, x < 2]

Definition at line 5903 of file z3py.py.

5904  def insert(self, *args):
5905  """Assert constraints into the solver.
5906 
5907  >>> x = Int('x')
5908  >>> s = Solver()
5909  >>> s.insert(x > 0, x < 2)
5910  >>> s
5911  [x > 0, x < 2]
5912  """
5913  self.assert_exprs(*args)
def insert
Definition: z3py.py:5903
def assert_exprs
Definition: z3py.py:5862
def model (   self)
Return a model for the last `check()`. 

This function raises an exception if 
a model is not available (e.g., last `check()` returned unsat).

>>> s = Solver()
>>> a = Int('a')
>>> s.add(a + 2 == 0)
>>> s.check()
sat
>>> s.model()
[a = -2]

Definition at line 5972 of file z3py.py.

5973  def model(self):
5974  """Return a model for the last `check()`.
5975 
5976  This function raises an exception if
5977  a model is not available (e.g., last `check()` returned unsat).
5978 
5979  >>> s = Solver()
5980  >>> a = Int('a')
5981  >>> s.add(a + 2 == 0)
5982  >>> s.check()
5983  sat
5984  >>> s.model()
5985  [a = -2]
5986  """
5987  try:
5988  return ModelRef(Z3_solver_get_model(self.ctx.ref(), self.solver), self.ctx)
5989  except Z3Exception:
5990  raise Z3Exception("model is not available")
def model
Definition: z3py.py:5972
Z3_model Z3_API Z3_solver_get_model(Z3_context c, Z3_solver s)
Retrieve the model for the last Z3_solver_check or Z3_solver_check_assumptions.
def param_descrs (   self)
Return the parameter description set.

Definition at line 6076 of file z3py.py.

6077  def param_descrs(self):
6078  """Return the parameter description set."""
6079  return ParamDescrsRef(Z3_solver_get_param_descrs(self.ctx.ref(), self.solver), self.ctx)
def param_descrs
Definition: z3py.py:6076
Z3_param_descrs Z3_API Z3_solver_get_param_descrs(Z3_context c, Z3_solver s)
Return the parameter description set for the given solver object.
def pop (   self,
  num = 1 
)
Backtrack \c num backtracking points.

>>> x = Int('x')
>>> s = Solver()
>>> s.add(x > 0)
>>> s
[x > 0]
>>> s.push()
>>> s.add(x < 1)
>>> s
[x > 0, x < 1]
>>> s.check()
unsat
>>> s.pop()
>>> s.check()
sat
>>> s
[x > 0]

Definition at line 5826 of file z3py.py.

5827  def pop(self, num=1):
5828  """Backtrack \c num backtracking points.
5829 
5830  >>> x = Int('x')
5831  >>> s = Solver()
5832  >>> s.add(x > 0)
5833  >>> s
5834  [x > 0]
5835  >>> s.push()
5836  >>> s.add(x < 1)
5837  >>> s
5838  [x > 0, x < 1]
5839  >>> s.check()
5840  unsat
5841  >>> s.pop()
5842  >>> s.check()
5843  sat
5844  >>> s
5845  [x > 0]
5846  """
5847  Z3_solver_pop(self.ctx.ref(), self.solver, num)
void Z3_API Z3_solver_pop(Z3_context c, Z3_solver s, unsigned n)
Backtrack n backtracking points.
def pop
Definition: z3py.py:5826
def proof (   self)
Return a proof for the last `check()`. Proof construction must be enabled.

Definition at line 6023 of file z3py.py.

6024  def proof(self):
6025  """Return a proof for the last `check()`. Proof construction must be enabled."""
6026  return _to_expr_ref(Z3_solver_get_proof(self.ctx.ref(), self.solver), self.ctx)
Z3_ast Z3_API Z3_solver_get_proof(Z3_context c, Z3_solver s)
Retrieve the proof for the last Z3_solver_check or Z3_solver_check_assumptions.
def proof
Definition: z3py.py:6023
def push (   self)
Create a backtracking point.

>>> x = Int('x')
>>> s = Solver()
>>> s.add(x > 0)
>>> s
[x > 0]
>>> s.push()
>>> s.add(x < 1)
>>> s
[x > 0, x < 1]
>>> s.check()
unsat
>>> s.pop()
>>> s.check()
sat
>>> s
[x > 0]

Definition at line 5804 of file z3py.py.

Referenced by Solver.reset().

5805  def push(self):
5806  """Create a backtracking point.
5807 
5808  >>> x = Int('x')
5809  >>> s = Solver()
5810  >>> s.add(x > 0)
5811  >>> s
5812  [x > 0]
5813  >>> s.push()
5814  >>> s.add(x < 1)
5815  >>> s
5816  [x > 0, x < 1]
5817  >>> s.check()
5818  unsat
5819  >>> s.pop()
5820  >>> s.check()
5821  sat
5822  >>> s
5823  [x > 0]
5824  """
5825  Z3_solver_push(self.ctx.ref(), self.solver)
void Z3_API Z3_solver_push(Z3_context c, Z3_solver s)
Create a backtracking point.
def push
Definition: z3py.py:5804
def reason_unknown (   self)
Return a string describing why the last `check()` returned `unknown`.

>>> x = Int('x')
>>> s = SimpleSolver()
>>> s.add(2**x == 4)
>>> s.check()
unknown
>>> s.reason_unknown()
'(incomplete (theory arithmetic))'

Definition at line 6059 of file z3py.py.

6060  def reason_unknown(self):
6061  """Return a string describing why the last `check()` returned `unknown`.
6062 
6063  >>> x = Int('x')
6064  >>> s = SimpleSolver()
6065  >>> s.add(2**x == 4)
6066  >>> s.check()
6067  unknown
6068  >>> s.reason_unknown()
6069  '(incomplete (theory arithmetic))'
6070  """
6071  return Z3_solver_get_reason_unknown(self.ctx.ref(), self.solver)
def reason_unknown
Definition: z3py.py:6059
Z3_string Z3_API Z3_solver_get_reason_unknown(Z3_context c, Z3_solver s)
Return a brief justification for an &quot;unknown&quot; result (i.e., Z3_L_UNDEF) for the commands Z3_solver_ch...
def reset (   self)
Remove all asserted constraints and backtracking points created using `push()`.

>>> x = Int('x')
>>> s = Solver()
>>> s.add(x > 0)
>>> s
[x > 0]
>>> s.reset()
>>> s
[]

Definition at line 5848 of file z3py.py.

5849  def reset(self):
5850  """Remove all asserted constraints and backtracking points created using `push()`.
5851 
5852  >>> x = Int('x')
5853  >>> s = Solver()
5854  >>> s.add(x > 0)
5855  >>> s
5856  [x > 0]
5857  >>> s.reset()
5858  >>> s
5859  []
5860  """
5861  Z3_solver_reset(self.ctx.ref(), self.solver)
void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s)
Remove all assertions from the solver.
def reset
Definition: z3py.py:5848
def set (   self,
  args,
  keys 
)
Set a configuration option. The method `help()` return a string containing all available options.

>>> s = Solver()
>>> # The option MBQI can be set using three different approaches.
>>> s.set(mbqi=True)
>>> s.set('MBQI', True)
>>> s.set(':mbqi', True)

Definition at line 5792 of file z3py.py.

5793  def set(self, *args, **keys):
5794  """Set a configuration option. The method `help()` return a string containing all available options.
5795 
5796  >>> s = Solver()
5797  >>> # The option MBQI can be set using three different approaches.
5798  >>> s.set(mbqi=True)
5799  >>> s.set('MBQI', True)
5800  >>> s.set(':mbqi', True)
5801  """
5802  p = args2params(args, keys, self.ctx)
5803  Z3_solver_set_params(self.ctx.ref(), self.solver, p.params)
void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p)
Set the given solver using the given parameters.
def args2params
Definition: z3py.py:4527
def set
Definition: z3py.py:5792
def sexpr (   self)
Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.

>>> x = Int('x')
>>> s = Solver()
>>> s.add(x > 0)
>>> s.add(x < 2)
>>> r = s.sexpr()

Definition at line 6084 of file z3py.py.

Referenced by Fixedpoint.__repr__(), and Optimize.__repr__().

6085  def sexpr(self):
6086  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
6087 
6088  >>> x = Int('x')
6089  >>> s = Solver()
6090  >>> s.add(x > 0)
6091  >>> s.add(x < 2)
6092  >>> r = s.sexpr()
6093  """
6094  return Z3_solver_to_string(self.ctx.ref(), self.solver)
Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s)
Convert a solver into a string.
def sexpr
Definition: z3py.py:6084
def statistics (   self)
Return statistics for the last `check()`.

>>> s = SimpleSolver()
>>> x = Int('x')
>>> s.add(x > 0)
>>> s.check()
sat
>>> st = s.statistics()
>>> st.get_key_value('final checks')
1
>>> len(st) > 0
True
>>> st[0] != 0
True

Definition at line 6041 of file z3py.py.

6042  def statistics(self):
6043  """Return statistics for the last `check()`.
6044 
6045  >>> s = SimpleSolver()
6046  >>> x = Int('x')
6047  >>> s.add(x > 0)
6048  >>> s.check()
6049  sat
6050  >>> st = s.statistics()
6051  >>> st.get_key_value('final checks')
6052  1
6053  >>> len(st) > 0
6054  True
6055  >>> st[0] != 0
6056  True
6057  """
6058  return Statistics(Z3_solver_get_statistics(self.ctx.ref(), self.solver), self.ctx)
Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s)
Return statistics for the given solver.
Statistics.
Definition: z3py.py:5604
def statistics
Definition: z3py.py:6041
def to_smt2 (   self)
return SMTLIB2 formatted benchmark for solver's assertions

Definition at line 6095 of file z3py.py.

6096  def to_smt2(self):
6097  """return SMTLIB2 formatted benchmark for solver's assertions"""
6098  es = self.assertions()
6099  sz = len(es)
6100  sz1 = sz
6101  if sz1 > 0:
6102  sz1 -= 1
6103  v = (Ast * sz1)()
6104  for i in range(sz1):
6105  v[i] = es[i].as_ast()
6106  if sz > 0:
6107  e = es[sz1].as_ast()
6108  else:
6109  e = BoolVal(True, self.ctx).as_ast()
6110  return Z3_benchmark_to_smtlib_string(self.ctx.ref(), "benchmark generated from python API", "", "unknown", "", sz1, v, e)
def BoolVal
Definition: z3py.py:1363
def to_smt2
Definition: z3py.py:6095
Z3_string Z3_API Z3_benchmark_to_smtlib_string(Z3_context c, Z3_string name, Z3_string logic, Z3_string status, Z3_string attributes, unsigned num_assumptions, Z3_ast const assumptions[], Z3_ast formula)
Convert the given benchmark into SMT-LIB formatted string.
def assertions
Definition: z3py.py:6027
def unsat_core (   self)
Return a subset (as an AST vector) of the assumptions provided to the last check().

These are the assumptions Z3 used in the unsatisfiability proof.
Assumptions are available in Z3. They are used to extract unsatisfiable cores. 
They may be also used to "retract" assumptions. Note that, assumptions are not really 
"soft constraints", but they can be used to implement them. 

>>> p1, p2, p3 = Bools('p1 p2 p3')
>>> x, y       = Ints('x y')
>>> s          = Solver()
>>> s.add(Implies(p1, x > 0))
>>> s.add(Implies(p2, y > x))
>>> s.add(Implies(p2, y < 1))
>>> s.add(Implies(p3, y > -3))
>>> s.check(p1, p2, p3)
unsat
>>> core = s.unsat_core()
>>> len(core)
2
>>> p1 in core
True
>>> p2 in core
True
>>> p3 in core
False
>>> # "Retracting" p2
>>> s.check(p1, p3)
sat

Definition at line 5991 of file z3py.py.

5992  def unsat_core(self):
5993  """Return a subset (as an AST vector) of the assumptions provided to the last check().
5994 
5995  These are the assumptions Z3 used in the unsatisfiability proof.
5996  Assumptions are available in Z3. They are used to extract unsatisfiable cores.
5997  They may be also used to "retract" assumptions. Note that, assumptions are not really
5998  "soft constraints", but they can be used to implement them.
5999 
6000  >>> p1, p2, p3 = Bools('p1 p2 p3')
6001  >>> x, y = Ints('x y')
6002  >>> s = Solver()
6003  >>> s.add(Implies(p1, x > 0))
6004  >>> s.add(Implies(p2, y > x))
6005  >>> s.add(Implies(p2, y < 1))
6006  >>> s.add(Implies(p3, y > -3))
6007  >>> s.check(p1, p2, p3)
6008  unsat
6009  >>> core = s.unsat_core()
6010  >>> len(core)
6011  2
6012  >>> p1 in core
6013  True
6014  >>> p2 in core
6015  True
6016  >>> p3 in core
6017  False
6018  >>> # "Retracting" p2
6019  >>> s.check(p1, p3)
6020  sat
6021  """
6022  return AstVector(Z3_solver_get_unsat_core(self.ctx.ref(), self.solver), self.ctx)
Z3_ast_vector Z3_API Z3_solver_get_unsat_core(Z3_context c, Z3_solver s)
Retrieve the unsat core for the last Z3_solver_check_assumptions The unsat core is a subset of the as...
def unsat_core
Definition: z3py.py:5991

Field Documentation

ctx

Definition at line 5780 of file z3py.py.

Referenced by Probe.__eq__(), Probe.__ge__(), ApplyResult.__getitem__(), Probe.__gt__(), Probe.__le__(), Probe.__lt__(), Probe.__ne__(), Fixedpoint.add_rule(), Optimize.add_soft(), Tactic.apply(), ApplyResult.as_expr(), Solver.assert_and_track(), Solver.assert_exprs(), Fixedpoint.assert_exprs(), Solver.assertions(), ApplyResult.convert_model(), Fixedpoint.get_answer(), Fixedpoint.get_assertions(), Fixedpoint.get_cover_delta(), Fixedpoint.get_rules(), Solver.model(), Optimize.model(), Solver.param_descrs(), Fixedpoint.param_descrs(), Optimize.param_descrs(), Tactic.param_descrs(), Fixedpoint.parse_file(), Fixedpoint.parse_string(), Solver.proof(), Fixedpoint.query(), Solver.set(), Fixedpoint.set(), Optimize.set(), Tactic.solver(), Solver.statistics(), Fixedpoint.statistics(), Optimize.statistics(), Solver.to_smt2(), Solver.unsat_core(), and Fixedpoint.update_rule().

solver

Definition at line 5781 of file z3py.py.

Referenced by Solver.__del__(), Solver.assert_and_track(), Solver.assert_exprs(), Solver.assertions(), Solver.check(), Solver.help(), Solver.model(), Solver.param_descrs(), Solver.pop(), Solver.proof(), Solver.push(), Solver.reason_unknown(), Solver.reset(), Solver.set(), Solver.sexpr(), Solver.statistics(), and Solver.unsat_core().