Z3
z3py.py
Go to the documentation of this file.
1 
8 
9 """Z3 is a high performance theorem prover developed at Microsoft Research. Z3 is used in many applications such as: software/hardware verification and testing, constraint solving, analysis of hybrid systems, security, biology (in silico analysis), and geometrical problems.
10 
11 Several online tutorials for Z3Py are available at:
12 http://rise4fun.com/Z3Py/tutorial/guide
13 
14 Please send feedback, comments and/or corrections on the Issue tracker for https://github.com/Z3prover/z3.git. Your comments are very valuable.
15 
16 Small example:
17 
18 >>> x = Int('x')
19 >>> y = Int('y')
20 >>> s = Solver()
21 >>> s.add(x > 0)
22 >>> s.add(x < 2)
23 >>> s.add(y == x + 1)
24 >>> s.check()
25 sat
26 >>> m = s.model()
27 >>> m[x]
28 1
29 >>> m[y]
30 2
31 
32 Z3 exceptions:
33 
34 >>> try:
35 ... x = BitVec('x', 32)
36 ... y = Bool('y')
37 ... # the expression x + y is type incorrect
38 ... n = x + y
39 ... except Z3Exception as ex:
40 ... print("failed: %s" % ex)
41 failed: sort mismatch
42 """
43 from . import z3core
44 from .z3core import *
45 from .z3types import *
46 from .z3consts import *
47 from .z3printer import *
48 from fractions import Fraction
49 import sys
50 import io
51 import math
52 import copy
53 
54 Z3_DEBUG = __debug__
55 
56 def z3_debug():
57  global Z3_DEBUG
58  return Z3_DEBUG
59 
60 if sys.version < '3':
61  def _is_int(v):
62  return isinstance(v, (int, long))
63 else:
64  def _is_int(v):
65  return isinstance(v, int)
66 
67 def enable_trace(msg):
68  Z3_enable_trace(msg)
69 
70 def disable_trace(msg):
71  Z3_disable_trace(msg)
72 
74  major = ctypes.c_uint(0)
75  minor = ctypes.c_uint(0)
76  build = ctypes.c_uint(0)
77  rev = ctypes.c_uint(0)
78  Z3_get_version(major, minor, build, rev)
79  return "%s.%s.%s" % (major.value, minor.value, build.value)
80 
82  major = ctypes.c_uint(0)
83  minor = ctypes.c_uint(0)
84  build = ctypes.c_uint(0)
85  rev = ctypes.c_uint(0)
86  Z3_get_version(major, minor, build, rev)
87  return (major.value, minor.value, build.value, rev.value)
88 
90  return Z3_get_full_version()
91 
92 # We use _z3_assert instead of the assert command because we want to
93 # produce nice error messages in Z3Py at rise4fun.com
94 def _z3_assert(cond, msg):
95  if not cond:
96  raise Z3Exception(msg)
97 
98 def _z3_check_cint_overflow(n, name):
99  _z3_assert(ctypes.c_int(n).value == n, name + " is too large")
100 
101 def open_log(fname):
102  """Log interaction to a file. This function must be invoked immediately after init(). """
103  Z3_open_log(fname)
104 
105 def append_log(s):
106  """Append user-defined string to interaction log. """
107  Z3_append_log(s)
108 
109 def to_symbol(s, ctx=None):
110  """Convert an integer or string into a Z3 symbol."""
111  if _is_int(s):
112  return Z3_mk_int_symbol(_get_ctx(ctx).ref(), s)
113  else:
114  return Z3_mk_string_symbol(_get_ctx(ctx).ref(), s)
115 
116 def _symbol2py(ctx, s):
117  """Convert a Z3 symbol back into a Python object. """
118  if Z3_get_symbol_kind(ctx.ref(), s) == Z3_INT_SYMBOL:
119  return "k!%s" % Z3_get_symbol_int(ctx.ref(), s)
120  else:
121  return Z3_get_symbol_string(ctx.ref(), s)
122 
123 # Hack for having nary functions that can receive one argument that is the
124 # list of arguments.
125 # Use this when function takes a single list of arguments
126 def _get_args(args):
127  try:
128  if len(args) == 1 and (isinstance(args[0], tuple) or isinstance(args[0], list)):
129  return args[0]
130  elif len(args) == 1 and (isinstance(args[0], set) or isinstance(args[0], AstVector)):
131  return [arg for arg in args[0]]
132  else:
133  return args
134  except: # len is not necessarily defined when args is not a sequence (use reflection?)
135  return args
136 
137 # Use this when function takes multiple arguments
138 def _get_args_ast_list(args):
139  try:
140  if isinstance(args, set) or isinstance(args, AstVector) or isinstance(args, tuple):
141  return [arg for arg in args]
142  else:
143  return args
144  except:
145  return args
146 
147 def _to_param_value(val):
148  if isinstance(val, bool):
149  if val == True:
150  return "true"
151  else:
152  return "false"
153  else:
154  return str(val)
155 
157  # Do nothing error handler, just avoid exit(0)
158  # The wrappers in z3core.py will raise a Z3Exception if an error is detected
159  return
160 
161 class Context:
162  """A Context manages all other Z3 objects, global configuration options, etc.
163 
164  Z3Py uses a default global context. For most applications this is sufficient.
165  An application may use multiple Z3 contexts. Objects created in one context
166  cannot be used in another one. However, several objects may be "translated" from
167  one context to another. It is not safe to access Z3 objects from multiple threads.
168  The only exception is the method `interrupt()` that can be used to interrupt() a long
169  computation.
170  The initialization method receives global configuration options for the new context.
171  """
172  def __init__(self, *args, **kws):
173  if z3_debug():
174  _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
175  conf = Z3_mk_config()
176  for key in kws:
177  value = kws[key]
178  Z3_set_param_value(conf, str(key).upper(), _to_param_value(value))
179  prev = None
180  for a in args:
181  if prev is None:
182  prev = a
183  else:
184  Z3_set_param_value(conf, str(prev), _to_param_value(a))
185  prev = None
186  self.ctxctx = Z3_mk_context_rc(conf)
187  self.eheh = Z3_set_error_handler(self.ctxctx, z3_error_handler)
188  Z3_set_ast_print_mode(self.ctxctx, Z3_PRINT_SMTLIB2_COMPLIANT)
189  Z3_del_config(conf)
190 
191  def __del__(self):
192  Z3_del_context(self.ctxctx)
193  self.ctxctx = None
194  self.eheh = None
195 
196  def ref(self):
197  """Return a reference to the actual C pointer to the Z3 context."""
198  return self.ctxctx
199 
200  def interrupt(self):
201  """Interrupt a solver performing a satisfiability test, a tactic processing a goal, or simplify functions.
202 
203  This method can be invoked from a thread different from the one executing the
204  interruptible procedure.
205  """
206  Z3_interrupt(self.refref())
207 
208 
209 # Global Z3 context
210 _main_ctx = None
211 def main_ctx():
212  """Return a reference to the global Z3 context.
213 
214  >>> x = Real('x')
215  >>> x.ctx == main_ctx()
216  True
217  >>> c = Context()
218  >>> c == main_ctx()
219  False
220  >>> x2 = Real('x', c)
221  >>> x2.ctx == c
222  True
223  >>> eq(x, x2)
224  False
225  """
226  global _main_ctx
227  if _main_ctx is None:
228  _main_ctx = Context()
229  return _main_ctx
230 
231 def _get_ctx(ctx):
232  if ctx is None:
233  return main_ctx()
234  else:
235  return ctx
236 
237 def get_ctx(ctx):
238  return _get_ctx(ctx)
239 
240 def set_param(*args, **kws):
241  """Set Z3 global (or module) parameters.
242 
243  >>> set_param(precision=10)
244  """
245  if z3_debug():
246  _z3_assert(len(args) % 2 == 0, "Argument list must have an even number of elements.")
247  new_kws = {}
248  for k in kws:
249  v = kws[k]
250  if not set_pp_option(k, v):
251  new_kws[k] = v
252  for key in new_kws:
253  value = new_kws[key]
254  Z3_global_param_set(str(key).upper(), _to_param_value(value))
255  prev = None
256  for a in args:
257  if prev is None:
258  prev = a
259  else:
260  Z3_global_param_set(str(prev), _to_param_value(a))
261  prev = None
262 
264  """Reset all global (or module) parameters.
265  """
267 
268 def set_option(*args, **kws):
269  """Alias for 'set_param' for backward compatibility.
270  """
271  return set_param(*args, **kws)
272 
273 def get_param(name):
274  """Return the value of a Z3 global (or module) parameter
275 
276  >>> get_param('nlsat.reorder')
277  'true'
278  """
279  ptr = (ctypes.c_char_p * 1)()
280  if Z3_global_param_get(str(name), ptr):
281  r = z3core._to_pystr(ptr[0])
282  return r
283  raise Z3Exception("failed to retrieve value for '%s'" % name)
284 
285 
290 
291 # Mark objects that use pretty printer
293  """Superclass for all Z3 objects that have support for pretty printing."""
294  def use_pp(self):
295  return True
296 
297  def _repr_html_(self):
298  in_html = in_html_mode()
299  set_html_mode(True)
300  res = repr(self)
301  set_html_mode(in_html)
302  return res
303 
304 
306  """AST are Direct Acyclic Graphs (DAGs) used to represent sorts, declarations and expressions."""
307  def __init__(self, ast, ctx=None):
308  self.astast = ast
309  self.ctxctx = _get_ctx(ctx)
310  Z3_inc_ref(self.ctxctx.ref(), self.as_astas_ast())
311 
312  def __del__(self):
313  if self.ctxctx.ref() is not None and self.astast is not None:
314  Z3_dec_ref(self.ctxctx.ref(), self.as_astas_ast())
315  self.astast = None
316 
317  def __deepcopy__(self, memo={}):
318  return _to_ast_ref(self.astast, self.ctxctx)
319 
320  def __str__(self):
321  return obj_to_string(self)
322 
323  def __repr__(self):
324  return obj_to_string(self)
325 
326  def __eq__(self, other):
327  return self.eqeq(other)
328 
329  def __hash__(self):
330  return self.hashhash()
331 
332  def __nonzero__(self):
333  return self.__bool____bool__()
334 
335  def __bool__(self):
336  if is_true(self):
337  return True
338  elif is_false(self):
339  return False
340  elif is_eq(self) and self.num_args() == 2:
341  return self.arg(0).eq(self.arg(1))
342  else:
343  raise Z3Exception("Symbolic expressions cannot be cast to concrete Boolean values.")
344 
345  def sexpr(self):
346  """Return a string representing the AST node in s-expression notation.
347 
348  >>> x = Int('x')
349  >>> ((x + 1)*x).sexpr()
350  '(* (+ x 1) x)'
351  """
352  return Z3_ast_to_string(self.ctx_refctx_ref(), self.as_astas_ast())
353 
354  def as_ast(self):
355  """Return a pointer to the corresponding C Z3_ast object."""
356  return self.astast
357 
358  def get_id(self):
359  """Return unique identifier for object. It can be used for hash-tables and maps."""
360  return Z3_get_ast_id(self.ctx_refctx_ref(), self.as_astas_ast())
361 
362  def ctx_ref(self):
363  """Return a reference to the C context where this AST node is stored."""
364  return self.ctxctx.ref()
365 
366  def eq(self, other):
367  """Return `True` if `self` and `other` are structurally identical.
368 
369  >>> x = Int('x')
370  >>> n1 = x + 1
371  >>> n2 = 1 + x
372  >>> n1.eq(n2)
373  False
374  >>> n1 = simplify(n1)
375  >>> n2 = simplify(n2)
376  >>> n1.eq(n2)
377  True
378  """
379  if z3_debug():
380  _z3_assert(is_ast(other), "Z3 AST expected")
381  return Z3_is_eq_ast(self.ctx_refctx_ref(), self.as_astas_ast(), other.as_ast())
382 
383  def translate(self, target):
384  """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
385 
386  >>> c1 = Context()
387  >>> c2 = Context()
388  >>> x = Int('x', c1)
389  >>> y = Int('y', c2)
390  >>> # Nodes in different contexts can't be mixed.
391  >>> # However, we can translate nodes from one context to another.
392  >>> x.translate(c2) + y
393  x + y
394  """
395  if z3_debug():
396  _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
397  return _to_ast_ref(Z3_translate(self.ctxctx.ref(), self.as_astas_ast(), target.ref()), target)
398 
399  def __copy__(self):
400  return self.translatetranslate(self.ctxctx)
401 
402  def hash(self):
403  """Return a hashcode for the `self`.
404 
405  >>> n1 = simplify(Int('x') + 1)
406  >>> n2 = simplify(2 + Int('x') - 1)
407  >>> n1.hash() == n2.hash()
408  True
409  """
410  return Z3_get_ast_hash(self.ctx_refctx_ref(), self.as_astas_ast())
411 
412 def is_ast(a):
413  """Return `True` if `a` is an AST node.
414 
415  >>> is_ast(10)
416  False
417  >>> is_ast(IntVal(10))
418  True
419  >>> is_ast(Int('x'))
420  True
421  >>> is_ast(BoolSort())
422  True
423  >>> is_ast(Function('f', IntSort(), IntSort()))
424  True
425  >>> is_ast("x")
426  False
427  >>> is_ast(Solver())
428  False
429  """
430  return isinstance(a, AstRef)
431 
432 def eq(a, b):
433  """Return `True` if `a` and `b` are structurally identical AST nodes.
434 
435  >>> x = Int('x')
436  >>> y = Int('y')
437  >>> eq(x, y)
438  False
439  >>> eq(x + 1, x + 1)
440  True
441  >>> eq(x + 1, 1 + x)
442  False
443  >>> eq(simplify(x + 1), simplify(1 + x))
444  True
445  """
446  if z3_debug():
447  _z3_assert(is_ast(a) and is_ast(b), "Z3 ASTs expected")
448  return a.eq(b)
449 
450 def _ast_kind(ctx, a):
451  if is_ast(a):
452  a = a.as_ast()
453  return Z3_get_ast_kind(ctx.ref(), a)
454 
455 def _ctx_from_ast_arg_list(args, default_ctx=None):
456  ctx = None
457  for a in args:
458  if is_ast(a) or is_probe(a):
459  if ctx is None:
460  ctx = a.ctx
461  else:
462  if z3_debug():
463  _z3_assert(ctx == a.ctx, "Context mismatch")
464  if ctx is None:
465  ctx = default_ctx
466  return ctx
467 
468 def _ctx_from_ast_args(*args):
469  return _ctx_from_ast_arg_list(args)
470 
471 def _to_func_decl_array(args):
472  sz = len(args)
473  _args = (FuncDecl * sz)()
474  for i in range(sz):
475  _args[i] = args[i].as_func_decl()
476  return _args, sz
477 
478 def _to_ast_array(args):
479  sz = len(args)
480  _args = (Ast * sz)()
481  for i in range(sz):
482  _args[i] = args[i].as_ast()
483  return _args, sz
484 
485 def _to_ref_array(ref, args):
486  sz = len(args)
487  _args = (ref * sz)()
488  for i in range(sz):
489  _args[i] = args[i].as_ast()
490  return _args, sz
491 
492 def _to_ast_ref(a, ctx):
493  k = _ast_kind(ctx, a)
494  if k == Z3_SORT_AST:
495  return _to_sort_ref(a, ctx)
496  elif k == Z3_FUNC_DECL_AST:
497  return _to_func_decl_ref(a, ctx)
498  else:
499  return _to_expr_ref(a, ctx)
500 
501 
502 
507 
508 def _sort_kind(ctx, s):
509  return Z3_get_sort_kind(ctx.ref(), s)
510 
512  """A Sort is essentially a type. Every Z3 expression has a sort. A sort is an AST node."""
513  def as_ast(self):
514  return Z3_sort_to_ast(self.ctx_refctx_ref(), self.astast)
515 
516  def get_id(self):
517  return Z3_get_ast_id(self.ctx_refctx_ref(), self.as_astas_astas_ast())
518 
519  def kind(self):
520  """Return the Z3 internal kind of a sort. This method can be used to test if `self` is one of the Z3 builtin sorts.
521 
522  >>> b = BoolSort()
523  >>> b.kind() == Z3_BOOL_SORT
524  True
525  >>> b.kind() == Z3_INT_SORT
526  False
527  >>> A = ArraySort(IntSort(), IntSort())
528  >>> A.kind() == Z3_ARRAY_SORT
529  True
530  >>> A.kind() == Z3_INT_SORT
531  False
532  """
533  return _sort_kind(self.ctxctx, self.astast)
534 
535  def subsort(self, other):
536  """Return `True` if `self` is a subsort of `other`.
537 
538  >>> IntSort().subsort(RealSort())
539  True
540  """
541  return False
542 
543  def cast(self, val):
544  """Try to cast `val` as an element of sort `self`.
545 
546  This method is used in Z3Py to convert Python objects such as integers,
547  floats, longs and strings into Z3 expressions.
548 
549  >>> x = Int('x')
550  >>> RealSort().cast(x)
551  ToReal(x)
552  """
553  if z3_debug():
554  _z3_assert(is_expr(val), "Z3 expression expected")
555  _z3_assert(self.eqeq(val.sort()), "Sort mismatch")
556  return val
557 
558  def name(self):
559  """Return the name (string) of sort `self`.
560 
561  >>> BoolSort().name()
562  'Bool'
563  >>> ArraySort(IntSort(), IntSort()).name()
564  'Array'
565  """
566  return _symbol2py(self.ctxctx, Z3_get_sort_name(self.ctx_refctx_ref(), self.astast))
567 
568  def __eq__(self, other):
569  """Return `True` if `self` and `other` are the same Z3 sort.
570 
571  >>> p = Bool('p')
572  >>> p.sort() == BoolSort()
573  True
574  >>> p.sort() == IntSort()
575  False
576  """
577  if other is None:
578  return False
579  return Z3_is_eq_sort(self.ctx_refctx_ref(), self.astast, other.ast)
580 
581  def __ne__(self, other):
582  """Return `True` if `self` and `other` are not the same Z3 sort.
583 
584  >>> p = Bool('p')
585  >>> p.sort() != BoolSort()
586  False
587  >>> p.sort() != IntSort()
588  True
589  """
590  return not Z3_is_eq_sort(self.ctx_refctx_ref(), self.astast, other.ast)
591 
592  def __hash__(self):
593  """ Hash code. """
594  return AstRef.__hash__(self)
595 
596 def is_sort(s):
597  """Return `True` if `s` is a Z3 sort.
598 
599  >>> is_sort(IntSort())
600  True
601  >>> is_sort(Int('x'))
602  False
603  >>> is_expr(Int('x'))
604  True
605  """
606  return isinstance(s, SortRef)
607 
608 def _to_sort_ref(s, ctx):
609  if z3_debug():
610  _z3_assert(isinstance(s, Sort), "Z3 Sort expected")
611  k = _sort_kind(ctx, s)
612  if k == Z3_BOOL_SORT:
613  return BoolSortRef(s, ctx)
614  elif k == Z3_INT_SORT or k == Z3_REAL_SORT:
615  return ArithSortRef(s, ctx)
616  elif k == Z3_BV_SORT:
617  return BitVecSortRef(s, ctx)
618  elif k == Z3_ARRAY_SORT:
619  return ArraySortRef(s, ctx)
620  elif k == Z3_DATATYPE_SORT:
621  return DatatypeSortRef(s, ctx)
622  elif k == Z3_FINITE_DOMAIN_SORT:
623  return FiniteDomainSortRef(s, ctx)
624  elif k == Z3_FLOATING_POINT_SORT:
625  return FPSortRef(s, ctx)
626  elif k == Z3_ROUNDING_MODE_SORT:
627  return FPRMSortRef(s, ctx)
628  elif k == Z3_RE_SORT:
629  return ReSortRef(s, ctx)
630  elif k == Z3_SEQ_SORT:
631  return SeqSortRef(s, ctx)
632  return SortRef(s, ctx)
633 
634 def _sort(ctx, a):
635  return _to_sort_ref(Z3_get_sort(ctx.ref(), a), ctx)
636 
637 def DeclareSort(name, ctx=None):
638  """Create a new uninterpreted sort named `name`.
639 
640  If `ctx=None`, then the new sort is declared in the global Z3Py context.
641 
642  >>> A = DeclareSort('A')
643  >>> a = Const('a', A)
644  >>> b = Const('b', A)
645  >>> a.sort() == A
646  True
647  >>> b.sort() == A
648  True
649  >>> a == b
650  a == b
651  """
652  ctx = _get_ctx(ctx)
653  return SortRef(Z3_mk_uninterpreted_sort(ctx.ref(), to_symbol(name, ctx)), ctx)
654 
655 
660 
662  """Function declaration. Every constant and function have an associated declaration.
663 
664  The declaration assigns a name, a sort (i.e., type), and for function
665  the sort (i.e., type) of each of its arguments. Note that, in Z3,
666  a constant is a function with 0 arguments.
667  """
668  def as_ast(self):
669  return Z3_func_decl_to_ast(self.ctx_refctx_ref(), self.astast)
670 
671  def get_id(self):
672  return Z3_get_ast_id(self.ctx_refctx_ref(), self.as_astas_astas_ast())
673 
674  def as_func_decl(self):
675  return self.astast
676 
677  def name(self):
678  """Return the name of the function declaration `self`.
679 
680  >>> f = Function('f', IntSort(), IntSort())
681  >>> f.name()
682  'f'
683  >>> isinstance(f.name(), str)
684  True
685  """
686  return _symbol2py(self.ctxctx, Z3_get_decl_name(self.ctx_refctx_ref(), self.astast))
687 
688  def arity(self):
689  """Return the number of arguments of a function declaration. If `self` is a constant, then `self.arity()` is 0.
690 
691  >>> f = Function('f', IntSort(), RealSort(), BoolSort())
692  >>> f.arity()
693  2
694  """
695  return int(Z3_get_arity(self.ctx_refctx_ref(), self.astast))
696 
697  def domain(self, i):
698  """Return the sort of the argument `i` of a function declaration. This method assumes that `0 <= i < self.arity()`.
699 
700  >>> f = Function('f', IntSort(), RealSort(), BoolSort())
701  >>> f.domain(0)
702  Int
703  >>> f.domain(1)
704  Real
705  """
706  if z3_debug():
707  _z3_assert(i < self.arityarity(), "Index out of bounds")
708  return _to_sort_ref(Z3_get_domain(self.ctx_refctx_ref(), self.astast, i), self.ctxctx)
709 
710  def range(self):
711  """Return the sort of the range of a function declaration. For constants, this is the sort of the constant.
712 
713  >>> f = Function('f', IntSort(), RealSort(), BoolSort())
714  >>> f.range()
715  Bool
716  """
717  return _to_sort_ref(Z3_get_range(self.ctx_refctx_ref(), self.astast), self.ctxctx)
718 
719  def kind(self):
720  """Return the internal kind of a function declaration. It can be used to identify Z3 built-in functions such as addition, multiplication, etc.
721 
722  >>> x = Int('x')
723  >>> d = (x + 1).decl()
724  >>> d.kind() == Z3_OP_ADD
725  True
726  >>> d.kind() == Z3_OP_MUL
727  False
728  """
729  return Z3_get_decl_kind(self.ctx_refctx_ref(), self.astast)
730 
731  def params(self):
732  ctx = self.ctxctx
733  n = Z3_get_decl_num_parameters(self.ctx_refctx_ref(), self.astast)
734  result = [ None for i in range(n) ]
735  for i in range(n):
736  k = Z3_get_decl_parameter_kind(self.ctx_refctx_ref(), self.astast, i)
737  if k == Z3_PARAMETER_INT:
738  result[i] = Z3_get_decl_int_parameter(self.ctx_refctx_ref(), self.astast, i)
739  elif k == Z3_PARAMETER_DOUBLE:
740  result[i] = Z3_get_decl_double_parameter(self.ctx_refctx_ref(), self.astast, i)
741  elif k == Z3_PARAMETER_RATIONAL:
742  result[i] = Z3_get_decl_rational_parameter(self.ctx_refctx_ref(), self.astast, i)
743  elif k == Z3_PARAMETER_SYMBOL:
744  result[i] = Z3_get_decl_symbol_parameter(self.ctx_refctx_ref(), self.astast, i)
745  elif k == Z3_PARAMETER_SORT:
746  result[i] = SortRef(Z3_get_decl_sort_parameter(self.ctx_refctx_ref(), self.astast, i), ctx)
747  elif k == Z3_PARAMETER_AST:
748  result[i] = ExprRef(Z3_get_decl_ast_parameter(self.ctx_refctx_ref(), self.astast, i), ctx)
749  elif k == Z3_PARAMETER_FUNC_DECL:
750  result[i] = FuncDeclRef(Z3_get_decl_func_decl_parameter(self.ctx_refctx_ref(), self.astast, i), ctx)
751  else:
752  assert(False)
753  return result
754 
755  def __call__(self, *args):
756  """Create a Z3 application expression using the function `self`, and the given arguments.
757 
758  The arguments must be Z3 expressions. This method assumes that
759  the sorts of the elements in `args` match the sorts of the
760  domain. Limited coercion is supported. For example, if
761  args[0] is a Python integer, and the function expects a Z3
762  integer, then the argument is automatically converted into a
763  Z3 integer.
764 
765  >>> f = Function('f', IntSort(), RealSort(), BoolSort())
766  >>> x = Int('x')
767  >>> y = Real('y')
768  >>> f(x, y)
769  f(x, y)
770  >>> f(x, x)
771  f(x, ToReal(x))
772  """
773  args = _get_args(args)
774  num = len(args)
775  if z3_debug():
776  _z3_assert(num == self.arityarity(), "Incorrect number of arguments to %s" % self)
777  _args = (Ast * num)()
778  saved = []
779  for i in range(num):
780  # self.domain(i).cast(args[i]) may create a new Z3 expression,
781  # then we must save in 'saved' to prevent it from being garbage collected.
782  tmp = self.domaindomain(i).cast(args[i])
783  saved.append(tmp)
784  _args[i] = tmp.as_ast()
785  return _to_expr_ref(Z3_mk_app(self.ctx_refctx_ref(), self.astast, len(args), _args), self.ctxctx)
786 
788  """Return `True` if `a` is a Z3 function declaration.
789 
790  >>> f = Function('f', IntSort(), IntSort())
791  >>> is_func_decl(f)
792  True
793  >>> x = Real('x')
794  >>> is_func_decl(x)
795  False
796  """
797  return isinstance(a, FuncDeclRef)
798 
799 def Function(name, *sig):
800  """Create a new Z3 uninterpreted function with the given sorts.
801 
802  >>> f = Function('f', IntSort(), IntSort())
803  >>> f(f(0))
804  f(f(0))
805  """
806  sig = _get_args(sig)
807  if z3_debug():
808  _z3_assert(len(sig) > 0, "At least two arguments expected")
809  arity = len(sig) - 1
810  rng = sig[arity]
811  if z3_debug():
812  _z3_assert(is_sort(rng), "Z3 sort expected")
813  dom = (Sort * arity)()
814  for i in range(arity):
815  if z3_debug():
816  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
817  dom[i] = sig[i].ast
818  ctx = rng.ctx
819  return FuncDeclRef(Z3_mk_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
820 
821 def FreshFunction(*sig):
822  """Create a new fresh Z3 uninterpreted function with the given sorts.
823  """
824  sig = _get_args(sig)
825  if z3_debug():
826  _z3_assert(len(sig) > 0, "At least two arguments expected")
827  arity = len(sig) - 1
828  rng = sig[arity]
829  if z3_debug():
830  _z3_assert(is_sort(rng), "Z3 sort expected")
831  dom = (z3.Sort * arity)()
832  for i in range(arity):
833  if z3_debug():
834  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
835  dom[i] = sig[i].ast
836  ctx = rng.ctx
837  return FuncDeclRef(Z3_mk_fresh_func_decl(ctx.ref(), 'f', arity, dom, rng.ast), ctx)
838 
839 
840 def _to_func_decl_ref(a, ctx):
841  return FuncDeclRef(a, ctx)
842 
843 def RecFunction(name, *sig):
844  """Create a new Z3 recursive with the given sorts."""
845  sig = _get_args(sig)
846  if z3_debug():
847  _z3_assert(len(sig) > 0, "At least two arguments expected")
848  arity = len(sig) - 1
849  rng = sig[arity]
850  if z3_debug():
851  _z3_assert(is_sort(rng), "Z3 sort expected")
852  dom = (Sort * arity)()
853  for i in range(arity):
854  if z3_debug():
855  _z3_assert(is_sort(sig[i]), "Z3 sort expected")
856  dom[i] = sig[i].ast
857  ctx = rng.ctx
858  return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx)
859 
860 def RecAddDefinition(f, args, body):
861  """Set the body of a recursive function.
862  Recursive definitions can be simplified if they are applied to ground
863  arguments.
864  >>> ctx = Context()
865  >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx))
866  >>> n = Int('n', ctx)
867  >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1)))
868  >>> simplify(fac(5))
869  120
870  >>> s = Solver(ctx=ctx)
871  >>> s.add(fac(n) < 3)
872  >>> s.check()
873  sat
874  >>> s.model().eval(fac(5))
875  120
876  """
877  if is_app(args):
878  args = [args]
879  ctx = body.ctx
880  args = _get_args(args)
881  n = len(args)
882  _args = (Ast * n)()
883  for i in range(n):
884  _args[i] = args[i].ast
885  Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast)
886 
887 
892 
894  """Constraints, formulas and terms are expressions in Z3.
895 
896  Expressions are ASTs. Every expression has a sort.
897  There are three main kinds of expressions:
898  function applications, quantifiers and bounded variables.
899  A constant is a function application with 0 arguments.
900  For quantifier free problems, all expressions are
901  function applications.
902  """
903  def as_ast(self):
904  return self.astast
905 
906  def get_id(self):
907  return Z3_get_ast_id(self.ctx_refctx_ref(), self.as_astas_astas_ast())
908 
909  def sort(self):
910  """Return the sort of expression `self`.
911 
912  >>> x = Int('x')
913  >>> (x + 1).sort()
914  Int
915  >>> y = Real('y')
916  >>> (x + y).sort()
917  Real
918  """
919  return _sort(self.ctxctx, self.as_astas_astas_ast())
920 
921  def sort_kind(self):
922  """Shorthand for `self.sort().kind()`.
923 
924  >>> a = Array('a', IntSort(), IntSort())
925  >>> a.sort_kind() == Z3_ARRAY_SORT
926  True
927  >>> a.sort_kind() == Z3_INT_SORT
928  False
929  """
930  return self.sortsort().kind()
931 
932  def __eq__(self, other):
933  """Return a Z3 expression that represents the constraint `self == other`.
934 
935  If `other` is `None`, then this method simply returns `False`.
936 
937  >>> a = Int('a')
938  >>> b = Int('b')
939  >>> a == b
940  a == b
941  >>> a is None
942  False
943  """
944  if other is None:
945  return False
946  a, b = _coerce_exprs(self, other)
947  return BoolRef(Z3_mk_eq(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
948 
949  def __hash__(self):
950  """ Hash code. """
951  return AstRef.__hash__(self)
952 
953  def __ne__(self, other):
954  """Return a Z3 expression that represents the constraint `self != other`.
955 
956  If `other` is `None`, then this method simply returns `True`.
957 
958  >>> a = Int('a')
959  >>> b = Int('b')
960  >>> a != b
961  a != b
962  >>> a is not None
963  True
964  """
965  if other is None:
966  return True
967  a, b = _coerce_exprs(self, other)
968  _args, sz = _to_ast_array((a, b))
969  return BoolRef(Z3_mk_distinct(self.ctx_refctx_ref(), 2, _args), self.ctxctx)
970 
971  def params(self):
972  return self.decldecl().params()
973 
974  def decl(self):
975  """Return the Z3 function declaration associated with a Z3 application.
976 
977  >>> f = Function('f', IntSort(), IntSort())
978  >>> a = Int('a')
979  >>> t = f(a)
980  >>> eq(t.decl(), f)
981  True
982  >>> (a + 1).decl()
983  +
984  """
985  if z3_debug():
986  _z3_assert(is_app(self), "Z3 application expected")
987  return FuncDeclRef(Z3_get_app_decl(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
988 
989  def num_args(self):
990  """Return the number of arguments of a Z3 application.
991 
992  >>> a = Int('a')
993  >>> b = Int('b')
994  >>> (a + b).num_args()
995  2
996  >>> f = Function('f', IntSort(), IntSort(), IntSort(), IntSort())
997  >>> t = f(a, b, 0)
998  >>> t.num_args()
999  3
1000  """
1001  if z3_debug():
1002  _z3_assert(is_app(self), "Z3 application expected")
1003  return int(Z3_get_app_num_args(self.ctx_refctx_ref(), self.as_astas_astas_ast()))
1004 
1005  def arg(self, idx):
1006  """Return argument `idx` of the application `self`.
1007 
1008  This method assumes that `self` is a function application with at least `idx+1` arguments.
1009 
1010  >>> a = Int('a')
1011  >>> b = Int('b')
1012  >>> f = Function('f', IntSort(), IntSort(), IntSort(), IntSort())
1013  >>> t = f(a, b, 0)
1014  >>> t.arg(0)
1015  a
1016  >>> t.arg(1)
1017  b
1018  >>> t.arg(2)
1019  0
1020  """
1021  if z3_debug():
1022  _z3_assert(is_app(self), "Z3 application expected")
1023  _z3_assert(idx < self.num_argsnum_args(), "Invalid argument index")
1024  return _to_expr_ref(Z3_get_app_arg(self.ctx_refctx_ref(), self.as_astas_astas_ast(), idx), self.ctxctx)
1025 
1026  def children(self):
1027  """Return a list containing the children of the given expression
1028 
1029  >>> a = Int('a')
1030  >>> b = Int('b')
1031  >>> f = Function('f', IntSort(), IntSort(), IntSort(), IntSort())
1032  >>> t = f(a, b, 0)
1033  >>> t.children()
1034  [a, b, 0]
1035  """
1036  if is_app(self):
1037  return [self.argarg(i) for i in range(self.num_argsnum_args())]
1038  else:
1039  return []
1040 
1041 def _to_expr_ref(a, ctx):
1042  if isinstance(a, Pattern):
1043  return PatternRef(a, ctx)
1044  ctx_ref = ctx.ref()
1045  k = Z3_get_ast_kind(ctx_ref, a)
1046  if k == Z3_QUANTIFIER_AST:
1047  return QuantifierRef(a, ctx)
1048  sk = Z3_get_sort_kind(ctx_ref, Z3_get_sort(ctx_ref, a))
1049  if sk == Z3_BOOL_SORT:
1050  return BoolRef(a, ctx)
1051  if sk == Z3_INT_SORT:
1052  if k == Z3_NUMERAL_AST:
1053  return IntNumRef(a, ctx)
1054  return ArithRef(a, ctx)
1055  if sk == Z3_REAL_SORT:
1056  if k == Z3_NUMERAL_AST:
1057  return RatNumRef(a, ctx)
1058  if _is_algebraic(ctx, a):
1059  return AlgebraicNumRef(a, ctx)
1060  return ArithRef(a, ctx)
1061  if sk == Z3_BV_SORT:
1062  if k == Z3_NUMERAL_AST:
1063  return BitVecNumRef(a, ctx)
1064  else:
1065  return BitVecRef(a, ctx)
1066  if sk == Z3_ARRAY_SORT:
1067  return ArrayRef(a, ctx)
1068  if sk == Z3_DATATYPE_SORT:
1069  return DatatypeRef(a, ctx)
1070  if sk == Z3_FLOATING_POINT_SORT:
1071  if k == Z3_APP_AST and _is_numeral(ctx, a):
1072  return FPNumRef(a, ctx)
1073  else:
1074  return FPRef(a, ctx)
1075  if sk == Z3_FINITE_DOMAIN_SORT:
1076  if k == Z3_NUMERAL_AST:
1077  return FiniteDomainNumRef(a, ctx)
1078  else:
1079  return FiniteDomainRef(a, ctx)
1080  if sk == Z3_ROUNDING_MODE_SORT:
1081  return FPRMRef(a, ctx)
1082  if sk == Z3_SEQ_SORT:
1083  return SeqRef(a, ctx)
1084  if sk == Z3_RE_SORT:
1085  return ReRef(a, ctx)
1086  return ExprRef(a, ctx)
1087 
1088 def _coerce_expr_merge(s, a):
1089  if is_expr(a):
1090  s1 = a.sort()
1091  if s is None:
1092  return s1
1093  if s1.eq(s):
1094  return s
1095  elif s.subsort(s1):
1096  return s1
1097  elif s1.subsort(s):
1098  return s
1099  else:
1100  if z3_debug():
1101  _z3_assert(s1.ctx == s.ctx, "context mismatch")
1102  _z3_assert(False, "sort mismatch")
1103  else:
1104  return s
1105 
1106 def _coerce_exprs(a, b, ctx=None):
1107  if not is_expr(a) and not is_expr(b):
1108  a = _py2expr(a, ctx)
1109  b = _py2expr(b, ctx)
1110  s = None
1111  s = _coerce_expr_merge(s, a)
1112  s = _coerce_expr_merge(s, b)
1113  a = s.cast(a)
1114  b = s.cast(b)
1115  return (a, b)
1116 
1117 
1118 def _reduce(f, l, a):
1119  r = a
1120  for e in l:
1121  r = f(r, e)
1122  return r
1123 
1124 def _coerce_expr_list(alist, ctx=None):
1125  has_expr = False
1126  for a in alist:
1127  if is_expr(a):
1128  has_expr = True
1129  break
1130  if not has_expr:
1131  alist = [ _py2expr(a, ctx) for a in alist ]
1132  s = _reduce(_coerce_expr_merge, alist, None)
1133  return [ s.cast(a) for a in alist ]
1134 
1135 def is_expr(a):
1136  """Return `True` if `a` is a Z3 expression.
1137 
1138  >>> a = Int('a')
1139  >>> is_expr(a)
1140  True
1141  >>> is_expr(a + 1)
1142  True
1143  >>> is_expr(IntSort())
1144  False
1145  >>> is_expr(1)
1146  False
1147  >>> is_expr(IntVal(1))
1148  True
1149  >>> x = Int('x')
1150  >>> is_expr(ForAll(x, x >= 0))
1151  True
1152  >>> is_expr(FPVal(1.0))
1153  True
1154  """
1155  return isinstance(a, ExprRef)
1156 
1157 def is_app(a):
1158  """Return `True` if `a` is a Z3 function application.
1159 
1160  Note that, constants are function applications with 0 arguments.
1161 
1162  >>> a = Int('a')
1163  >>> is_app(a)
1164  True
1165  >>> is_app(a + 1)
1166  True
1167  >>> is_app(IntSort())
1168  False
1169  >>> is_app(1)
1170  False
1171  >>> is_app(IntVal(1))
1172  True
1173  >>> x = Int('x')
1174  >>> is_app(ForAll(x, x >= 0))
1175  False
1176  """
1177  if not isinstance(a, ExprRef):
1178  return False
1179  k = _ast_kind(a.ctx, a)
1180  return k == Z3_NUMERAL_AST or k == Z3_APP_AST
1181 
1182 def is_const(a):
1183  """Return `True` if `a` is Z3 constant/variable expression.
1184 
1185  >>> a = Int('a')
1186  >>> is_const(a)
1187  True
1188  >>> is_const(a + 1)
1189  False
1190  >>> is_const(1)
1191  False
1192  >>> is_const(IntVal(1))
1193  True
1194  >>> x = Int('x')
1195  >>> is_const(ForAll(x, x >= 0))
1196  False
1197  """
1198  return is_app(a) and a.num_args() == 0
1199 
1200 def is_var(a):
1201  """Return `True` if `a` is variable.
1202 
1203  Z3 uses de-Bruijn indices for representing bound variables in
1204  quantifiers.
1205 
1206  >>> x = Int('x')
1207  >>> is_var(x)
1208  False
1209  >>> is_const(x)
1210  True
1211  >>> f = Function('f', IntSort(), IntSort())
1212  >>> # Z3 replaces x with bound variables when ForAll is executed.
1213  >>> q = ForAll(x, f(x) == x)
1214  >>> b = q.body()
1215  >>> b
1216  f(Var(0)) == Var(0)
1217  >>> b.arg(1)
1218  Var(0)
1219  >>> is_var(b.arg(1))
1220  True
1221  """
1222  return is_expr(a) and _ast_kind(a.ctx, a) == Z3_VAR_AST
1223 
1225  """Return the de-Bruijn index of the Z3 bounded variable `a`.
1226 
1227  >>> x = Int('x')
1228  >>> y = Int('y')
1229  >>> is_var(x)
1230  False
1231  >>> is_const(x)
1232  True
1233  >>> f = Function('f', IntSort(), IntSort(), IntSort())
1234  >>> # Z3 replaces x and y with bound variables when ForAll is executed.
1235  >>> q = ForAll([x, y], f(x, y) == x + y)
1236  >>> q.body()
1237  f(Var(1), Var(0)) == Var(1) + Var(0)
1238  >>> b = q.body()
1239  >>> b.arg(0)
1240  f(Var(1), Var(0))
1241  >>> v1 = b.arg(0).arg(0)
1242  >>> v2 = b.arg(0).arg(1)
1243  >>> v1
1244  Var(1)
1245  >>> v2
1246  Var(0)
1247  >>> get_var_index(v1)
1248  1
1249  >>> get_var_index(v2)
1250  0
1251  """
1252  if z3_debug():
1253  _z3_assert(is_var(a), "Z3 bound variable expected")
1254  return int(Z3_get_index_value(a.ctx.ref(), a.as_ast()))
1255 
1256 def is_app_of(a, k):
1257  """Return `True` if `a` is an application of the given kind `k`.
1258 
1259  >>> x = Int('x')
1260  >>> n = x + 1
1261  >>> is_app_of(n, Z3_OP_ADD)
1262  True
1263  >>> is_app_of(n, Z3_OP_MUL)
1264  False
1265  """
1266  return is_app(a) and a.decl().kind() == k
1267 
1268 def If(a, b, c, ctx=None):
1269  """Create a Z3 if-then-else expression.
1270 
1271  >>> x = Int('x')
1272  >>> y = Int('y')
1273  >>> max = If(x > y, x, y)
1274  >>> max
1275  If(x > y, x, y)
1276  >>> simplify(max)
1277  If(x <= y, y, x)
1278  """
1279  if isinstance(a, Probe) or isinstance(b, Tactic) or isinstance(c, Tactic):
1280  return Cond(a, b, c, ctx)
1281  else:
1282  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b, c], ctx))
1283  s = BoolSort(ctx)
1284  a = s.cast(a)
1285  b, c = _coerce_exprs(b, c, ctx)
1286  if z3_debug():
1287  _z3_assert(a.ctx == b.ctx, "Context mismatch")
1288  return _to_expr_ref(Z3_mk_ite(ctx.ref(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
1289 
1290 def Distinct(*args):
1291  """Create a Z3 distinct expression.
1292 
1293  >>> x = Int('x')
1294  >>> y = Int('y')
1295  >>> Distinct(x, y)
1296  x != y
1297  >>> z = Int('z')
1298  >>> Distinct(x, y, z)
1299  Distinct(x, y, z)
1300  >>> simplify(Distinct(x, y, z))
1301  Distinct(x, y, z)
1302  >>> simplify(Distinct(x, y, z), blast_distinct=True)
1303  And(Not(x == y), Not(x == z), Not(y == z))
1304  """
1305  args = _get_args(args)
1306  ctx = _ctx_from_ast_arg_list(args)
1307  if z3_debug():
1308  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
1309  args = _coerce_expr_list(args, ctx)
1310  _args, sz = _to_ast_array(args)
1311  return BoolRef(Z3_mk_distinct(ctx.ref(), sz, _args), ctx)
1312 
1313 def _mk_bin(f, a, b):
1314  args = (Ast * 2)()
1315  if z3_debug():
1316  _z3_assert(a.ctx == b.ctx, "Context mismatch")
1317  args[0] = a.as_ast()
1318  args[1] = b.as_ast()
1319  return f(a.ctx.ref(), 2, args)
1320 
1321 def Const(name, sort):
1322  """Create a constant of the given sort.
1323 
1324  >>> Const('x', IntSort())
1325  x
1326  """
1327  if z3_debug():
1328  _z3_assert(isinstance(sort, SortRef), "Z3 sort expected")
1329  ctx = sort.ctx
1330  return _to_expr_ref(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), sort.ast), ctx)
1331 
1332 def Consts(names, sort):
1333  """Create several constants of the given sort.
1334 
1335  `names` is a string containing the names of all constants to be created.
1336  Blank spaces separate the names of different constants.
1337 
1338  >>> x, y, z = Consts('x y z', IntSort())
1339  >>> x + y + z
1340  x + y + z
1341  """
1342  if isinstance(names, str):
1343  names = names.split(" ")
1344  return [Const(name, sort) for name in names]
1345 
1346 def FreshConst(sort, prefix='c'):
1347  """Create a fresh constant of a specified sort"""
1348  ctx = _get_ctx(sort.ctx)
1349  return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx)
1350 
1351 def Var(idx, s):
1352  """Create a Z3 free variable. Free variables are used to create quantified formulas.
1353 
1354  >>> Var(0, IntSort())
1355  Var(0)
1356  >>> eq(Var(0, IntSort()), Var(0, BoolSort()))
1357  False
1358  """
1359  if z3_debug():
1360  _z3_assert(is_sort(s), "Z3 sort expected")
1361  return _to_expr_ref(Z3_mk_bound(s.ctx_ref(), idx, s.ast), s.ctx)
1362 
1363 def RealVar(idx, ctx=None):
1364  """
1365  Create a real free variable. Free variables are used to create quantified formulas.
1366  They are also used to create polynomials.
1367 
1368  >>> RealVar(0)
1369  Var(0)
1370  """
1371  return Var(idx, RealSort(ctx))
1372 
1373 def RealVarVector(n, ctx=None):
1374  """
1375  Create a list of Real free variables.
1376  The variables have ids: 0, 1, ..., n-1
1377 
1378  >>> x0, x1, x2, x3 = RealVarVector(4)
1379  >>> x2
1380  Var(2)
1381  """
1382  return [ RealVar(i, ctx) for i in range(n) ]
1383 
1384 
1389 
1391  """Boolean sort."""
1392  def cast(self, val):
1393  """Try to cast `val` as a Boolean.
1394 
1395  >>> x = BoolSort().cast(True)
1396  >>> x
1397  True
1398  >>> is_expr(x)
1399  True
1400  >>> is_expr(True)
1401  False
1402  >>> x.sort()
1403  Bool
1404  """
1405  if isinstance(val, bool):
1406  return BoolVal(val, self.ctxctx)
1407  if z3_debug():
1408  if not is_expr(val):
1409  _z3_assert(is_expr(val), "True, False or Z3 Boolean expression expected. Received %s of type %s" % (val, type(val)))
1410  if not self.eqeq(val.sort()):
1411  _z3_assert(self.eqeq(val.sort()), "Value cannot be converted into a Z3 Boolean value")
1412  return val
1413 
1414  def subsort(self, other):
1415  return isinstance(other, ArithSortRef)
1416 
1417  def is_int(self):
1418  return True
1419 
1420  def is_bool(self):
1421  return True
1422 
1423 
1425  """All Boolean expressions are instances of this class."""
1426  def sort(self):
1427  return BoolSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
1428 
1429  def __rmul__(self, other):
1430  return self * other
1431 
1432  def __mul__(self, other):
1433  """Create the Z3 expression `self * other`.
1434  """
1435  if other == 1:
1436  return self
1437  if other == 0:
1438  return 0
1439  return If(self, other, 0)
1440 
1441 
1442 def is_bool(a):
1443  """Return `True` if `a` is a Z3 Boolean expression.
1444 
1445  >>> p = Bool('p')
1446  >>> is_bool(p)
1447  True
1448  >>> q = Bool('q')
1449  >>> is_bool(And(p, q))
1450  True
1451  >>> x = Real('x')
1452  >>> is_bool(x)
1453  False
1454  >>> is_bool(x == 0)
1455  True
1456  """
1457  return isinstance(a, BoolRef)
1458 
1459 def is_true(a):
1460  """Return `True` if `a` is the Z3 true expression.
1461 
1462  >>> p = Bool('p')
1463  >>> is_true(p)
1464  False
1465  >>> is_true(simplify(p == p))
1466  True
1467  >>> x = Real('x')
1468  >>> is_true(x == 0)
1469  False
1470  >>> # True is a Python Boolean expression
1471  >>> is_true(True)
1472  False
1473  """
1474  return is_app_of(a, Z3_OP_TRUE)
1475 
1476 def is_false(a):
1477  """Return `True` if `a` is the Z3 false expression.
1478 
1479  >>> p = Bool('p')
1480  >>> is_false(p)
1481  False
1482  >>> is_false(False)
1483  False
1484  >>> is_false(BoolVal(False))
1485  True
1486  """
1487  return is_app_of(a, Z3_OP_FALSE)
1488 
1489 def is_and(a):
1490  """Return `True` if `a` is a Z3 and expression.
1491 
1492  >>> p, q = Bools('p q')
1493  >>> is_and(And(p, q))
1494  True
1495  >>> is_and(Or(p, q))
1496  False
1497  """
1498  return is_app_of(a, Z3_OP_AND)
1499 
1500 def is_or(a):
1501  """Return `True` if `a` is a Z3 or expression.
1502 
1503  >>> p, q = Bools('p q')
1504  >>> is_or(Or(p, q))
1505  True
1506  >>> is_or(And(p, q))
1507  False
1508  """
1509  return is_app_of(a, Z3_OP_OR)
1510 
1511 def is_implies(a):
1512  """Return `True` if `a` is a Z3 implication expression.
1513 
1514  >>> p, q = Bools('p q')
1515  >>> is_implies(Implies(p, q))
1516  True
1517  >>> is_implies(And(p, q))
1518  False
1519  """
1520  return is_app_of(a, Z3_OP_IMPLIES)
1521 
1522 def is_not(a):
1523  """Return `True` if `a` is a Z3 not expression.
1524 
1525  >>> p = Bool('p')
1526  >>> is_not(p)
1527  False
1528  >>> is_not(Not(p))
1529  True
1530  """
1531  return is_app_of(a, Z3_OP_NOT)
1532 
1533 def is_eq(a):
1534  """Return `True` if `a` is a Z3 equality expression.
1535 
1536  >>> x, y = Ints('x y')
1537  >>> is_eq(x == y)
1538  True
1539  """
1540  return is_app_of(a, Z3_OP_EQ)
1541 
1543  """Return `True` if `a` is a Z3 distinct expression.
1544 
1545  >>> x, y, z = Ints('x y z')
1546  >>> is_distinct(x == y)
1547  False
1548  >>> is_distinct(Distinct(x, y, z))
1549  True
1550  """
1551  return is_app_of(a, Z3_OP_DISTINCT)
1552 
1553 def BoolSort(ctx=None):
1554  """Return the Boolean Z3 sort. If `ctx=None`, then the global context is used.
1555 
1556  >>> BoolSort()
1557  Bool
1558  >>> p = Const('p', BoolSort())
1559  >>> is_bool(p)
1560  True
1561  >>> r = Function('r', IntSort(), IntSort(), BoolSort())
1562  >>> r(0, 1)
1563  r(0, 1)
1564  >>> is_bool(r(0, 1))
1565  True
1566  """
1567  ctx = _get_ctx(ctx)
1568  return BoolSortRef(Z3_mk_bool_sort(ctx.ref()), ctx)
1569 
1570 def BoolVal(val, ctx=None):
1571  """Return the Boolean value `True` or `False`. If `ctx=None`, then the global context is used.
1572 
1573  >>> BoolVal(True)
1574  True
1575  >>> is_true(BoolVal(True))
1576  True
1577  >>> is_true(True)
1578  False
1579  >>> is_false(BoolVal(False))
1580  True
1581  """
1582  ctx = _get_ctx(ctx)
1583  if val == False:
1584  return BoolRef(Z3_mk_false(ctx.ref()), ctx)
1585  else:
1586  return BoolRef(Z3_mk_true(ctx.ref()), ctx)
1587 
1588 def Bool(name, ctx=None):
1589  """Return a Boolean constant named `name`. If `ctx=None`, then the global context is used.
1590 
1591  >>> p = Bool('p')
1592  >>> q = Bool('q')
1593  >>> And(p, q)
1594  And(p, q)
1595  """
1596  ctx = _get_ctx(ctx)
1597  return BoolRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), BoolSort(ctx).ast), ctx)
1598 
1599 def Bools(names, ctx=None):
1600  """Return a tuple of Boolean constants.
1601 
1602  `names` is a single string containing all names separated by blank spaces.
1603  If `ctx=None`, then the global context is used.
1604 
1605  >>> p, q, r = Bools('p q r')
1606  >>> And(p, Or(q, r))
1607  And(p, Or(q, r))
1608  """
1609  ctx = _get_ctx(ctx)
1610  if isinstance(names, str):
1611  names = names.split(" ")
1612  return [Bool(name, ctx) for name in names]
1613 
1614 def BoolVector(prefix, sz, ctx=None):
1615  """Return a list of Boolean constants of size `sz`.
1616 
1617  The constants are named using the given prefix.
1618  If `ctx=None`, then the global context is used.
1619 
1620  >>> P = BoolVector('p', 3)
1621  >>> P
1622  [p__0, p__1, p__2]
1623  >>> And(P)
1624  And(p__0, p__1, p__2)
1625  """
1626  return [ Bool('%s__%s' % (prefix, i)) for i in range(sz) ]
1627 
1628 def FreshBool(prefix='b', ctx=None):
1629  """Return a fresh Boolean constant in the given context using the given prefix.
1630 
1631  If `ctx=None`, then the global context is used.
1632 
1633  >>> b1 = FreshBool()
1634  >>> b2 = FreshBool()
1635  >>> eq(b1, b2)
1636  False
1637  """
1638  ctx = _get_ctx(ctx)
1639  return BoolRef(Z3_mk_fresh_const(ctx.ref(), prefix, BoolSort(ctx).ast), ctx)
1640 
1641 def Implies(a, b, ctx=None):
1642  """Create a Z3 implies expression.
1643 
1644  >>> p, q = Bools('p q')
1645  >>> Implies(p, q)
1646  Implies(p, q)
1647  """
1648  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1649  s = BoolSort(ctx)
1650  a = s.cast(a)
1651  b = s.cast(b)
1652  return BoolRef(Z3_mk_implies(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1653 
1654 def Xor(a, b, ctx=None):
1655  """Create a Z3 Xor expression.
1656 
1657  >>> p, q = Bools('p q')
1658  >>> Xor(p, q)
1659  Xor(p, q)
1660  >>> simplify(Xor(p, q))
1661  Not(p) == q
1662  """
1663  ctx = _get_ctx(_ctx_from_ast_arg_list([a, b], ctx))
1664  s = BoolSort(ctx)
1665  a = s.cast(a)
1666  b = s.cast(b)
1667  return BoolRef(Z3_mk_xor(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
1668 
1669 def Not(a, ctx=None):
1670  """Create a Z3 not expression or probe.
1671 
1672  >>> p = Bool('p')
1673  >>> Not(Not(p))
1674  Not(Not(p))
1675  >>> simplify(Not(Not(p)))
1676  p
1677  """
1678  ctx = _get_ctx(_ctx_from_ast_arg_list([a], ctx))
1679  if is_probe(a):
1680  # Not is also used to build probes
1681  return Probe(Z3_probe_not(ctx.ref(), a.probe), ctx)
1682  else:
1683  s = BoolSort(ctx)
1684  a = s.cast(a)
1685  return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx)
1686 
1687 def mk_not(a):
1688  if is_not(a):
1689  return a.arg(0)
1690  else:
1691  return Not(a)
1692 
1693 def _has_probe(args):
1694  """Return `True` if one of the elements of the given collection is a Z3 probe."""
1695  for arg in args:
1696  if is_probe(arg):
1697  return True
1698  return False
1699 
1700 def And(*args):
1701  """Create a Z3 and-expression or and-probe.
1702 
1703  >>> p, q, r = Bools('p q r')
1704  >>> And(p, q, r)
1705  And(p, q, r)
1706  >>> P = BoolVector('p', 5)
1707  >>> And(P)
1708  And(p__0, p__1, p__2, p__3, p__4)
1709  """
1710  last_arg = None
1711  if len(args) > 0:
1712  last_arg = args[len(args)-1]
1713  if isinstance(last_arg, Context):
1714  ctx = args[len(args)-1]
1715  args = args[:len(args)-1]
1716  elif len(args) == 1 and isinstance(args[0], AstVector):
1717  ctx = args[0].ctx
1718  args = [a for a in args[0]]
1719  else:
1720  ctx = None
1721  args = _get_args(args)
1722  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1723  if z3_debug():
1724  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1725  if _has_probe(args):
1726  return _probe_and(args, ctx)
1727  else:
1728  args = _coerce_expr_list(args, ctx)
1729  _args, sz = _to_ast_array(args)
1730  return BoolRef(Z3_mk_and(ctx.ref(), sz, _args), ctx)
1731 
1732 def Or(*args):
1733  """Create a Z3 or-expression or or-probe.
1734 
1735  >>> p, q, r = Bools('p q r')
1736  >>> Or(p, q, r)
1737  Or(p, q, r)
1738  >>> P = BoolVector('p', 5)
1739  >>> Or(P)
1740  Or(p__0, p__1, p__2, p__3, p__4)
1741  """
1742  last_arg = None
1743  if len(args) > 0:
1744  last_arg = args[len(args)-1]
1745  if isinstance(last_arg, Context):
1746  ctx = args[len(args)-1]
1747  args = args[:len(args)-1]
1748  elif len(args) == 1 and isinstance(args[0], AstVector):
1749  ctx = args[0].ctx
1750  args = [a for a in args[0]]
1751  else:
1752  ctx = None
1753  args = _get_args(args)
1754  ctx = _get_ctx(_ctx_from_ast_arg_list(args, ctx))
1755  if z3_debug():
1756  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression or probe")
1757  if _has_probe(args):
1758  return _probe_or(args, ctx)
1759  else:
1760  args = _coerce_expr_list(args, ctx)
1761  _args, sz = _to_ast_array(args)
1762  return BoolRef(Z3_mk_or(ctx.ref(), sz, _args), ctx)
1763 
1764 
1769 
1771  """Patterns are hints for quantifier instantiation.
1772 
1773  """
1774  def as_ast(self):
1775  return Z3_pattern_to_ast(self.ctx_refctx_ref(), self.astast)
1776 
1777  def get_id(self):
1778  return Z3_get_ast_id(self.ctx_refctx_ref(), self.as_astas_astas_astas_ast())
1779 
1780 def is_pattern(a):
1781  """Return `True` if `a` is a Z3 pattern (hint for quantifier instantiation.
1782 
1783  >>> f = Function('f', IntSort(), IntSort())
1784  >>> x = Int('x')
1785  >>> q = ForAll(x, f(x) == 0, patterns = [ f(x) ])
1786  >>> q
1787  ForAll(x, f(x) == 0)
1788  >>> q.num_patterns()
1789  1
1790  >>> is_pattern(q.pattern(0))
1791  True
1792  >>> q.pattern(0)
1793  f(Var(0))
1794  """
1795  return isinstance(a, PatternRef)
1796 
1797 def MultiPattern(*args):
1798  """Create a Z3 multi-pattern using the given expressions `*args`
1799 
1800  >>> f = Function('f', IntSort(), IntSort())
1801  >>> g = Function('g', IntSort(), IntSort())
1802  >>> x = Int('x')
1803  >>> q = ForAll(x, f(x) != g(x), patterns = [ MultiPattern(f(x), g(x)) ])
1804  >>> q
1805  ForAll(x, f(x) != g(x))
1806  >>> q.num_patterns()
1807  1
1808  >>> is_pattern(q.pattern(0))
1809  True
1810  >>> q.pattern(0)
1811  MultiPattern(f(Var(0)), g(Var(0)))
1812  """
1813  if z3_debug():
1814  _z3_assert(len(args) > 0, "At least one argument expected")
1815  _z3_assert(all([ is_expr(a) for a in args ]), "Z3 expressions expected")
1816  ctx = args[0].ctx
1817  args, sz = _to_ast_array(args)
1818  return PatternRef(Z3_mk_pattern(ctx.ref(), sz, args), ctx)
1819 
1820 def _to_pattern(arg):
1821  if is_pattern(arg):
1822  return arg
1823  else:
1824  return MultiPattern(arg)
1825 
1826 
1831 
1833  """Universally and Existentially quantified formulas."""
1834 
1835  def as_ast(self):
1836  return self.astast
1837 
1838  def get_id(self):
1839  return Z3_get_ast_id(self.ctx_refctx_ref(), self.as_astas_astas_astas_ast())
1840 
1841  def sort(self):
1842  """Return the Boolean sort or sort of Lambda."""
1843  if self.is_lambdais_lambda():
1844  return _sort(self.ctxctx, self.as_astas_astas_astas_ast())
1845  return BoolSort(self.ctxctx)
1846 
1847  def is_forall(self):
1848  """Return `True` if `self` is a universal quantifier.
1849 
1850  >>> f = Function('f', IntSort(), IntSort())
1851  >>> x = Int('x')
1852  >>> q = ForAll(x, f(x) == 0)
1853  >>> q.is_forall()
1854  True
1855  >>> q = Exists(x, f(x) != 0)
1856  >>> q.is_forall()
1857  False
1858  """
1859  return Z3_is_quantifier_forall(self.ctx_refctx_ref(), self.astast)
1860 
1861  def is_exists(self):
1862  """Return `True` if `self` is an existential quantifier.
1863 
1864  >>> f = Function('f', IntSort(), IntSort())
1865  >>> x = Int('x')
1866  >>> q = ForAll(x, f(x) == 0)
1867  >>> q.is_exists()
1868  False
1869  >>> q = Exists(x, f(x) != 0)
1870  >>> q.is_exists()
1871  True
1872  """
1873  return Z3_is_quantifier_exists(self.ctx_refctx_ref(), self.astast)
1874 
1875  def is_lambda(self):
1876  """Return `True` if `self` is a lambda expression.
1877 
1878  >>> f = Function('f', IntSort(), IntSort())
1879  >>> x = Int('x')
1880  >>> q = Lambda(x, f(x))
1881  >>> q.is_lambda()
1882  True
1883  >>> q = Exists(x, f(x) != 0)
1884  >>> q.is_lambda()
1885  False
1886  """
1887  return Z3_is_lambda(self.ctx_refctx_ref(), self.astast)
1888 
1889  def __getitem__(self, arg):
1890  """Return the Z3 expression `self[arg]`.
1891  """
1892  if z3_debug():
1893  _z3_assert(self.is_lambdais_lambda(), "quantifier should be a lambda expression")
1894  arg = self.sortsortsortsort().domain().cast(arg)
1895  return _to_expr_ref(Z3_mk_select(self.ctx_refctx_ref(), self.as_astas_astas_astas_ast(), arg.as_ast()), self.ctxctx)
1896 
1897 
1898  def weight(self):
1899  """Return the weight annotation of `self`.
1900 
1901  >>> f = Function('f', IntSort(), IntSort())
1902  >>> x = Int('x')
1903  >>> q = ForAll(x, f(x) == 0)
1904  >>> q.weight()
1905  1
1906  >>> q = ForAll(x, f(x) == 0, weight=10)
1907  >>> q.weight()
1908  10
1909  """
1910  return int(Z3_get_quantifier_weight(self.ctx_refctx_ref(), self.astast))
1911 
1912  def num_patterns(self):
1913  """Return the number of patterns (i.e., quantifier instantiation hints) in `self`.
1914 
1915  >>> f = Function('f', IntSort(), IntSort())
1916  >>> g = Function('g', IntSort(), IntSort())
1917  >>> x = Int('x')
1918  >>> q = ForAll(x, f(x) != g(x), patterns = [ f(x), g(x) ])
1919  >>> q.num_patterns()
1920  2
1921  """
1922  return int(Z3_get_quantifier_num_patterns(self.ctx_refctx_ref(), self.astast))
1923 
1924  def pattern(self, idx):
1925  """Return a pattern (i.e., quantifier instantiation hints) in `self`.
1926 
1927  >>> f = Function('f', IntSort(), IntSort())
1928  >>> g = Function('g', IntSort(), IntSort())
1929  >>> x = Int('x')
1930  >>> q = ForAll(x, f(x) != g(x), patterns = [ f(x), g(x) ])
1931  >>> q.num_patterns()
1932  2
1933  >>> q.pattern(0)
1934  f(Var(0))
1935  >>> q.pattern(1)
1936  g(Var(0))
1937  """
1938  if z3_debug():
1939  _z3_assert(idx < self.num_patternsnum_patterns(), "Invalid pattern idx")
1940  return PatternRef(Z3_get_quantifier_pattern_ast(self.ctx_refctx_ref(), self.astast, idx), self.ctxctx)
1941 
1942  def num_no_patterns(self):
1943  """Return the number of no-patterns."""
1944  return Z3_get_quantifier_num_no_patterns(self.ctx_refctx_ref(), self.astast)
1945 
1946  def no_pattern(self, idx):
1947  """Return a no-pattern."""
1948  if z3_debug():
1949  _z3_assert(idx < self.num_no_patternsnum_no_patterns(), "Invalid no-pattern idx")
1950  return _to_expr_ref(Z3_get_quantifier_no_pattern_ast(self.ctx_refctx_ref(), self.astast, idx), self.ctxctx)
1951 
1952  def body(self):
1953  """Return the expression being quantified.
1954 
1955  >>> f = Function('f', IntSort(), IntSort())
1956  >>> x = Int('x')
1957  >>> q = ForAll(x, f(x) == 0)
1958  >>> q.body()
1959  f(Var(0)) == 0
1960  """
1961  return _to_expr_ref(Z3_get_quantifier_body(self.ctx_refctx_ref(), self.astast), self.ctxctx)
1962 
1963  def num_vars(self):
1964  """Return the number of variables bounded by this quantifier.
1965 
1966  >>> f = Function('f', IntSort(), IntSort(), IntSort())
1967  >>> x = Int('x')
1968  >>> y = Int('y')
1969  >>> q = ForAll([x, y], f(x, y) >= x)
1970  >>> q.num_vars()
1971  2
1972  """
1973  return int(Z3_get_quantifier_num_bound(self.ctx_refctx_ref(), self.astast))
1974 
1975  def var_name(self, idx):
1976  """Return a string representing a name used when displaying the quantifier.
1977 
1978  >>> f = Function('f', IntSort(), IntSort(), IntSort())
1979  >>> x = Int('x')
1980  >>> y = Int('y')
1981  >>> q = ForAll([x, y], f(x, y) >= x)
1982  >>> q.var_name(0)
1983  'x'
1984  >>> q.var_name(1)
1985  'y'
1986  """
1987  if z3_debug():
1988  _z3_assert(idx < self.num_varsnum_vars(), "Invalid variable idx")
1989  return _symbol2py(self.ctxctx, Z3_get_quantifier_bound_name(self.ctx_refctx_ref(), self.astast, idx))
1990 
1991  def var_sort(self, idx):
1992  """Return the sort of a bound variable.
1993 
1994  >>> f = Function('f', IntSort(), RealSort(), IntSort())
1995  >>> x = Int('x')
1996  >>> y = Real('y')
1997  >>> q = ForAll([x, y], f(x, y) >= x)
1998  >>> q.var_sort(0)
1999  Int
2000  >>> q.var_sort(1)
2001  Real
2002  """
2003  if z3_debug():
2004  _z3_assert(idx < self.num_varsnum_vars(), "Invalid variable idx")
2005  return _to_sort_ref(Z3_get_quantifier_bound_sort(self.ctx_refctx_ref(), self.astast, idx), self.ctxctx)
2006 
2007  def children(self):
2008  """Return a list containing a single element self.body()
2009 
2010  >>> f = Function('f', IntSort(), IntSort())
2011  >>> x = Int('x')
2012  >>> q = ForAll(x, f(x) == 0)
2013  >>> q.children()
2014  [f(Var(0)) == 0]
2015  """
2016  return [ self.bodybody() ]
2017 
2019  """Return `True` if `a` is a Z3 quantifier.
2020 
2021  >>> f = Function('f', IntSort(), IntSort())
2022  >>> x = Int('x')
2023  >>> q = ForAll(x, f(x) == 0)
2024  >>> is_quantifier(q)
2025  True
2026  >>> is_quantifier(f(x))
2027  False
2028  """
2029  return isinstance(a, QuantifierRef)
2030 
2031 def _mk_quantifier(is_forall, vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2032  if z3_debug():
2033  _z3_assert(is_bool(body) or is_app(vs) or (len(vs) > 0 and is_app(vs[0])), "Z3 expression expected")
2034  _z3_assert(is_const(vs) or (len(vs) > 0 and all([ is_const(v) for v in vs])), "Invalid bounded variable(s)")
2035  _z3_assert(all([is_pattern(a) or is_expr(a) for a in patterns]), "Z3 patterns expected")
2036  _z3_assert(all([is_expr(p) for p in no_patterns]), "no patterns are Z3 expressions")
2037  if is_app(vs):
2038  ctx = vs.ctx
2039  vs = [vs]
2040  else:
2041  ctx = vs[0].ctx
2042  if not is_expr(body):
2043  body = BoolVal(body, ctx)
2044  num_vars = len(vs)
2045  if num_vars == 0:
2046  return body
2047  _vs = (Ast * num_vars)()
2048  for i in range(num_vars):
2049 
2050  _vs[i] = vs[i].as_ast()
2051  patterns = [ _to_pattern(p) for p in patterns ]
2052  num_pats = len(patterns)
2053  _pats = (Pattern * num_pats)()
2054  for i in range(num_pats):
2055  _pats[i] = patterns[i].ast
2056  _no_pats, num_no_pats = _to_ast_array(no_patterns)
2057  qid = to_symbol(qid, ctx)
2058  skid = to_symbol(skid, ctx)
2059  return QuantifierRef(Z3_mk_quantifier_const_ex(ctx.ref(), is_forall, weight, qid, skid,
2060  num_vars, _vs,
2061  num_pats, _pats,
2062  num_no_pats, _no_pats,
2063  body.as_ast()), ctx)
2064 
2065 def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2066  """Create a Z3 forall formula.
2067 
2068  The parameters `weight`, `qid`, `skid`, `patterns` and `no_patterns` are optional annotations.
2069 
2070  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2071  >>> x = Int('x')
2072  >>> y = Int('y')
2073  >>> ForAll([x, y], f(x, y) >= x)
2074  ForAll([x, y], f(x, y) >= x)
2075  >>> ForAll([x, y], f(x, y) >= x, patterns=[ f(x, y) ])
2076  ForAll([x, y], f(x, y) >= x)
2077  >>> ForAll([x, y], f(x, y) >= x, weight=10)
2078  ForAll([x, y], f(x, y) >= x)
2079  """
2080  return _mk_quantifier(True, vs, body, weight, qid, skid, patterns, no_patterns)
2081 
2082 def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[]):
2083  """Create a Z3 exists formula.
2084 
2085  The parameters `weight`, `qif`, `skid`, `patterns` and `no_patterns` are optional annotations.
2086 
2087 
2088  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2089  >>> x = Int('x')
2090  >>> y = Int('y')
2091  >>> q = Exists([x, y], f(x, y) >= x, skid="foo")
2092  >>> q
2093  Exists([x, y], f(x, y) >= x)
2094  >>> is_quantifier(q)
2095  True
2096  >>> r = Tactic('nnf')(q).as_expr()
2097  >>> is_quantifier(r)
2098  False
2099  """
2100  return _mk_quantifier(False, vs, body, weight, qid, skid, patterns, no_patterns)
2101 
2102 def Lambda(vs, body):
2103  """Create a Z3 lambda expression.
2104 
2105  >>> f = Function('f', IntSort(), IntSort(), IntSort())
2106  >>> mem0 = Array('mem0', IntSort(), IntSort())
2107  >>> lo, hi, e, i = Ints('lo hi e i')
2108  >>> mem1 = Lambda([i], If(And(lo <= i, i <= hi), e, mem0[i]))
2109  >>> mem1
2110  Lambda(i, If(And(lo <= i, i <= hi), e, mem0[i]))
2111  """
2112  ctx = body.ctx
2113  if is_app(vs):
2114  vs = [vs]
2115  num_vars = len(vs)
2116  _vs = (Ast * num_vars)()
2117  for i in range(num_vars):
2118 
2119  _vs[i] = vs[i].as_ast()
2120  return QuantifierRef(Z3_mk_lambda_const(ctx.ref(), num_vars, _vs, body.as_ast()), ctx)
2121 
2122 
2127 
2129  """Real and Integer sorts."""
2130 
2131  def is_real(self):
2132  """Return `True` if `self` is of the sort Real.
2133 
2134  >>> x = Real('x')
2135  >>> x.is_real()
2136  True
2137  >>> (x + 1).is_real()
2138  True
2139  >>> x = Int('x')
2140  >>> x.is_real()
2141  False
2142  """
2143  return self.kindkind() == Z3_REAL_SORT
2144 
2145  def is_int(self):
2146  """Return `True` if `self` is of the sort Integer.
2147 
2148  >>> x = Int('x')
2149  >>> x.is_int()
2150  True
2151  >>> (x + 1).is_int()
2152  True
2153  >>> x = Real('x')
2154  >>> x.is_int()
2155  False
2156  """
2157  return self.kindkind() == Z3_INT_SORT
2158 
2159  def subsort(self, other):
2160  """Return `True` if `self` is a subsort of `other`."""
2161  return self.is_intis_int() and is_arith_sort(other) and other.is_real()
2162 
2163  def cast(self, val):
2164  """Try to cast `val` as an Integer or Real.
2165 
2166  >>> IntSort().cast(10)
2167  10
2168  >>> is_int(IntSort().cast(10))
2169  True
2170  >>> is_int(10)
2171  False
2172  >>> RealSort().cast(10)
2173  10
2174  >>> is_real(RealSort().cast(10))
2175  True
2176  """
2177  if is_expr(val):
2178  if z3_debug():
2179  _z3_assert(self.ctxctxctx == val.ctx, "Context mismatch")
2180  val_s = val.sort()
2181  if self.eqeq(val_s):
2182  return val
2183  if val_s.is_int() and self.is_realis_real():
2184  return ToReal(val)
2185  if val_s.is_bool() and self.is_intis_int():
2186  return If(val, 1, 0)
2187  if val_s.is_bool() and self.is_realis_real():
2188  return ToReal(If(val, 1, 0))
2189  if z3_debug():
2190  _z3_assert(False, "Z3 Integer/Real expression expected" )
2191  else:
2192  if self.is_intis_int():
2193  return IntVal(val, self.ctxctxctx)
2194  if self.is_realis_real():
2195  return RealVal(val, self.ctxctxctx)
2196  if z3_debug():
2197  _z3_assert(False, "int, long, float, string (numeral), or Z3 Integer/Real expression expected. Got %s" % self)
2198 
2200  """Return `True` if s is an arithmetical sort (type).
2201 
2202  >>> is_arith_sort(IntSort())
2203  True
2204  >>> is_arith_sort(RealSort())
2205  True
2206  >>> is_arith_sort(BoolSort())
2207  False
2208  >>> n = Int('x') + 1
2209  >>> is_arith_sort(n.sort())
2210  True
2211  """
2212  return isinstance(s, ArithSortRef)
2213 
2215  """Integer and Real expressions."""
2216 
2217  def sort(self):
2218  """Return the sort (type) of the arithmetical expression `self`.
2219 
2220  >>> Int('x').sort()
2221  Int
2222  >>> (Real('x') + 1).sort()
2223  Real
2224  """
2225  return ArithSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
2226 
2227  def is_int(self):
2228  """Return `True` if `self` is an integer expression.
2229 
2230  >>> x = Int('x')
2231  >>> x.is_int()
2232  True
2233  >>> (x + 1).is_int()
2234  True
2235  >>> y = Real('y')
2236  >>> (x + y).is_int()
2237  False
2238  """
2239  return self.sortsortsort().is_int()
2240 
2241  def is_real(self):
2242  """Return `True` if `self` is an real expression.
2243 
2244  >>> x = Real('x')
2245  >>> x.is_real()
2246  True
2247  >>> (x + 1).is_real()
2248  True
2249  """
2250  return self.sortsortsort().is_real()
2251 
2252  def __add__(self, other):
2253  """Create the Z3 expression `self + other`.
2254 
2255  >>> x = Int('x')
2256  >>> y = Int('y')
2257  >>> x + y
2258  x + y
2259  >>> (x + y).sort()
2260  Int
2261  """
2262  a, b = _coerce_exprs(self, other)
2263  return ArithRef(_mk_bin(Z3_mk_add, a, b), self.ctxctx)
2264 
2265  def __radd__(self, other):
2266  """Create the Z3 expression `other + self`.
2267 
2268  >>> x = Int('x')
2269  >>> 10 + x
2270  10 + x
2271  """
2272  a, b = _coerce_exprs(self, other)
2273  return ArithRef(_mk_bin(Z3_mk_add, b, a), self.ctxctx)
2274 
2275  def __mul__(self, other):
2276  """Create the Z3 expression `self * other`.
2277 
2278  >>> x = Real('x')
2279  >>> y = Real('y')
2280  >>> x * y
2281  x*y
2282  >>> (x * y).sort()
2283  Real
2284  """
2285  if isinstance(other, BoolRef):
2286  return If(other, self, 0)
2287  a, b = _coerce_exprs(self, other)
2288  return ArithRef(_mk_bin(Z3_mk_mul, a, b), self.ctxctx)
2289 
2290  def __rmul__(self, other):
2291  """Create the Z3 expression `other * self`.
2292 
2293  >>> x = Real('x')
2294  >>> 10 * x
2295  10*x
2296  """
2297  a, b = _coerce_exprs(self, other)
2298  return ArithRef(_mk_bin(Z3_mk_mul, b, a), self.ctxctx)
2299 
2300  def __sub__(self, other):
2301  """Create the Z3 expression `self - other`.
2302 
2303  >>> x = Int('x')
2304  >>> y = Int('y')
2305  >>> x - y
2306  x - y
2307  >>> (x - y).sort()
2308  Int
2309  """
2310  a, b = _coerce_exprs(self, other)
2311  return ArithRef(_mk_bin(Z3_mk_sub, a, b), self.ctxctx)
2312 
2313  def __rsub__(self, other):
2314  """Create the Z3 expression `other - self`.
2315 
2316  >>> x = Int('x')
2317  >>> 10 - x
2318  10 - x
2319  """
2320  a, b = _coerce_exprs(self, other)
2321  return ArithRef(_mk_bin(Z3_mk_sub, b, a), self.ctxctx)
2322 
2323  def __pow__(self, other):
2324  """Create the Z3 expression `self**other` (** is the power operator).
2325 
2326  >>> x = Real('x')
2327  >>> x**3
2328  x**3
2329  >>> (x**3).sort()
2330  Real
2331  >>> simplify(IntVal(2)**8)
2332  256
2333  """
2334  a, b = _coerce_exprs(self, other)
2335  return ArithRef(Z3_mk_power(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2336 
2337  def __rpow__(self, other):
2338  """Create the Z3 expression `other**self` (** is the power operator).
2339 
2340  >>> x = Real('x')
2341  >>> 2**x
2342  2**x
2343  >>> (2**x).sort()
2344  Real
2345  >>> simplify(2**IntVal(8))
2346  256
2347  """
2348  a, b = _coerce_exprs(self, other)
2349  return ArithRef(Z3_mk_power(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
2350 
2351  def __div__(self, other):
2352  """Create the Z3 expression `other/self`.
2353 
2354  >>> x = Int('x')
2355  >>> y = Int('y')
2356  >>> x/y
2357  x/y
2358  >>> (x/y).sort()
2359  Int
2360  >>> (x/y).sexpr()
2361  '(div x y)'
2362  >>> x = Real('x')
2363  >>> y = Real('y')
2364  >>> x/y
2365  x/y
2366  >>> (x/y).sort()
2367  Real
2368  >>> (x/y).sexpr()
2369  '(/ x y)'
2370  """
2371  a, b = _coerce_exprs(self, other)
2372  return ArithRef(Z3_mk_div(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2373 
2374  def __truediv__(self, other):
2375  """Create the Z3 expression `other/self`."""
2376  return self.__div____div__(other)
2377 
2378  def __rdiv__(self, other):
2379  """Create the Z3 expression `other/self`.
2380 
2381  >>> x = Int('x')
2382  >>> 10/x
2383  10/x
2384  >>> (10/x).sexpr()
2385  '(div 10 x)'
2386  >>> x = Real('x')
2387  >>> 10/x
2388  10/x
2389  >>> (10/x).sexpr()
2390  '(/ 10.0 x)'
2391  """
2392  a, b = _coerce_exprs(self, other)
2393  return ArithRef(Z3_mk_div(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
2394 
2395  def __rtruediv__(self, other):
2396  """Create the Z3 expression `other/self`."""
2397  return self.__rdiv____rdiv__(other)
2398 
2399  def __mod__(self, other):
2400  """Create the Z3 expression `other%self`.
2401 
2402  >>> x = Int('x')
2403  >>> y = Int('y')
2404  >>> x % y
2405  x%y
2406  >>> simplify(IntVal(10) % IntVal(3))
2407  1
2408  """
2409  a, b = _coerce_exprs(self, other)
2410  if z3_debug():
2411  _z3_assert(a.is_int(), "Z3 integer expression expected")
2412  return ArithRef(Z3_mk_mod(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2413 
2414  def __rmod__(self, other):
2415  """Create the Z3 expression `other%self`.
2416 
2417  >>> x = Int('x')
2418  >>> 10 % x
2419  10%x
2420  """
2421  a, b = _coerce_exprs(self, other)
2422  if z3_debug():
2423  _z3_assert(a.is_int(), "Z3 integer expression expected")
2424  return ArithRef(Z3_mk_mod(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
2425 
2426  def __neg__(self):
2427  """Return an expression representing `-self`.
2428 
2429  >>> x = Int('x')
2430  >>> -x
2431  -x
2432  >>> simplify(-(-x))
2433  x
2434  """
2435  return ArithRef(Z3_mk_unary_minus(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
2436 
2437  def __pos__(self):
2438  """Return `self`.
2439 
2440  >>> x = Int('x')
2441  >>> +x
2442  x
2443  """
2444  return self
2445 
2446  def __le__(self, other):
2447  """Create the Z3 expression `other <= self`.
2448 
2449  >>> x, y = Ints('x y')
2450  >>> x <= y
2451  x <= y
2452  >>> y = Real('y')
2453  >>> x <= y
2454  ToReal(x) <= y
2455  """
2456  a, b = _coerce_exprs(self, other)
2457  return BoolRef(Z3_mk_le(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2458 
2459  def __lt__(self, other):
2460  """Create the Z3 expression `other < self`.
2461 
2462  >>> x, y = Ints('x y')
2463  >>> x < y
2464  x < y
2465  >>> y = Real('y')
2466  >>> x < y
2467  ToReal(x) < y
2468  """
2469  a, b = _coerce_exprs(self, other)
2470  return BoolRef(Z3_mk_lt(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2471 
2472  def __gt__(self, other):
2473  """Create the Z3 expression `other > self`.
2474 
2475  >>> x, y = Ints('x y')
2476  >>> x > y
2477  x > y
2478  >>> y = Real('y')
2479  >>> x > y
2480  ToReal(x) > y
2481  """
2482  a, b = _coerce_exprs(self, other)
2483  return BoolRef(Z3_mk_gt(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2484 
2485  def __ge__(self, other):
2486  """Create the Z3 expression `other >= self`.
2487 
2488  >>> x, y = Ints('x y')
2489  >>> x >= y
2490  x >= y
2491  >>> y = Real('y')
2492  >>> x >= y
2493  ToReal(x) >= y
2494  """
2495  a, b = _coerce_exprs(self, other)
2496  return BoolRef(Z3_mk_ge(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
2497 
2498 def is_arith(a):
2499  """Return `True` if `a` is an arithmetical expression.
2500 
2501  >>> x = Int('x')
2502  >>> is_arith(x)
2503  True
2504  >>> is_arith(x + 1)
2505  True
2506  >>> is_arith(1)
2507  False
2508  >>> is_arith(IntVal(1))
2509  True
2510  >>> y = Real('y')
2511  >>> is_arith(y)
2512  True
2513  >>> is_arith(y + 1)
2514  True
2515  """
2516  return isinstance(a, ArithRef)
2517 
2518 def is_int(a):
2519  """Return `True` if `a` is an integer expression.
2520 
2521  >>> x = Int('x')
2522  >>> is_int(x + 1)
2523  True
2524  >>> is_int(1)
2525  False
2526  >>> is_int(IntVal(1))
2527  True
2528  >>> y = Real('y')
2529  >>> is_int(y)
2530  False
2531  >>> is_int(y + 1)
2532  False
2533  """
2534  return is_arith(a) and a.is_int()
2535 
2536 def is_real(a):
2537  """Return `True` if `a` is a real expression.
2538 
2539  >>> x = Int('x')
2540  >>> is_real(x + 1)
2541  False
2542  >>> y = Real('y')
2543  >>> is_real(y)
2544  True
2545  >>> is_real(y + 1)
2546  True
2547  >>> is_real(1)
2548  False
2549  >>> is_real(RealVal(1))
2550  True
2551  """
2552  return is_arith(a) and a.is_real()
2553 
2554 def _is_numeral(ctx, a):
2555  return Z3_is_numeral_ast(ctx.ref(), a)
2556 
2557 def _is_algebraic(ctx, a):
2558  return Z3_is_algebraic_number(ctx.ref(), a)
2559 
2561  """Return `True` if `a` is an integer value of sort Int.
2562 
2563  >>> is_int_value(IntVal(1))
2564  True
2565  >>> is_int_value(1)
2566  False
2567  >>> is_int_value(Int('x'))
2568  False
2569  >>> n = Int('x') + 1
2570  >>> n
2571  x + 1
2572  >>> n.arg(1)
2573  1
2574  >>> is_int_value(n.arg(1))
2575  True
2576  >>> is_int_value(RealVal("1/3"))
2577  False
2578  >>> is_int_value(RealVal(1))
2579  False
2580  """
2581  return is_arith(a) and a.is_int() and _is_numeral(a.ctx, a.as_ast())
2582 
2584  """Return `True` if `a` is rational value of sort Real.
2585 
2586  >>> is_rational_value(RealVal(1))
2587  True
2588  >>> is_rational_value(RealVal("3/5"))
2589  True
2590  >>> is_rational_value(IntVal(1))
2591  False
2592  >>> is_rational_value(1)
2593  False
2594  >>> n = Real('x') + 1
2595  >>> n.arg(1)
2596  1
2597  >>> is_rational_value(n.arg(1))
2598  True
2599  >>> is_rational_value(Real('x'))
2600  False
2601  """
2602  return is_arith(a) and a.is_real() and _is_numeral(a.ctx, a.as_ast())
2603 
2605  """Return `True` if `a` is an algebraic value of sort Real.
2606 
2607  >>> is_algebraic_value(RealVal("3/5"))
2608  False
2609  >>> n = simplify(Sqrt(2))
2610  >>> n
2611  1.4142135623?
2612  >>> is_algebraic_value(n)
2613  True
2614  """
2615  return is_arith(a) and a.is_real() and _is_algebraic(a.ctx, a.as_ast())
2616 
2617 def is_add(a):
2618  """Return `True` if `a` is an expression of the form b + c.
2619 
2620  >>> x, y = Ints('x y')
2621  >>> is_add(x + y)
2622  True
2623  >>> is_add(x - y)
2624  False
2625  """
2626  return is_app_of(a, Z3_OP_ADD)
2627 
2628 def is_mul(a):
2629  """Return `True` if `a` is an expression of the form b * c.
2630 
2631  >>> x, y = Ints('x y')
2632  >>> is_mul(x * y)
2633  True
2634  >>> is_mul(x - y)
2635  False
2636  """
2637  return is_app_of(a, Z3_OP_MUL)
2638 
2639 def is_sub(a):
2640  """Return `True` if `a` is an expression of the form b - c.
2641 
2642  >>> x, y = Ints('x y')
2643  >>> is_sub(x - y)
2644  True
2645  >>> is_sub(x + y)
2646  False
2647  """
2648  return is_app_of(a, Z3_OP_SUB)
2649 
2650 def is_div(a):
2651  """Return `True` if `a` is an expression of the form b / c.
2652 
2653  >>> x, y = Reals('x y')
2654  >>> is_div(x / y)
2655  True
2656  >>> is_div(x + y)
2657  False
2658  >>> x, y = Ints('x y')
2659  >>> is_div(x / y)
2660  False
2661  >>> is_idiv(x / y)
2662  True
2663  """
2664  return is_app_of(a, Z3_OP_DIV)
2665 
2666 def is_idiv(a):
2667  """Return `True` if `a` is an expression of the form b div c.
2668 
2669  >>> x, y = Ints('x y')
2670  >>> is_idiv(x / y)
2671  True
2672  >>> is_idiv(x + y)
2673  False
2674  """
2675  return is_app_of(a, Z3_OP_IDIV)
2676 
2677 def is_mod(a):
2678  """Return `True` if `a` is an expression of the form b % c.
2679 
2680  >>> x, y = Ints('x y')
2681  >>> is_mod(x % y)
2682  True
2683  >>> is_mod(x + y)
2684  False
2685  """
2686  return is_app_of(a, Z3_OP_MOD)
2687 
2688 def is_le(a):
2689  """Return `True` if `a` is an expression of the form b <= c.
2690 
2691  >>> x, y = Ints('x y')
2692  >>> is_le(x <= y)
2693  True
2694  >>> is_le(x < y)
2695  False
2696  """
2697  return is_app_of(a, Z3_OP_LE)
2698 
2699 def is_lt(a):
2700  """Return `True` if `a` is an expression of the form b < c.
2701 
2702  >>> x, y = Ints('x y')
2703  >>> is_lt(x < y)
2704  True
2705  >>> is_lt(x == y)
2706  False
2707  """
2708  return is_app_of(a, Z3_OP_LT)
2709 
2710 def is_ge(a):
2711  """Return `True` if `a` is an expression of the form b >= c.
2712 
2713  >>> x, y = Ints('x y')
2714  >>> is_ge(x >= y)
2715  True
2716  >>> is_ge(x == y)
2717  False
2718  """
2719  return is_app_of(a, Z3_OP_GE)
2720 
2721 def is_gt(a):
2722  """Return `True` if `a` is an expression of the form b > c.
2723 
2724  >>> x, y = Ints('x y')
2725  >>> is_gt(x > y)
2726  True
2727  >>> is_gt(x == y)
2728  False
2729  """
2730  return is_app_of(a, Z3_OP_GT)
2731 
2732 def is_is_int(a):
2733  """Return `True` if `a` is an expression of the form IsInt(b).
2734 
2735  >>> x = Real('x')
2736  >>> is_is_int(IsInt(x))
2737  True
2738  >>> is_is_int(x)
2739  False
2740  """
2741  return is_app_of(a, Z3_OP_IS_INT)
2742 
2743 def is_to_real(a):
2744  """Return `True` if `a` is an expression of the form ToReal(b).
2745 
2746  >>> x = Int('x')
2747  >>> n = ToReal(x)
2748  >>> n
2749  ToReal(x)
2750  >>> is_to_real(n)
2751  True
2752  >>> is_to_real(x)
2753  False
2754  """
2755  return is_app_of(a, Z3_OP_TO_REAL)
2756 
2757 def is_to_int(a):
2758  """Return `True` if `a` is an expression of the form ToInt(b).
2759 
2760  >>> x = Real('x')
2761  >>> n = ToInt(x)
2762  >>> n
2763  ToInt(x)
2764  >>> is_to_int(n)
2765  True
2766  >>> is_to_int(x)
2767  False
2768  """
2769  return is_app_of(a, Z3_OP_TO_INT)
2770 
2772  """Integer values."""
2773 
2774  def as_long(self):
2775  """Return a Z3 integer numeral as a Python long (bignum) numeral.
2776 
2777  >>> v = IntVal(1)
2778  >>> v + 1
2779  1 + 1
2780  >>> v.as_long() + 1
2781  2
2782  """
2783  if z3_debug():
2784  _z3_assert(self.is_intis_int(), "Integer value expected")
2785  return int(self.as_stringas_string())
2786 
2787  def as_string(self):
2788  """Return a Z3 integer numeral as a Python string.
2789  >>> v = IntVal(100)
2790  >>> v.as_string()
2791  '100'
2792  """
2793  return Z3_get_numeral_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
2794 
2795  def as_binary_string(self):
2796  """Return a Z3 integer numeral as a Python binary string.
2797  >>> v = IntVal(10)
2798  >>> v.as_binary_string()
2799  '1010'
2800  """
2801  return Z3_get_numeral_binary_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
2802 
2804  """Rational values."""
2805 
2806  def numerator(self):
2807  """ Return the numerator of a Z3 rational numeral.
2808 
2809  >>> is_rational_value(RealVal("3/5"))
2810  True
2811  >>> n = RealVal("3/5")
2812  >>> n.numerator()
2813  3
2814  >>> is_rational_value(Q(3,5))
2815  True
2816  >>> Q(3,5).numerator()
2817  3
2818  """
2819  return IntNumRef(Z3_get_numerator(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
2820 
2821  def denominator(self):
2822  """ Return the denominator of a Z3 rational numeral.
2823 
2824  >>> is_rational_value(Q(3,5))
2825  True
2826  >>> n = Q(3,5)
2827  >>> n.denominator()
2828  5
2829  """
2830  return IntNumRef(Z3_get_denominator(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
2831 
2833  """ Return the numerator as a Python long.
2834 
2835  >>> v = RealVal(10000000000)
2836  >>> v
2837  10000000000
2838  >>> v + 1
2839  10000000000 + 1
2840  >>> v.numerator_as_long() + 1 == 10000000001
2841  True
2842  """
2843  return self.numeratornumerator().as_long()
2844 
2846  """ Return the denominator as a Python long.
2847 
2848  >>> v = RealVal("1/3")
2849  >>> v
2850  1/3
2851  >>> v.denominator_as_long()
2852  3
2853  """
2854  return self.denominatordenominator().as_long()
2855 
2856  def is_int(self):
2857  return False
2858 
2859  def is_real(self):
2860  return True
2861 
2862  def is_int_value(self):
2863  return self.denominatordenominator().is_int() and self.denominator_as_longdenominator_as_long() == 1
2864 
2865  def as_long(self):
2866  _z3_assert(self.is_int_valueis_int_value(), "Expected integer fraction")
2867  return self.numerator_as_longnumerator_as_long()
2868 
2869  def as_decimal(self, prec):
2870  """ Return a Z3 rational value as a string in decimal notation using at most `prec` decimal places.
2871 
2872  >>> v = RealVal("1/5")
2873  >>> v.as_decimal(3)
2874  '0.2'
2875  >>> v = RealVal("1/3")
2876  >>> v.as_decimal(3)
2877  '0.333?'
2878  """
2879  return Z3_get_numeral_decimal_string(self.ctx_refctx_ref(), self.as_astas_astas_ast(), prec)
2880 
2881  def as_string(self):
2882  """Return a Z3 rational numeral as a Python string.
2883 
2884  >>> v = Q(3,6)
2885  >>> v.as_string()
2886  '1/2'
2887  """
2888  return Z3_get_numeral_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
2889 
2890  def as_fraction(self):
2891  """Return a Z3 rational as a Python Fraction object.
2892 
2893  >>> v = RealVal("1/5")
2894  >>> v.as_fraction()
2895  Fraction(1, 5)
2896  """
2897  return Fraction(self.numerator_as_longnumerator_as_long(), self.denominator_as_longdenominator_as_long())
2898 
2900  """Algebraic irrational values."""
2901 
2902  def approx(self, precision=10):
2903  """Return a Z3 rational number that approximates the algebraic number `self`.
2904  The result `r` is such that |r - self| <= 1/10^precision
2905 
2906  >>> x = simplify(Sqrt(2))
2907  >>> x.approx(20)
2908  6838717160008073720548335/4835703278458516698824704
2909  >>> x.approx(5)
2910  2965821/2097152
2911  """
2912  return RatNumRef(Z3_get_algebraic_number_upper(self.ctx_refctx_ref(), self.as_astas_astas_ast(), precision), self.ctxctx)
2913  def as_decimal(self, prec):
2914  """Return a string representation of the algebraic number `self` in decimal notation using `prec` decimal places
2915 
2916  >>> x = simplify(Sqrt(2))
2917  >>> x.as_decimal(10)
2918  '1.4142135623?'
2919  >>> x.as_decimal(20)
2920  '1.41421356237309504880?'
2921  """
2922  return Z3_get_numeral_decimal_string(self.ctx_refctx_ref(), self.as_astas_astas_ast(), prec)
2923 
2924  def poly(self):
2925  return AstVector(Z3_algebraic_get_poly(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
2926 
2927  def index(self):
2928  return Z3_algebraic_get_i(self.ctx_refctx_ref(), self.as_astas_astas_ast())
2929 
2930 def _py2expr(a, ctx=None):
2931  if isinstance(a, bool):
2932  return BoolVal(a, ctx)
2933  if _is_int(a):
2934  return IntVal(a, ctx)
2935  if isinstance(a, float):
2936  return RealVal(a, ctx)
2937  if is_expr(a):
2938  return a
2939  if z3_debug():
2940  _z3_assert(False, "Python bool, int, long or float expected")
2941 
2942 def IntSort(ctx=None):
2943  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
2944 
2945  >>> IntSort()
2946  Int
2947  >>> x = Const('x', IntSort())
2948  >>> is_int(x)
2949  True
2950  >>> x.sort() == IntSort()
2951  True
2952  >>> x.sort() == BoolSort()
2953  False
2954  """
2955  ctx = _get_ctx(ctx)
2956  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
2957 
2958 def RealSort(ctx=None):
2959  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
2960 
2961  >>> RealSort()
2962  Real
2963  >>> x = Const('x', RealSort())
2964  >>> is_real(x)
2965  True
2966  >>> is_int(x)
2967  False
2968  >>> x.sort() == RealSort()
2969  True
2970  """
2971  ctx = _get_ctx(ctx)
2972  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
2973 
2974 def _to_int_str(val):
2975  if isinstance(val, float):
2976  return str(int(val))
2977  elif isinstance(val, bool):
2978  if val:
2979  return "1"
2980  else:
2981  return "0"
2982  elif _is_int(val):
2983  return str(val)
2984  elif isinstance(val, str):
2985  return val
2986  if z3_debug():
2987  _z3_assert(False, "Python value cannot be used as a Z3 integer")
2988 
2989 def IntVal(val, ctx=None):
2990  """Return a Z3 integer value. If `ctx=None`, then the global context is used.
2991 
2992  >>> IntVal(1)
2993  1
2994  >>> IntVal("100")
2995  100
2996  """
2997  ctx = _get_ctx(ctx)
2998  return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
2999 
3000 def RealVal(val, ctx=None):
3001  """Return a Z3 real value.
3002 
3003  `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
3004  If `ctx=None`, then the global context is used.
3005 
3006  >>> RealVal(1)
3007  1
3008  >>> RealVal(1).sort()
3009  Real
3010  >>> RealVal("3/5")
3011  3/5
3012  >>> RealVal("1.5")
3013  3/2
3014  """
3015  ctx = _get_ctx(ctx)
3016  return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3017 
3018 def RatVal(a, b, ctx=None):
3019  """Return a Z3 rational a/b.
3020 
3021  If `ctx=None`, then the global context is used.
3022 
3023  >>> RatVal(3,5)
3024  3/5
3025  >>> RatVal(3,5).sort()
3026  Real
3027  """
3028  if z3_debug():
3029  _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3030  _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3031  return simplify(RealVal(a, ctx)/RealVal(b, ctx))
3032 
3033 def Q(a, b, ctx=None):
3034  """Return a Z3 rational a/b.
3035 
3036  If `ctx=None`, then the global context is used.
3037 
3038  >>> Q(3,5)
3039  3/5
3040  >>> Q(3,5).sort()
3041  Real
3042  """
3043  return simplify(RatVal(a, b))
3044 
3045 def Int(name, ctx=None):
3046  """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3047 
3048  >>> x = Int('x')
3049  >>> is_int(x)
3050  True
3051  >>> is_int(x + 1)
3052  True
3053  """
3054  ctx = _get_ctx(ctx)
3055  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3056 
3057 def Ints(names, ctx=None):
3058  """Return a tuple of Integer constants.
3059 
3060  >>> x, y, z = Ints('x y z')
3061  >>> Sum(x, y, z)
3062  x + y + z
3063  """
3064  ctx = _get_ctx(ctx)
3065  if isinstance(names, str):
3066  names = names.split(" ")
3067  return [Int(name, ctx) for name in names]
3068 
3069 def IntVector(prefix, sz, ctx=None):
3070  """Return a list of integer constants of size `sz`.
3071 
3072  >>> X = IntVector('x', 3)
3073  >>> X
3074  [x__0, x__1, x__2]
3075  >>> Sum(X)
3076  x__0 + x__1 + x__2
3077  """
3078  ctx = _get_ctx(ctx)
3079  return [ Int('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3080 
3081 def FreshInt(prefix='x', ctx=None):
3082  """Return a fresh integer constant in the given context using the given prefix.
3083 
3084  >>> x = FreshInt()
3085  >>> y = FreshInt()
3086  >>> eq(x, y)
3087  False
3088  >>> x.sort()
3089  Int
3090  """
3091  ctx = _get_ctx(ctx)
3092  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3093 
3094 def Real(name, ctx=None):
3095  """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3096 
3097  >>> x = Real('x')
3098  >>> is_real(x)
3099  True
3100  >>> is_real(x + 1)
3101  True
3102  """
3103  ctx = _get_ctx(ctx)
3104  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3105 
3106 def Reals(names, ctx=None):
3107  """Return a tuple of real constants.
3108 
3109  >>> x, y, z = Reals('x y z')
3110  >>> Sum(x, y, z)
3111  x + y + z
3112  >>> Sum(x, y, z).sort()
3113  Real
3114  """
3115  ctx = _get_ctx(ctx)
3116  if isinstance(names, str):
3117  names = names.split(" ")
3118  return [Real(name, ctx) for name in names]
3119 
3120 def RealVector(prefix, sz, ctx=None):
3121  """Return a list of real constants of size `sz`.
3122 
3123  >>> X = RealVector('x', 3)
3124  >>> X
3125  [x__0, x__1, x__2]
3126  >>> Sum(X)
3127  x__0 + x__1 + x__2
3128  >>> Sum(X).sort()
3129  Real
3130  """
3131  ctx = _get_ctx(ctx)
3132  return [ Real('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3133 
3134 def FreshReal(prefix='b', ctx=None):
3135  """Return a fresh real constant in the given context using the given prefix.
3136 
3137  >>> x = FreshReal()
3138  >>> y = FreshReal()
3139  >>> eq(x, y)
3140  False
3141  >>> x.sort()
3142  Real
3143  """
3144  ctx = _get_ctx(ctx)
3145  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3146 
3147 def ToReal(a):
3148  """ Return the Z3 expression ToReal(a).
3149 
3150  >>> x = Int('x')
3151  >>> x.sort()
3152  Int
3153  >>> n = ToReal(x)
3154  >>> n
3155  ToReal(x)
3156  >>> n.sort()
3157  Real
3158  """
3159  if z3_debug():
3160  _z3_assert(a.is_int(), "Z3 integer expression expected.")
3161  ctx = a.ctx
3162  return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3163 
3164 def ToInt(a):
3165  """ Return the Z3 expression ToInt(a).
3166 
3167  >>> x = Real('x')
3168  >>> x.sort()
3169  Real
3170  >>> n = ToInt(x)
3171  >>> n
3172  ToInt(x)
3173  >>> n.sort()
3174  Int
3175  """
3176  if z3_debug():
3177  _z3_assert(a.is_real(), "Z3 real expression expected.")
3178  ctx = a.ctx
3179  return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3180 
3181 def IsInt(a):
3182  """ Return the Z3 predicate IsInt(a).
3183 
3184  >>> x = Real('x')
3185  >>> IsInt(x + "1/2")
3186  IsInt(x + 1/2)
3187  >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3188  [x = 1/2]
3189  >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3190  no solution
3191  """
3192  if z3_debug():
3193  _z3_assert(a.is_real(), "Z3 real expression expected.")
3194  ctx = a.ctx
3195  return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3196 
3197 def Sqrt(a, ctx=None):
3198  """ Return a Z3 expression which represents the square root of a.
3199 
3200  >>> x = Real('x')
3201  >>> Sqrt(x)
3202  x**(1/2)
3203  """
3204  if not is_expr(a):
3205  ctx = _get_ctx(ctx)
3206  a = RealVal(a, ctx)
3207  return a ** "1/2"
3208 
3209 def Cbrt(a, ctx=None):
3210  """ Return a Z3 expression which represents the cubic root of a.
3211 
3212  >>> x = Real('x')
3213  >>> Cbrt(x)
3214  x**(1/3)
3215  """
3216  if not is_expr(a):
3217  ctx = _get_ctx(ctx)
3218  a = RealVal(a, ctx)
3219  return a ** "1/3"
3220 
3221 
3226 
3228  """Bit-vector sort."""
3229 
3230  def size(self):
3231  """Return the size (number of bits) of the bit-vector sort `self`.
3232 
3233  >>> b = BitVecSort(32)
3234  >>> b.size()
3235  32
3236  """
3237  return int(Z3_get_bv_sort_size(self.ctx_refctx_ref(), self.astast))
3238 
3239  def subsort(self, other):
3240  return is_bv_sort(other) and self.sizesize() < other.size()
3241 
3242  def cast(self, val):
3243  """Try to cast `val` as a Bit-Vector.
3244 
3245  >>> b = BitVecSort(32)
3246  >>> b.cast(10)
3247  10
3248  >>> b.cast(10).sexpr()
3249  '#x0000000a'
3250  """
3251  if is_expr(val):
3252  if z3_debug():
3253  _z3_assert(self.ctxctxctx == val.ctx, "Context mismatch")
3254  # Idea: use sign_extend if sort of val is a bitvector of smaller size
3255  return val
3256  else:
3257  return BitVecVal(val, self)
3258 
3259 def is_bv_sort(s):
3260  """Return True if `s` is a Z3 bit-vector sort.
3261 
3262  >>> is_bv_sort(BitVecSort(32))
3263  True
3264  >>> is_bv_sort(IntSort())
3265  False
3266  """
3267  return isinstance(s, BitVecSortRef)
3268 
3270  """Bit-vector expressions."""
3271 
3272  def sort(self):
3273  """Return the sort of the bit-vector expression `self`.
3274 
3275  >>> x = BitVec('x', 32)
3276  >>> x.sort()
3277  BitVec(32)
3278  >>> x.sort() == BitVecSort(32)
3279  True
3280  """
3281  return BitVecSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
3282 
3283  def size(self):
3284  """Return the number of bits of the bit-vector expression `self`.
3285 
3286  >>> x = BitVec('x', 32)
3287  >>> (x + 1).size()
3288  32
3289  >>> Concat(x, x).size()
3290  64
3291  """
3292  return self.sortsortsort().size()
3293 
3294  def __add__(self, other):
3295  """Create the Z3 expression `self + other`.
3296 
3297  >>> x = BitVec('x', 32)
3298  >>> y = BitVec('y', 32)
3299  >>> x + y
3300  x + y
3301  >>> (x + y).sort()
3302  BitVec(32)
3303  """
3304  a, b = _coerce_exprs(self, other)
3305  return BitVecRef(Z3_mk_bvadd(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3306 
3307  def __radd__(self, other):
3308  """Create the Z3 expression `other + self`.
3309 
3310  >>> x = BitVec('x', 32)
3311  >>> 10 + x
3312  10 + x
3313  """
3314  a, b = _coerce_exprs(self, other)
3315  return BitVecRef(Z3_mk_bvadd(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3316 
3317  def __mul__(self, other):
3318  """Create the Z3 expression `self * other`.
3319 
3320  >>> x = BitVec('x', 32)
3321  >>> y = BitVec('y', 32)
3322  >>> x * y
3323  x*y
3324  >>> (x * y).sort()
3325  BitVec(32)
3326  """
3327  a, b = _coerce_exprs(self, other)
3328  return BitVecRef(Z3_mk_bvmul(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3329 
3330  def __rmul__(self, other):
3331  """Create the Z3 expression `other * self`.
3332 
3333  >>> x = BitVec('x', 32)
3334  >>> 10 * x
3335  10*x
3336  """
3337  a, b = _coerce_exprs(self, other)
3338  return BitVecRef(Z3_mk_bvmul(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3339 
3340  def __sub__(self, other):
3341  """Create the Z3 expression `self - other`.
3342 
3343  >>> x = BitVec('x', 32)
3344  >>> y = BitVec('y', 32)
3345  >>> x - y
3346  x - y
3347  >>> (x - y).sort()
3348  BitVec(32)
3349  """
3350  a, b = _coerce_exprs(self, other)
3351  return BitVecRef(Z3_mk_bvsub(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3352 
3353  def __rsub__(self, other):
3354  """Create the Z3 expression `other - self`.
3355 
3356  >>> x = BitVec('x', 32)
3357  >>> 10 - x
3358  10 - x
3359  """
3360  a, b = _coerce_exprs(self, other)
3361  return BitVecRef(Z3_mk_bvsub(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3362 
3363  def __or__(self, other):
3364  """Create the Z3 expression bitwise-or `self | other`.
3365 
3366  >>> x = BitVec('x', 32)
3367  >>> y = BitVec('y', 32)
3368  >>> x | y
3369  x | y
3370  >>> (x | y).sort()
3371  BitVec(32)
3372  """
3373  a, b = _coerce_exprs(self, other)
3374  return BitVecRef(Z3_mk_bvor(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3375 
3376  def __ror__(self, other):
3377  """Create the Z3 expression bitwise-or `other | self`.
3378 
3379  >>> x = BitVec('x', 32)
3380  >>> 10 | x
3381  10 | x
3382  """
3383  a, b = _coerce_exprs(self, other)
3384  return BitVecRef(Z3_mk_bvor(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3385 
3386  def __and__(self, other):
3387  """Create the Z3 expression bitwise-and `self & other`.
3388 
3389  >>> x = BitVec('x', 32)
3390  >>> y = BitVec('y', 32)
3391  >>> x & y
3392  x & y
3393  >>> (x & y).sort()
3394  BitVec(32)
3395  """
3396  a, b = _coerce_exprs(self, other)
3397  return BitVecRef(Z3_mk_bvand(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3398 
3399  def __rand__(self, other):
3400  """Create the Z3 expression bitwise-or `other & self`.
3401 
3402  >>> x = BitVec('x', 32)
3403  >>> 10 & x
3404  10 & x
3405  """
3406  a, b = _coerce_exprs(self, other)
3407  return BitVecRef(Z3_mk_bvand(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3408 
3409  def __xor__(self, other):
3410  """Create the Z3 expression bitwise-xor `self ^ other`.
3411 
3412  >>> x = BitVec('x', 32)
3413  >>> y = BitVec('y', 32)
3414  >>> x ^ y
3415  x ^ y
3416  >>> (x ^ y).sort()
3417  BitVec(32)
3418  """
3419  a, b = _coerce_exprs(self, other)
3420  return BitVecRef(Z3_mk_bvxor(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3421 
3422  def __rxor__(self, other):
3423  """Create the Z3 expression bitwise-xor `other ^ self`.
3424 
3425  >>> x = BitVec('x', 32)
3426  >>> 10 ^ x
3427  10 ^ x
3428  """
3429  a, b = _coerce_exprs(self, other)
3430  return BitVecRef(Z3_mk_bvxor(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3431 
3432  def __pos__(self):
3433  """Return `self`.
3434 
3435  >>> x = BitVec('x', 32)
3436  >>> +x
3437  x
3438  """
3439  return self
3440 
3441  def __neg__(self):
3442  """Return an expression representing `-self`.
3443 
3444  >>> x = BitVec('x', 32)
3445  >>> -x
3446  -x
3447  >>> simplify(-(-x))
3448  x
3449  """
3450  return BitVecRef(Z3_mk_bvneg(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
3451 
3452  def __invert__(self):
3453  """Create the Z3 expression bitwise-not `~self`.
3454 
3455  >>> x = BitVec('x', 32)
3456  >>> ~x
3457  ~x
3458  >>> simplify(~(~x))
3459  x
3460  """
3461  return BitVecRef(Z3_mk_bvnot(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
3462 
3463  def __div__(self, other):
3464  """Create the Z3 expression (signed) division `self / other`.
3465 
3466  Use the function UDiv() for unsigned division.
3467 
3468  >>> x = BitVec('x', 32)
3469  >>> y = BitVec('y', 32)
3470  >>> x / y
3471  x/y
3472  >>> (x / y).sort()
3473  BitVec(32)
3474  >>> (x / y).sexpr()
3475  '(bvsdiv x y)'
3476  >>> UDiv(x, y).sexpr()
3477  '(bvudiv x y)'
3478  """
3479  a, b = _coerce_exprs(self, other)
3480  return BitVecRef(Z3_mk_bvsdiv(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3481 
3482  def __truediv__(self, other):
3483  """Create the Z3 expression (signed) division `self / other`."""
3484  return self.__div____div__(other)
3485 
3486  def __rdiv__(self, other):
3487  """Create the Z3 expression (signed) division `other / self`.
3488 
3489  Use the function UDiv() for unsigned division.
3490 
3491  >>> x = BitVec('x', 32)
3492  >>> 10 / x
3493  10/x
3494  >>> (10 / x).sexpr()
3495  '(bvsdiv #x0000000a x)'
3496  >>> UDiv(10, x).sexpr()
3497  '(bvudiv #x0000000a x)'
3498  """
3499  a, b = _coerce_exprs(self, other)
3500  return BitVecRef(Z3_mk_bvsdiv(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3501 
3502  def __rtruediv__(self, other):
3503  """Create the Z3 expression (signed) division `other / self`."""
3504  return self.__rdiv____rdiv__(other)
3505 
3506  def __mod__(self, other):
3507  """Create the Z3 expression (signed) mod `self % other`.
3508 
3509  Use the function URem() for unsigned remainder, and SRem() for signed remainder.
3510 
3511  >>> x = BitVec('x', 32)
3512  >>> y = BitVec('y', 32)
3513  >>> x % y
3514  x%y
3515  >>> (x % y).sort()
3516  BitVec(32)
3517  >>> (x % y).sexpr()
3518  '(bvsmod x y)'
3519  >>> URem(x, y).sexpr()
3520  '(bvurem x y)'
3521  >>> SRem(x, y).sexpr()
3522  '(bvsrem x y)'
3523  """
3524  a, b = _coerce_exprs(self, other)
3525  return BitVecRef(Z3_mk_bvsmod(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3526 
3527  def __rmod__(self, other):
3528  """Create the Z3 expression (signed) mod `other % self`.
3529 
3530  Use the function URem() for unsigned remainder, and SRem() for signed remainder.
3531 
3532  >>> x = BitVec('x', 32)
3533  >>> 10 % x
3534  10%x
3535  >>> (10 % x).sexpr()
3536  '(bvsmod #x0000000a x)'
3537  >>> URem(10, x).sexpr()
3538  '(bvurem #x0000000a x)'
3539  >>> SRem(10, x).sexpr()
3540  '(bvsrem #x0000000a x)'
3541  """
3542  a, b = _coerce_exprs(self, other)
3543  return BitVecRef(Z3_mk_bvsmod(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3544 
3545  def __le__(self, other):
3546  """Create the Z3 expression (signed) `other <= self`.
3547 
3548  Use the function ULE() for unsigned less than or equal to.
3549 
3550  >>> x, y = BitVecs('x y', 32)
3551  >>> x <= y
3552  x <= y
3553  >>> (x <= y).sexpr()
3554  '(bvsle x y)'
3555  >>> ULE(x, y).sexpr()
3556  '(bvule x y)'
3557  """
3558  a, b = _coerce_exprs(self, other)
3559  return BoolRef(Z3_mk_bvsle(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3560 
3561  def __lt__(self, other):
3562  """Create the Z3 expression (signed) `other < self`.
3563 
3564  Use the function ULT() for unsigned less than.
3565 
3566  >>> x, y = BitVecs('x y', 32)
3567  >>> x < y
3568  x < y
3569  >>> (x < y).sexpr()
3570  '(bvslt x y)'
3571  >>> ULT(x, y).sexpr()
3572  '(bvult x y)'
3573  """
3574  a, b = _coerce_exprs(self, other)
3575  return BoolRef(Z3_mk_bvslt(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3576 
3577  def __gt__(self, other):
3578  """Create the Z3 expression (signed) `other > self`.
3579 
3580  Use the function UGT() for unsigned greater than.
3581 
3582  >>> x, y = BitVecs('x y', 32)
3583  >>> x > y
3584  x > y
3585  >>> (x > y).sexpr()
3586  '(bvsgt x y)'
3587  >>> UGT(x, y).sexpr()
3588  '(bvugt x y)'
3589  """
3590  a, b = _coerce_exprs(self, other)
3591  return BoolRef(Z3_mk_bvsgt(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3592 
3593  def __ge__(self, other):
3594  """Create the Z3 expression (signed) `other >= self`.
3595 
3596  Use the function UGE() for unsigned greater than or equal to.
3597 
3598  >>> x, y = BitVecs('x y', 32)
3599  >>> x >= y
3600  x >= y
3601  >>> (x >= y).sexpr()
3602  '(bvsge x y)'
3603  >>> UGE(x, y).sexpr()
3604  '(bvuge x y)'
3605  """
3606  a, b = _coerce_exprs(self, other)
3607  return BoolRef(Z3_mk_bvsge(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3608 
3609  def __rshift__(self, other):
3610  """Create the Z3 expression (arithmetical) right shift `self >> other`
3611 
3612  Use the function LShR() for the right logical shift
3613 
3614  >>> x, y = BitVecs('x y', 32)
3615  >>> x >> y
3616  x >> y
3617  >>> (x >> y).sexpr()
3618  '(bvashr x y)'
3619  >>> LShR(x, y).sexpr()
3620  '(bvlshr x y)'
3621  >>> BitVecVal(4, 3)
3622  4
3623  >>> BitVecVal(4, 3).as_signed_long()
3624  -4
3625  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
3626  -2
3627  >>> simplify(BitVecVal(4, 3) >> 1)
3628  6
3629  >>> simplify(LShR(BitVecVal(4, 3), 1))
3630  2
3631  >>> simplify(BitVecVal(2, 3) >> 1)
3632  1
3633  >>> simplify(LShR(BitVecVal(2, 3), 1))
3634  1
3635  """
3636  a, b = _coerce_exprs(self, other)
3637  return BitVecRef(Z3_mk_bvashr(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3638 
3639  def __lshift__(self, other):
3640  """Create the Z3 expression left shift `self << other`
3641 
3642  >>> x, y = BitVecs('x y', 32)
3643  >>> x << y
3644  x << y
3645  >>> (x << y).sexpr()
3646  '(bvshl x y)'
3647  >>> simplify(BitVecVal(2, 3) << 1)
3648  4
3649  """
3650  a, b = _coerce_exprs(self, other)
3651  return BitVecRef(Z3_mk_bvshl(self.ctx_refctx_ref(), a.as_ast(), b.as_ast()), self.ctxctx)
3652 
3653  def __rrshift__(self, other):
3654  """Create the Z3 expression (arithmetical) right shift `other` >> `self`.
3655 
3656  Use the function LShR() for the right logical shift
3657 
3658  >>> x = BitVec('x', 32)
3659  >>> 10 >> x
3660  10 >> x
3661  >>> (10 >> x).sexpr()
3662  '(bvashr #x0000000a x)'
3663  """
3664  a, b = _coerce_exprs(self, other)
3665  return BitVecRef(Z3_mk_bvashr(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3666 
3667  def __rlshift__(self, other):
3668  """Create the Z3 expression left shift `other << self`.
3669 
3670  Use the function LShR() for the right logical shift
3671 
3672  >>> x = BitVec('x', 32)
3673  >>> 10 << x
3674  10 << x
3675  >>> (10 << x).sexpr()
3676  '(bvshl #x0000000a x)'
3677  """
3678  a, b = _coerce_exprs(self, other)
3679  return BitVecRef(Z3_mk_bvshl(self.ctx_refctx_ref(), b.as_ast(), a.as_ast()), self.ctxctx)
3680 
3682  """Bit-vector values."""
3683 
3684  def as_long(self):
3685  """Return a Z3 bit-vector numeral as a Python long (bignum) numeral.
3686 
3687  >>> v = BitVecVal(0xbadc0de, 32)
3688  >>> v
3689  195936478
3690  >>> print("0x%.8x" % v.as_long())
3691  0x0badc0de
3692  """
3693  return int(self.as_stringas_string())
3694 
3695  def as_signed_long(self):
3696  """Return a Z3 bit-vector numeral as a Python long (bignum) numeral. The most significant bit is assumed to be the sign.
3697 
3698  >>> BitVecVal(4, 3).as_signed_long()
3699  -4
3700  >>> BitVecVal(7, 3).as_signed_long()
3701  -1
3702  >>> BitVecVal(3, 3).as_signed_long()
3703  3
3704  >>> BitVecVal(2**32 - 1, 32).as_signed_long()
3705  -1
3706  >>> BitVecVal(2**64 - 1, 64).as_signed_long()
3707  -1
3708  """
3709  sz = self.sizesize()
3710  val = self.as_longas_long()
3711  if val >= 2**(sz - 1):
3712  val = val - 2**sz
3713  if val < -2**(sz - 1):
3714  val = val + 2**sz
3715  return int(val)
3716 
3717  def as_string(self):
3718  return Z3_get_numeral_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
3719 
3720  def as_binary_string(self):
3721  return Z3_get_numeral_binary_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
3722 
3723 
3724 def is_bv(a):
3725  """Return `True` if `a` is a Z3 bit-vector expression.
3726 
3727  >>> b = BitVec('b', 32)
3728  >>> is_bv(b)
3729  True
3730  >>> is_bv(b + 10)
3731  True
3732  >>> is_bv(Int('x'))
3733  False
3734  """
3735  return isinstance(a, BitVecRef)
3736 
3738  """Return `True` if `a` is a Z3 bit-vector numeral value.
3739 
3740  >>> b = BitVec('b', 32)
3741  >>> is_bv_value(b)
3742  False
3743  >>> b = BitVecVal(10, 32)
3744  >>> b
3745  10
3746  >>> is_bv_value(b)
3747  True
3748  """
3749  return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3750 
3751 def BV2Int(a, is_signed=False):
3752  """Return the Z3 expression BV2Int(a).
3753 
3754  >>> b = BitVec('b', 3)
3755  >>> BV2Int(b).sort()
3756  Int
3757  >>> x = Int('x')
3758  >>> x > BV2Int(b)
3759  x > BV2Int(b)
3760  >>> x > BV2Int(b, is_signed=False)
3761  x > BV2Int(b)
3762  >>> x > BV2Int(b, is_signed=True)
3763  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3764  >>> solve(x > BV2Int(b), b == 1, x < 3)
3765  [x = 2, b = 1]
3766  """
3767  if z3_debug():
3768  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3769  ctx = a.ctx
3770 
3771  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3772 
3773 def Int2BV(a, num_bits):
3774  """Return the z3 expression Int2BV(a, num_bits).
3775  It is a bit-vector of width num_bits and represents the
3776  modulo of a by 2^num_bits
3777  """
3778  ctx = a.ctx
3779  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3780 
3781 def BitVecSort(sz, ctx=None):
3782  """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3783 
3784  >>> Byte = BitVecSort(8)
3785  >>> Word = BitVecSort(16)
3786  >>> Byte
3787  BitVec(8)
3788  >>> x = Const('x', Byte)
3789  >>> eq(x, BitVec('x', 8))
3790  True
3791  """
3792  ctx = _get_ctx(ctx)
3793  return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
3794 
3795 def BitVecVal(val, bv, ctx=None):
3796  """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
3797 
3798  >>> v = BitVecVal(10, 32)
3799  >>> v
3800  10
3801  >>> print("0x%.8x" % v.as_long())
3802  0x0000000a
3803  """
3804  if is_bv_sort(bv):
3805  ctx = bv.ctx
3806  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
3807  else:
3808  ctx = _get_ctx(ctx)
3809  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
3810 
3811 def BitVec(name, bv, ctx=None):
3812  """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
3813  If `ctx=None`, then the global context is used.
3814 
3815  >>> x = BitVec('x', 16)
3816  >>> is_bv(x)
3817  True
3818  >>> x.size()
3819  16
3820  >>> x.sort()
3821  BitVec(16)
3822  >>> word = BitVecSort(16)
3823  >>> x2 = BitVec('x', word)
3824  >>> eq(x, x2)
3825  True
3826  """
3827  if isinstance(bv, BitVecSortRef):
3828  ctx = bv.ctx
3829  else:
3830  ctx = _get_ctx(ctx)
3831  bv = BitVecSort(bv, ctx)
3832  return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
3833 
3834 def BitVecs(names, bv, ctx=None):
3835  """Return a tuple of bit-vector constants of size bv.
3836 
3837  >>> x, y, z = BitVecs('x y z', 16)
3838  >>> x.size()
3839  16
3840  >>> x.sort()
3841  BitVec(16)
3842  >>> Sum(x, y, z)
3843  0 + x + y + z
3844  >>> Product(x, y, z)
3845  1*x*y*z
3846  >>> simplify(Product(x, y, z))
3847  x*y*z
3848  """
3849  ctx = _get_ctx(ctx)
3850  if isinstance(names, str):
3851  names = names.split(" ")
3852  return [BitVec(name, bv, ctx) for name in names]
3853 
3854 def Concat(*args):
3855  """Create a Z3 bit-vector concatenation expression.
3856 
3857  >>> v = BitVecVal(1, 4)
3858  >>> Concat(v, v+1, v)
3859  Concat(Concat(1, 1 + 1), 1)
3860  >>> simplify(Concat(v, v+1, v))
3861  289
3862  >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
3863  121
3864  """
3865  args = _get_args(args)
3866  sz = len(args)
3867  if z3_debug():
3868  _z3_assert(sz >= 2, "At least two arguments expected.")
3869 
3870  ctx = None
3871  for a in args:
3872  if is_expr(a):
3873  ctx = a.ctx
3874  break
3875  if is_seq(args[0]) or isinstance(args[0], str):
3876  args = [_coerce_seq(s, ctx) for s in args]
3877  if z3_debug():
3878  _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
3879  v = (Ast * sz)()
3880  for i in range(sz):
3881  v[i] = args[i].as_ast()
3882  return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
3883 
3884  if is_re(args[0]):
3885  if z3_debug():
3886  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
3887  v = (Ast * sz)()
3888  for i in range(sz):
3889  v[i] = args[i].as_ast()
3890  return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
3891 
3892  if z3_debug():
3893  _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
3894  r = args[0]
3895  for i in range(sz - 1):
3896  r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i+1].as_ast()), ctx)
3897  return r
3898 
3899 def Extract(high, low, a):
3900  """Create a Z3 bit-vector extraction expression, or create a string extraction expression.
3901 
3902  >>> x = BitVec('x', 8)
3903  >>> Extract(6, 2, x)
3904  Extract(6, 2, x)
3905  >>> Extract(6, 2, x).sort()
3906  BitVec(5)
3907  >>> simplify(Extract(StringVal("abcd"),2,1))
3908  "c"
3909  """
3910  if isinstance(high, str):
3911  high = StringVal(high)
3912  if is_seq(high):
3913  s = high
3914  offset, length = _coerce_exprs(low, a, s.ctx)
3915  return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
3916  if z3_debug():
3917  _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
3918  _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0, "First and second arguments must be non negative integers")
3919  _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
3920  return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
3921 
3922 def _check_bv_args(a, b):
3923  if z3_debug():
3924  _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
3925 
3926 def ULE(a, b):
3927  """Create the Z3 expression (unsigned) `other <= self`.
3928 
3929  Use the operator <= for signed less than or equal to.
3930 
3931  >>> x, y = BitVecs('x y', 32)
3932  >>> ULE(x, y)
3933  ULE(x, y)
3934  >>> (x <= y).sexpr()
3935  '(bvsle x y)'
3936  >>> ULE(x, y).sexpr()
3937  '(bvule x y)'
3938  """
3939  _check_bv_args(a, b)
3940  a, b = _coerce_exprs(a, b)
3941  return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3942 
3943 def ULT(a, b):
3944  """Create the Z3 expression (unsigned) `other < self`.
3945 
3946  Use the operator < for signed less than.
3947 
3948  >>> x, y = BitVecs('x y', 32)
3949  >>> ULT(x, y)
3950  ULT(x, y)
3951  >>> (x < y).sexpr()
3952  '(bvslt x y)'
3953  >>> ULT(x, y).sexpr()
3954  '(bvult x y)'
3955  """
3956  _check_bv_args(a, b)
3957  a, b = _coerce_exprs(a, b)
3958  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3959 
3960 def UGE(a, b):
3961  """Create the Z3 expression (unsigned) `other >= self`.
3962 
3963  Use the operator >= for signed greater than or equal to.
3964 
3965  >>> x, y = BitVecs('x y', 32)
3966  >>> UGE(x, y)
3967  UGE(x, y)
3968  >>> (x >= y).sexpr()
3969  '(bvsge x y)'
3970  >>> UGE(x, y).sexpr()
3971  '(bvuge x y)'
3972  """
3973  _check_bv_args(a, b)
3974  a, b = _coerce_exprs(a, b)
3975  return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3976 
3977 def UGT(a, b):
3978  """Create the Z3 expression (unsigned) `other > self`.
3979 
3980  Use the operator > for signed greater than.
3981 
3982  >>> x, y = BitVecs('x y', 32)
3983  >>> UGT(x, y)
3984  UGT(x, y)
3985  >>> (x > y).sexpr()
3986  '(bvsgt x y)'
3987  >>> UGT(x, y).sexpr()
3988  '(bvugt x y)'
3989  """
3990  _check_bv_args(a, b)
3991  a, b = _coerce_exprs(a, b)
3992  return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3993 
3994 def UDiv(a, b):
3995  """Create the Z3 expression (unsigned) division `self / other`.
3996 
3997  Use the operator / for signed division.
3998 
3999  >>> x = BitVec('x', 32)
4000  >>> y = BitVec('y', 32)
4001  >>> UDiv(x, y)
4002  UDiv(x, y)
4003  >>> UDiv(x, y).sort()
4004  BitVec(32)
4005  >>> (x / y).sexpr()
4006  '(bvsdiv x y)'
4007  >>> UDiv(x, y).sexpr()
4008  '(bvudiv x y)'
4009  """
4010  _check_bv_args(a, b)
4011  a, b = _coerce_exprs(a, b)
4012  return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4013 
4014 def URem(a, b):
4015  """Create the Z3 expression (unsigned) remainder `self % other`.
4016 
4017  Use the operator % for signed modulus, and SRem() for signed remainder.
4018 
4019  >>> x = BitVec('x', 32)
4020  >>> y = BitVec('y', 32)
4021  >>> URem(x, y)
4022  URem(x, y)
4023  >>> URem(x, y).sort()
4024  BitVec(32)
4025  >>> (x % y).sexpr()
4026  '(bvsmod x y)'
4027  >>> URem(x, y).sexpr()
4028  '(bvurem x y)'
4029  """
4030  _check_bv_args(a, b)
4031  a, b = _coerce_exprs(a, b)
4032  return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4033 
4034 def SRem(a, b):
4035  """Create the Z3 expression signed remainder.
4036 
4037  Use the operator % for signed modulus, and URem() for unsigned remainder.
4038 
4039  >>> x = BitVec('x', 32)
4040  >>> y = BitVec('y', 32)
4041  >>> SRem(x, y)
4042  SRem(x, y)
4043  >>> SRem(x, y).sort()
4044  BitVec(32)
4045  >>> (x % y).sexpr()
4046  '(bvsmod x y)'
4047  >>> SRem(x, y).sexpr()
4048  '(bvsrem x y)'
4049  """
4050  _check_bv_args(a, b)
4051  a, b = _coerce_exprs(a, b)
4052  return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4053 
4054 def LShR(a, b):
4055  """Create the Z3 expression logical right shift.
4056 
4057  Use the operator >> for the arithmetical right shift.
4058 
4059  >>> x, y = BitVecs('x y', 32)
4060  >>> LShR(x, y)
4061  LShR(x, y)
4062  >>> (x >> y).sexpr()
4063  '(bvashr x y)'
4064  >>> LShR(x, y).sexpr()
4065  '(bvlshr x y)'
4066  >>> BitVecVal(4, 3)
4067  4
4068  >>> BitVecVal(4, 3).as_signed_long()
4069  -4
4070  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4071  -2
4072  >>> simplify(BitVecVal(4, 3) >> 1)
4073  6
4074  >>> simplify(LShR(BitVecVal(4, 3), 1))
4075  2
4076  >>> simplify(BitVecVal(2, 3) >> 1)
4077  1
4078  >>> simplify(LShR(BitVecVal(2, 3), 1))
4079  1
4080  """
4081  _check_bv_args(a, b)
4082  a, b = _coerce_exprs(a, b)
4083  return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4084 
4085 def RotateLeft(a, b):
4086  """Return an expression representing `a` rotated to the left `b` times.
4087 
4088  >>> a, b = BitVecs('a b', 16)
4089  >>> RotateLeft(a, b)
4090  RotateLeft(a, b)
4091  >>> simplify(RotateLeft(a, 0))
4092  a
4093  >>> simplify(RotateLeft(a, 16))
4094  a
4095  """
4096  _check_bv_args(a, b)
4097  a, b = _coerce_exprs(a, b)
4098  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4099 
4100 def RotateRight(a, b):
4101  """Return an expression representing `a` rotated to the right `b` times.
4102 
4103  >>> a, b = BitVecs('a b', 16)
4104  >>> RotateRight(a, b)
4105  RotateRight(a, b)
4106  >>> simplify(RotateRight(a, 0))
4107  a
4108  >>> simplify(RotateRight(a, 16))
4109  a
4110  """
4111  _check_bv_args(a, b)
4112  a, b = _coerce_exprs(a, b)
4113  return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4114 
4115 def SignExt(n, a):
4116  """Return a bit-vector expression with `n` extra sign-bits.
4117 
4118  >>> x = BitVec('x', 16)
4119  >>> n = SignExt(8, x)
4120  >>> n.size()
4121  24
4122  >>> n
4123  SignExt(8, x)
4124  >>> n.sort()
4125  BitVec(24)
4126  >>> v0 = BitVecVal(2, 2)
4127  >>> v0
4128  2
4129  >>> v0.size()
4130  2
4131  >>> v = simplify(SignExt(6, v0))
4132  >>> v
4133  254
4134  >>> v.size()
4135  8
4136  >>> print("%.x" % v.as_long())
4137  fe
4138  """
4139  if z3_debug():
4140  _z3_assert(_is_int(n), "First argument must be an integer")
4141  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4142  return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4143 
4144 def ZeroExt(n, a):
4145  """Return a bit-vector expression with `n` extra zero-bits.
4146 
4147  >>> x = BitVec('x', 16)
4148  >>> n = ZeroExt(8, x)
4149  >>> n.size()
4150  24
4151  >>> n
4152  ZeroExt(8, x)
4153  >>> n.sort()
4154  BitVec(24)
4155  >>> v0 = BitVecVal(2, 2)
4156  >>> v0
4157  2
4158  >>> v0.size()
4159  2
4160  >>> v = simplify(ZeroExt(6, v0))
4161  >>> v
4162  2
4163  >>> v.size()
4164  8
4165  """
4166  if z3_debug():
4167  _z3_assert(_is_int(n), "First argument must be an integer")
4168  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4169  return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4170 
4171 def RepeatBitVec(n, a):
4172  """Return an expression representing `n` copies of `a`.
4173 
4174  >>> x = BitVec('x', 8)
4175  >>> n = RepeatBitVec(4, x)
4176  >>> n
4177  RepeatBitVec(4, x)
4178  >>> n.size()
4179  32
4180  >>> v0 = BitVecVal(10, 4)
4181  >>> print("%.x" % v0.as_long())
4182  a
4183  >>> v = simplify(RepeatBitVec(4, v0))
4184  >>> v.size()
4185  16
4186  >>> print("%.x" % v.as_long())
4187  aaaa
4188  """
4189  if z3_debug():
4190  _z3_assert(_is_int(n), "First argument must be an integer")
4191  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4192  return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4193 
4194 def BVRedAnd(a):
4195  """Return the reduction-and expression of `a`."""
4196  if z3_debug():
4197  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4198  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4199 
4200 def BVRedOr(a):
4201  """Return the reduction-or expression of `a`."""
4202  if z3_debug():
4203  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4204  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4205 
4206 def BVAddNoOverflow(a, b, signed):
4207  """A predicate the determines that bit-vector addition does not overflow"""
4208  _check_bv_args(a, b)
4209  a, b = _coerce_exprs(a, b)
4210  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4211 
4213  """A predicate the determines that signed bit-vector addition does not underflow"""
4214  _check_bv_args(a, b)
4215  a, b = _coerce_exprs(a, b)
4216  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4217 
4219  """A predicate the determines that bit-vector subtraction does not overflow"""
4220  _check_bv_args(a, b)
4221  a, b = _coerce_exprs(a, b)
4222  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4223 
4224 
4225 def BVSubNoUnderflow(a, b, signed):
4226  """A predicate the determines that bit-vector subtraction does not underflow"""
4227  _check_bv_args(a, b)
4228  a, b = _coerce_exprs(a, b)
4229  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4230 
4232  """A predicate the determines that bit-vector signed division does not overflow"""
4233  _check_bv_args(a, b)
4234  a, b = _coerce_exprs(a, b)
4235  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4236 
4238  """A predicate the determines that bit-vector unary negation does not overflow"""
4239  if z3_debug():
4240  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4241  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4242 
4243 def BVMulNoOverflow(a, b, signed):
4244  """A predicate the determines that bit-vector multiplication does not overflow"""
4245  _check_bv_args(a, b)
4246  a, b = _coerce_exprs(a, b)
4247  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4248 
4249 
4251  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4252  _check_bv_args(a, b)
4253  a, b = _coerce_exprs(a, b)
4254  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4255 
4256 
4257 
4258 
4263 
4265  """Array sorts."""
4266 
4267  def domain(self):
4268  """Return the domain of the array sort `self`.
4269 
4270  >>> A = ArraySort(IntSort(), BoolSort())
4271  >>> A.domain()
4272  Int
4273  """
4274  return _to_sort_ref(Z3_get_array_sort_domain(self.ctx_refctx_ref(), self.astast), self.ctxctx)
4275 
4276  def range(self):
4277  """Return the range of the array sort `self`.
4278 
4279  >>> A = ArraySort(IntSort(), BoolSort())
4280  >>> A.range()
4281  Bool
4282  """
4283  return _to_sort_ref(Z3_get_array_sort_range(self.ctx_refctx_ref(), self.astast), self.ctxctx)
4284 
4286  """Array expressions. """
4287 
4288  def sort(self):
4289  """Return the array sort of the array expression `self`.
4290 
4291  >>> a = Array('a', IntSort(), BoolSort())
4292  >>> a.sort()
4293  Array(Int, Bool)
4294  """
4295  return ArraySortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
4296 
4297  def domain(self):
4298  """Shorthand for `self.sort().domain()`.
4299 
4300  >>> a = Array('a', IntSort(), BoolSort())
4301  >>> a.domain()
4302  Int
4303  """
4304  return self.sortsortsort().domain()
4305 
4306  def range(self):
4307  """Shorthand for `self.sort().range()`.
4308 
4309  >>> a = Array('a', IntSort(), BoolSort())
4310  >>> a.range()
4311  Bool
4312  """
4313  return self.sortsortsort().range()
4314 
4315  def __getitem__(self, arg):
4316  """Return the Z3 expression `self[arg]`.
4317 
4318  >>> a = Array('a', IntSort(), BoolSort())
4319  >>> i = Int('i')
4320  >>> a[i]
4321  a[i]
4322  >>> a[i].sexpr()
4323  '(select a i)'
4324  """
4325  arg = self.domaindomain().cast(arg)
4326  return _to_expr_ref(Z3_mk_select(self.ctx_refctx_ref(), self.as_astas_astas_ast(), arg.as_ast()), self.ctxctx)
4327 
4328  def default(self):
4329  return _to_expr_ref(Z3_mk_array_default(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
4330 
4332  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4333 
4334 
4335 def is_array(a):
4336  """Return `True` if `a` is a Z3 array expression.
4337 
4338  >>> a = Array('a', IntSort(), IntSort())
4339  >>> is_array(a)
4340  True
4341  >>> is_array(Store(a, 0, 1))
4342  True
4343  >>> is_array(a[0])
4344  False
4345  """
4346  return isinstance(a, ArrayRef)
4347 
4349  """Return `True` if `a` is a Z3 constant array.
4350 
4351  >>> a = K(IntSort(), 10)
4352  >>> is_const_array(a)
4353  True
4354  >>> a = Array('a', IntSort(), IntSort())
4355  >>> is_const_array(a)
4356  False
4357  """
4358  return is_app_of(a, Z3_OP_CONST_ARRAY)
4359 
4360 def is_K(a):
4361  """Return `True` if `a` is a Z3 constant array.
4362 
4363  >>> a = K(IntSort(), 10)
4364  >>> is_K(a)
4365  True
4366  >>> a = Array('a', IntSort(), IntSort())
4367  >>> is_K(a)
4368  False
4369  """
4370  return is_app_of(a, Z3_OP_CONST_ARRAY)
4371 
4372 def is_map(a):
4373  """Return `True` if `a` is a Z3 map array expression.
4374 
4375  >>> f = Function('f', IntSort(), IntSort())
4376  >>> b = Array('b', IntSort(), IntSort())
4377  >>> a = Map(f, b)
4378  >>> a
4379  Map(f, b)
4380  >>> is_map(a)
4381  True
4382  >>> is_map(b)
4383  False
4384  """
4385  return is_app_of(a, Z3_OP_ARRAY_MAP)
4386 
4387 def is_default(a):
4388  """Return `True` if `a` is a Z3 default array expression.
4389  >>> d = Default(K(IntSort(), 10))
4390  >>> is_default(d)
4391  True
4392  """
4393  return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4394 
4396  """Return the function declaration associated with a Z3 map array expression.
4397 
4398  >>> f = Function('f', IntSort(), IntSort())
4399  >>> b = Array('b', IntSort(), IntSort())
4400  >>> a = Map(f, b)
4401  >>> eq(f, get_map_func(a))
4402  True
4403  >>> get_map_func(a)
4404  f
4405  >>> get_map_func(a)(0)
4406  f(0)
4407  """
4408  if z3_debug():
4409  _z3_assert(is_map(a), "Z3 array map expression expected.")
4410  return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx)
4411 
4412 def ArraySort(*sig):
4413  """Return the Z3 array sort with the given domain and range sorts.
4414 
4415  >>> A = ArraySort(IntSort(), BoolSort())
4416  >>> A
4417  Array(Int, Bool)
4418  >>> A.domain()
4419  Int
4420  >>> A.range()
4421  Bool
4422  >>> AA = ArraySort(IntSort(), A)
4423  >>> AA
4424  Array(Int, Array(Int, Bool))
4425  """
4426  sig = _get_args(sig)
4427  if z3_debug():
4428  _z3_assert(len(sig) > 1, "At least two arguments expected")
4429  arity = len(sig) - 1
4430  r = sig[arity]
4431  d = sig[0]
4432  if z3_debug():
4433  for s in sig:
4434  _z3_assert(is_sort(s), "Z3 sort expected")
4435  _z3_assert(s.ctx == r.ctx, "Context mismatch")
4436  ctx = d.ctx
4437  if len(sig) == 2:
4438  return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4439  dom = (Sort * arity)()
4440  for i in range(arity):
4441  dom[i] = sig[i].ast
4442  return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4443 
4444 def Array(name, dom, rng):
4445  """Return an array constant named `name` with the given domain and range sorts.
4446 
4447  >>> a = Array('a', IntSort(), IntSort())
4448  >>> a.sort()
4449  Array(Int, Int)
4450  >>> a[0]
4451  a[0]
4452  """
4453  s = ArraySort(dom, rng)
4454  ctx = s.ctx
4455  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4456 
4457 def Update(a, i, v):
4458  """Return a Z3 store array expression.
4459 
4460  >>> a = Array('a', IntSort(), IntSort())
4461  >>> i, v = Ints('i v')
4462  >>> s = Update(a, i, v)
4463  >>> s.sort()
4464  Array(Int, Int)
4465  >>> prove(s[i] == v)
4466  proved
4467  >>> j = Int('j')
4468  >>> prove(Implies(i != j, s[j] == a[j]))
4469  proved
4470  """
4471  if z3_debug():
4472  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4473  i = a.sort().domain().cast(i)
4474  v = a.sort().range().cast(v)
4475  ctx = a.ctx
4476  return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4477 
4478 def Default(a):
4479  """ Return a default value for array expression.
4480  >>> b = K(IntSort(), 1)
4481  >>> prove(Default(b) == 1)
4482  proved
4483  """
4484  if z3_debug():
4485  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4486  return a.default()
4487 
4488 
4489 def Store(a, i, v):
4490  """Return a Z3 store array expression.
4491 
4492  >>> a = Array('a', IntSort(), IntSort())
4493  >>> i, v = Ints('i v')
4494  >>> s = Store(a, i, v)
4495  >>> s.sort()
4496  Array(Int, Int)
4497  >>> prove(s[i] == v)
4498  proved
4499  >>> j = Int('j')
4500  >>> prove(Implies(i != j, s[j] == a[j]))
4501  proved
4502  """
4503  return Update(a, i, v)
4504 
4505 def Select(a, i):
4506  """Return a Z3 select array expression.
4507 
4508  >>> a = Array('a', IntSort(), IntSort())
4509  >>> i = Int('i')
4510  >>> Select(a, i)
4511  a[i]
4512  >>> eq(Select(a, i), a[i])
4513  True
4514  """
4515  if z3_debug():
4516  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4517  return a[i]
4518 
4519 
4520 def Map(f, *args):
4521  """Return a Z3 map array expression.
4522 
4523  >>> f = Function('f', IntSort(), IntSort(), IntSort())
4524  >>> a1 = Array('a1', IntSort(), IntSort())
4525  >>> a2 = Array('a2', IntSort(), IntSort())
4526  >>> b = Map(f, a1, a2)
4527  >>> b
4528  Map(f, a1, a2)
4529  >>> prove(b[0] == f(a1[0], a2[0]))
4530  proved
4531  """
4532  args = _get_args(args)
4533  if z3_debug():
4534  _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4535  _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4536  _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4537  _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4538  _args, sz = _to_ast_array(args)
4539  ctx = f.ctx
4540  return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4541 
4542 def K(dom, v):
4543  """Return a Z3 constant array expression.
4544 
4545  >>> a = K(IntSort(), 10)
4546  >>> a
4547  K(Int, 10)
4548  >>> a.sort()
4549  Array(Int, Int)
4550  >>> i = Int('i')
4551  >>> a[i]
4552  K(Int, 10)[i]
4553  >>> simplify(a[i])
4554  10
4555  """
4556  if z3_debug():
4557  _z3_assert(is_sort(dom), "Z3 sort expected")
4558  ctx = dom.ctx
4559  if not is_expr(v):
4560  v = _py2expr(v, ctx)
4561  return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4562 
4563 def Ext(a, b):
4564  """Return extensionality index for one-dimensional arrays.
4565  >> a, b = Consts('a b', SetSort(IntSort()))
4566  >> Ext(a, b)
4567  Ext(a, b)
4568  """
4569  ctx = a.ctx
4570  if z3_debug():
4571  _z3_assert(is_array_sort(a) and is_array(b), "arguments must be arrays")
4572  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4573 
4574 def SetHasSize(a, k):
4575  ctx = a.ctx
4576  k = _py2expr(k, ctx)
4577  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4578 
4579 def is_select(a):
4580  """Return `True` if `a` is a Z3 array select application.
4581 
4582  >>> a = Array('a', IntSort(), IntSort())
4583  >>> is_select(a)
4584  False
4585  >>> i = Int('i')
4586  >>> is_select(a[i])
4587  True
4588  """
4589  return is_app_of(a, Z3_OP_SELECT)
4590 
4591 def is_store(a):
4592  """Return `True` if `a` is a Z3 array store application.
4593 
4594  >>> a = Array('a', IntSort(), IntSort())
4595  >>> is_store(a)
4596  False
4597  >>> is_store(Store(a, 0, 1))
4598  True
4599  """
4600  return is_app_of(a, Z3_OP_STORE)
4601 
4602 
4607 
4608 
4609 def SetSort(s):
4610  """ Create a set sort over element sort s"""
4611  return ArraySort(s, BoolSort())
4612 
4613 def EmptySet(s):
4614  """Create the empty set
4615  >>> EmptySet(IntSort())
4616  K(Int, False)
4617  """
4618  ctx = s.ctx
4619  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4620 
4621 def FullSet(s):
4622  """Create the full set
4623  >>> FullSet(IntSort())
4624  K(Int, True)
4625  """
4626  ctx = s.ctx
4627  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4628 
4629 def SetUnion(*args):
4630  """ Take the union of sets
4631  >>> a = Const('a', SetSort(IntSort()))
4632  >>> b = Const('b', SetSort(IntSort()))
4633  >>> SetUnion(a, b)
4634  union(a, b)
4635  """
4636  args = _get_args(args)
4637  ctx = _ctx_from_ast_arg_list(args)
4638  _args, sz = _to_ast_array(args)
4639  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4640 
4641 def SetIntersect(*args):
4642  """ Take the union of sets
4643  >>> a = Const('a', SetSort(IntSort()))
4644  >>> b = Const('b', SetSort(IntSort()))
4645  >>> SetIntersect(a, b)
4646  intersection(a, b)
4647  """
4648  args = _get_args(args)
4649  ctx = _ctx_from_ast_arg_list(args)
4650  _args, sz = _to_ast_array(args)
4651  return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4652 
4653 def SetAdd(s, e):
4654  """ Add element e to set s
4655  >>> a = Const('a', SetSort(IntSort()))
4656  >>> SetAdd(a, 1)
4657  Store(a, 1, True)
4658  """
4659  ctx = _ctx_from_ast_arg_list([s,e])
4660  e = _py2expr(e, ctx)
4661  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4662 
4663 def SetDel(s, e):
4664  """ Remove element e to set s
4665  >>> a = Const('a', SetSort(IntSort()))
4666  >>> SetDel(a, 1)
4667  Store(a, 1, False)
4668  """
4669  ctx = _ctx_from_ast_arg_list([s,e])
4670  e = _py2expr(e, ctx)
4671  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4672 
4674  """ The complement of set s
4675  >>> a = Const('a', SetSort(IntSort()))
4676  >>> SetComplement(a)
4677  complement(a)
4678  """
4679  ctx = s.ctx
4680  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4681 
4682 def SetDifference(a, b):
4683  """ The set difference of a and b
4684  >>> a = Const('a', SetSort(IntSort()))
4685  >>> b = Const('b', SetSort(IntSort()))
4686  >>> SetDifference(a, b)
4687  setminus(a, b)
4688  """
4689  ctx = _ctx_from_ast_arg_list([a, b])
4690  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4691 
4692 def IsMember(e, s):
4693  """ Check if e is a member of set s
4694  >>> a = Const('a', SetSort(IntSort()))
4695  >>> IsMember(1, a)
4696  a[1]
4697  """
4698  ctx = _ctx_from_ast_arg_list([s,e])
4699  e = _py2expr(e, ctx)
4700  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
4701 
4702 def IsSubset(a, b):
4703  """ Check if a is a subset of b
4704  >>> a = Const('a', SetSort(IntSort()))
4705  >>> b = Const('b', SetSort(IntSort()))
4706  >>> IsSubset(a, b)
4707  subset(a, b)
4708  """
4709  ctx = _ctx_from_ast_arg_list([a, b])
4710  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4711 
4712 
4713 
4718 
4719 def _valid_accessor(acc):
4720  """Return `True` if acc is pair of the form (String, Datatype or Sort). """
4721  return isinstance(acc, tuple) and len(acc) == 2 and isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
4722 
4723 class Datatype:
4724  """Helper class for declaring Z3 datatypes.
4725 
4726  >>> List = Datatype('List')
4727  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4728  >>> List.declare('nil')
4729  >>> List = List.create()
4730  >>> # List is now a Z3 declaration
4731  >>> List.nil
4732  nil
4733  >>> List.cons(10, List.nil)
4734  cons(10, nil)
4735  >>> List.cons(10, List.nil).sort()
4736  List
4737  >>> cons = List.cons
4738  >>> nil = List.nil
4739  >>> car = List.car
4740  >>> cdr = List.cdr
4741  >>> n = cons(1, cons(0, nil))
4742  >>> n
4743  cons(1, cons(0, nil))
4744  >>> simplify(cdr(n))
4745  cons(0, nil)
4746  >>> simplify(car(n))
4747  1
4748  """
4749  def __init__(self, name, ctx=None):
4750  self.ctxctx = _get_ctx(ctx)
4751  self.namename = name
4752  self.constructorsconstructors = []
4753 
4754  def __deepcopy__(self, memo={}):
4755  r = Datatype(self.namename, self.ctxctx)
4756  r.constructors = copy.deepcopy(self.constructorsconstructors)
4757  return r
4758 
4759  def declare_core(self, name, rec_name, *args):
4760  if z3_debug():
4761  _z3_assert(isinstance(name, str), "String expected")
4762  _z3_assert(isinstance(rec_name, str), "String expected")
4763  _z3_assert(all([_valid_accessor(a) for a in args]), "Valid list of accessors expected. An accessor is a pair of the form (String, Datatype|Sort)")
4764  self.constructorsconstructors.append((name, rec_name, args))
4765 
4766  def declare(self, name, *args):
4767  """Declare constructor named `name` with the given accessors `args`.
4768  Each accessor is a pair `(name, sort)`, where `name` is a string and `sort` a Z3 sort or a reference to the datatypes being declared.
4769 
4770  In the following example `List.declare('cons', ('car', IntSort()), ('cdr', List))`
4771  declares the constructor named `cons` that builds a new List using an integer and a List.
4772  It also declares the accessors `car` and `cdr`. The accessor `car` extracts the integer of a `cons` cell,
4773  and `cdr` the list of a `cons` cell. After all constructors were declared, we use the method create() to create
4774  the actual datatype in Z3.
4775 
4776  >>> List = Datatype('List')
4777  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4778  >>> List.declare('nil')
4779  >>> List = List.create()
4780  """
4781  if z3_debug():
4782  _z3_assert(isinstance(name, str), "String expected")
4783  _z3_assert(name != "", "Constructor name cannot be empty")
4784  return self.declare_coredeclare_core(name, "is-" + name, *args)
4785 
4786  def __repr__(self):
4787  return "Datatype(%s, %s)" % (self.namename, self.constructorsconstructors)
4788 
4789  def create(self):
4790  """Create a Z3 datatype based on the constructors declared using the method `declare()`.
4791 
4792  The function `CreateDatatypes()` must be used to define mutually recursive datatypes.
4793 
4794  >>> List = Datatype('List')
4795  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4796  >>> List.declare('nil')
4797  >>> List = List.create()
4798  >>> List.nil
4799  nil
4800  >>> List.cons(10, List.nil)
4801  cons(10, nil)
4802  """
4803  return CreateDatatypes([self])[0]
4804 
4806  """Auxiliary object used to create Z3 datatypes."""
4807  def __init__(self, c, ctx):
4808  self.cc = c
4809  self.ctxctx = ctx
4810  def __del__(self):
4811  if self.ctxctx.ref() is not None:
4812  Z3_del_constructor(self.ctxctx.ref(), self.cc)
4813 
4815  """Auxiliary object used to create Z3 datatypes."""
4816  def __init__(self, c, ctx):
4817  self.cc = c
4818  self.ctxctx = ctx
4819  def __del__(self):
4820  if self.ctxctx.ref() is not None:
4821  Z3_del_constructor_list(self.ctxctx.ref(), self.cc)
4822 
4824  """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
4825 
4826  In the following example we define a Tree-List using two mutually recursive datatypes.
4827 
4828  >>> TreeList = Datatype('TreeList')
4829  >>> Tree = Datatype('Tree')
4830  >>> # Tree has two constructors: leaf and node
4831  >>> Tree.declare('leaf', ('val', IntSort()))
4832  >>> # a node contains a list of trees
4833  >>> Tree.declare('node', ('children', TreeList))
4834  >>> TreeList.declare('nil')
4835  >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
4836  >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
4837  >>> Tree.val(Tree.leaf(10))
4838  val(leaf(10))
4839  >>> simplify(Tree.val(Tree.leaf(10)))
4840  10
4841  >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
4842  >>> n1
4843  node(cons(leaf(10), cons(leaf(20), nil)))
4844  >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
4845  >>> simplify(n2 == n1)
4846  False
4847  >>> simplify(TreeList.car(Tree.children(n2)) == n1)
4848  True
4849  """
4850  ds = _get_args(ds)
4851  if z3_debug():
4852  _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
4853  _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
4854  _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
4855  _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
4856  ctx = ds[0].ctx
4857  num = len(ds)
4858  names = (Symbol * num)()
4859  out = (Sort * num)()
4860  clists = (ConstructorList * num)()
4861  to_delete = []
4862  for i in range(num):
4863  d = ds[i]
4864  names[i] = to_symbol(d.name, ctx)
4865  num_cs = len(d.constructors)
4866  cs = (Constructor * num_cs)()
4867  for j in range(num_cs):
4868  c = d.constructors[j]
4869  cname = to_symbol(c[0], ctx)
4870  rname = to_symbol(c[1], ctx)
4871  fs = c[2]
4872  num_fs = len(fs)
4873  fnames = (Symbol * num_fs)()
4874  sorts = (Sort * num_fs)()
4875  refs = (ctypes.c_uint * num_fs)()
4876  for k in range(num_fs):
4877  fname = fs[k][0]
4878  ftype = fs[k][1]
4879  fnames[k] = to_symbol(fname, ctx)
4880  if isinstance(ftype, Datatype):
4881  if z3_debug():
4882  _z3_assert(ds.count(ftype) == 1, "One and only one occurrence of each datatype is expected")
4883  sorts[k] = None
4884  refs[k] = ds.index(ftype)
4885  else:
4886  if z3_debug():
4887  _z3_assert(is_sort(ftype), "Z3 sort expected")
4888  sorts[k] = ftype.ast
4889  refs[k] = 0
4890  cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
4891  to_delete.append(ScopedConstructor(cs[j], ctx))
4892  clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
4893  to_delete.append(ScopedConstructorList(clists[i], ctx))
4894  Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
4895  result = []
4896 
4897  for i in range(num):
4898  dref = DatatypeSortRef(out[i], ctx)
4899  num_cs = dref.num_constructors()
4900  for j in range(num_cs):
4901  cref = dref.constructor(j)
4902  cref_name = cref.name()
4903  cref_arity = cref.arity()
4904  if cref.arity() == 0:
4905  cref = cref()
4906  setattr(dref, cref_name, cref)
4907  rref = dref.recognizer(j)
4908  setattr(dref, "is_" + cref_name, rref)
4909  for k in range(cref_arity):
4910  aref = dref.accessor(j, k)
4911  setattr(dref, aref.name(), aref)
4912  result.append(dref)
4913  return tuple(result)
4914 
4916  """Datatype sorts."""
4917  def num_constructors(self):
4918  """Return the number of constructors in the given Z3 datatype.
4919 
4920  >>> List = Datatype('List')
4921  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4922  >>> List.declare('nil')
4923  >>> List = List.create()
4924  >>> # List is now a Z3 declaration
4925  >>> List.num_constructors()
4926  2
4927  """
4928  return int(Z3_get_datatype_sort_num_constructors(self.ctx_refctx_ref(), self.astast))
4929 
4930  def constructor(self, idx):
4931  """Return a constructor of the datatype `self`.
4932 
4933  >>> List = Datatype('List')
4934  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4935  >>> List.declare('nil')
4936  >>> List = List.create()
4937  >>> # List is now a Z3 declaration
4938  >>> List.num_constructors()
4939  2
4940  >>> List.constructor(0)
4941  cons
4942  >>> List.constructor(1)
4943  nil
4944  """
4945  if z3_debug():
4946  _z3_assert(idx < self.num_constructorsnum_constructors(), "Invalid constructor index")
4947  return FuncDeclRef(Z3_get_datatype_sort_constructor(self.ctx_refctx_ref(), self.astast, idx), self.ctxctx)
4948 
4949  def recognizer(self, idx):
4950  """In Z3, each constructor has an associated recognizer predicate.
4951 
4952  If the constructor is named `name`, then the recognizer `is_name`.
4953 
4954  >>> List = Datatype('List')
4955  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4956  >>> List.declare('nil')
4957  >>> List = List.create()
4958  >>> # List is now a Z3 declaration
4959  >>> List.num_constructors()
4960  2
4961  >>> List.recognizer(0)
4962  is(cons)
4963  >>> List.recognizer(1)
4964  is(nil)
4965  >>> simplify(List.is_nil(List.cons(10, List.nil)))
4966  False
4967  >>> simplify(List.is_cons(List.cons(10, List.nil)))
4968  True
4969  >>> l = Const('l', List)
4970  >>> simplify(List.is_cons(l))
4971  is(cons, l)
4972  """
4973  if z3_debug():
4974  _z3_assert(idx < self.num_constructorsnum_constructors(), "Invalid recognizer index")
4975  return FuncDeclRef(Z3_get_datatype_sort_recognizer(self.ctx_refctx_ref(), self.astast, idx), self.ctxctx)
4976 
4977  def accessor(self, i, j):
4978  """In Z3, each constructor has 0 or more accessor. The number of accessors is equal to the arity of the constructor.
4979 
4980  >>> List = Datatype('List')
4981  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4982  >>> List.declare('nil')
4983  >>> List = List.create()
4984  >>> List.num_constructors()
4985  2
4986  >>> List.constructor(0)
4987  cons
4988  >>> num_accs = List.constructor(0).arity()
4989  >>> num_accs
4990  2
4991  >>> List.accessor(0, 0)
4992  car
4993  >>> List.accessor(0, 1)
4994  cdr
4995  >>> List.constructor(1)
4996  nil
4997  >>> num_accs = List.constructor(1).arity()
4998  >>> num_accs
4999  0
5000  """
5001  if z3_debug():
5002  _z3_assert(i < self.num_constructorsnum_constructors(), "Invalid constructor index")
5003  _z3_assert(j < self.constructorconstructor(i).arity(), "Invalid accessor index")
5004  return FuncDeclRef(Z3_get_datatype_sort_constructor_accessor(self.ctx_refctx_ref(), self.astast, i, j), self.ctxctx)
5005 
5007  """Datatype expressions."""
5008  def sort(self):
5009  """Return the datatype sort of the datatype expression `self`."""
5010  return DatatypeSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
5011 
5012 def TupleSort(name, sorts, ctx = None):
5013  """Create a named tuple sort base on a set of underlying sorts
5014  Example:
5015  >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
5016  """
5017  tuple = Datatype(name, ctx)
5018  projects = [ ('project%d' % i, sorts[i]) for i in range(len(sorts)) ]
5019  tuple.declare(name, *projects)
5020  tuple = tuple.create()
5021  return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5022 
5023 def DisjointSum(name, sorts, ctx=None):
5024  """Create a named tagged union sort base on a set of underlying sorts
5025  Example:
5026  >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5027  """
5028  sum = Datatype(name, ctx)
5029  for i in range(len(sorts)):
5030  sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5031  sum = sum.create()
5032  return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5033 
5034 
5035 def EnumSort(name, values, ctx=None):
5036  """Return a new enumeration sort named `name` containing the given values.
5037 
5038  The result is a pair (sort, list of constants).
5039  Example:
5040  >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5041  """
5042  if z3_debug():
5043  _z3_assert(isinstance(name, str), "Name must be a string")
5044  _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5045  _z3_assert(len(values) > 0, "At least one value expected")
5046  ctx = _get_ctx(ctx)
5047  num = len(values)
5048  _val_names = (Symbol * num)()
5049  for i in range(num):
5050  _val_names[i] = to_symbol(values[i])
5051  _values = (FuncDecl * num)()
5052  _testers = (FuncDecl * num)()
5053  name = to_symbol(name)
5054  S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5055  V = []
5056  for i in range(num):
5057  V.append(FuncDeclRef(_values[i], ctx))
5058  V = [a() for a in V]
5059  return S, V
5060 
5061 
5066 
5068  """Set of parameters used to configure Solvers, Tactics and Simplifiers in Z3.
5069 
5070  Consider using the function `args2params` to create instances of this object.
5071  """
5072  def __init__(self, ctx=None, params=None):
5073  self.ctxctx = _get_ctx(ctx)
5074  if params is None:
5075  self.paramsparams = Z3_mk_params(self.ctxctx.ref())
5076  else:
5077  self.paramsparams = params
5078  Z3_params_inc_ref(self.ctxctx.ref(), self.paramsparams)
5079 
5080  def __deepcopy__(self, memo={}):
5081  return ParamsRef(self.ctxctx, self.paramsparams)
5082 
5083  def __del__(self):
5084  if self.ctxctx.ref() is not None:
5085  Z3_params_dec_ref(self.ctxctx.ref(), self.paramsparams)
5086 
5087  def set(self, name, val):
5088  """Set parameter name with value val."""
5089  if z3_debug():
5090  _z3_assert(isinstance(name, str), "parameter name must be a string")
5091  name_sym = to_symbol(name, self.ctxctx)
5092  if isinstance(val, bool):
5093  Z3_params_set_bool(self.ctxctx.ref(), self.paramsparams, name_sym, val)
5094  elif _is_int(val):
5095  Z3_params_set_uint(self.ctxctx.ref(), self.paramsparams, name_sym, val)
5096  elif isinstance(val, float):
5097  Z3_params_set_double(self.ctxctx.ref(), self.paramsparams, name_sym, val)
5098  elif isinstance(val, str):
5099  Z3_params_set_symbol(self.ctxctx.ref(), self.paramsparams, name_sym, to_symbol(val, self.ctxctx))
5100  else:
5101  if z3_debug():
5102  _z3_assert(False, "invalid parameter value")
5103 
5104  def __repr__(self):
5105  return Z3_params_to_string(self.ctxctx.ref(), self.paramsparams)
5106 
5107  def validate(self, ds):
5108  _z3_assert(isinstance(ds, ParamDescrsRef), "parameter description set expected")
5109  Z3_params_validate(self.ctxctx.ref(), self.paramsparams, ds.descr)
5110 
5111 def args2params(arguments, keywords, ctx=None):
5112  """Convert python arguments into a Z3_params object.
5113  A ':' is added to the keywords, and '_' is replaced with '-'
5114 
5115  >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5116  (params model true relevancy 2 elim_and true)
5117  """
5118  if z3_debug():
5119  _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5120  prev = None
5121  r = ParamsRef(ctx)
5122  for a in arguments:
5123  if prev is None:
5124  prev = a
5125  else:
5126  r.set(prev, a)
5127  prev = None
5128  for k in keywords:
5129  v = keywords[k]
5130  r.set(k, v)
5131  return r
5132 
5134  """Set of parameter descriptions for Solvers, Tactics and Simplifiers in Z3.
5135  """
5136  def __init__(self, descr, ctx=None):
5137  _z3_assert(isinstance(descr, ParamDescrs), "parameter description object expected")
5138  self.ctxctx = _get_ctx(ctx)
5139  self.descrdescr = descr
5140  Z3_param_descrs_inc_ref(self.ctxctx.ref(), self.descrdescr)
5141 
5142  def __deepcopy__(self, memo={}):
5143  return ParamsDescrsRef(self.descrdescr, self.ctxctx)
5144 
5145  def __del__(self):
5146  if self.ctxctx.ref() is not None:
5147  Z3_param_descrs_dec_ref(self.ctxctx.ref(), self.descrdescr)
5148 
5149  def size(self):
5150  """Return the size of in the parameter description `self`.
5151  """
5152  return int(Z3_param_descrs_size(self.ctxctx.ref(), self.descrdescr))
5153 
5154  def __len__(self):
5155  """Return the size of in the parameter description `self`.
5156  """
5157  return self.sizesize()
5158 
5159  def get_name(self, i):
5160  """Return the i-th parameter name in the parameter description `self`.
5161  """
5162  return _symbol2py(self.ctxctx, Z3_param_descrs_get_name(self.ctxctx.ref(), self.descrdescr, i))
5163 
5164  def get_kind(self, n):
5165  """Return the kind of the parameter named `n`.
5166  """
5167  return Z3_param_descrs_get_kind(self.ctxctx.ref(), self.descrdescr, to_symbol(n, self.ctxctx))
5168 
5169  def get_documentation(self, n):
5170  """Return the documentation string of the parameter named `n`.
5171  """
5172  return Z3_param_descrs_get_documentation(self.ctxctx.ref(), self.descrdescr, to_symbol(n, self.ctxctx))
5173 
5174  def __getitem__(self, arg):
5175  if _is_int(arg):
5176  return self.get_nameget_name(arg)
5177  else:
5178  return self.get_kindget_kind(arg)
5179 
5180  def __repr__(self):
5181  return Z3_param_descrs_to_string(self.ctxctx.ref(), self.descrdescr)
5182 
5183 
5188 
5190  """Goal is a collection of constraints we want to find a solution or show to be unsatisfiable (infeasible).
5191 
5192  Goals are processed using Tactics. A Tactic transforms a goal into a set of subgoals.
5193  A goal has a solution if one of its subgoals has a solution.
5194  A goal is unsatisfiable if all subgoals are unsatisfiable.
5195  """
5196 
5197  def __init__(self, models=True, unsat_cores=False, proofs=False, ctx=None, goal=None):
5198  if z3_debug():
5199  _z3_assert(goal is None or ctx is not None, "If goal is different from None, then ctx must be also different from None")
5200  self.ctxctx = _get_ctx(ctx)
5201  self.goalgoal = goal
5202  if self.goalgoal is None:
5203  self.goalgoal = Z3_mk_goal(self.ctxctx.ref(), models, unsat_cores, proofs)
5204  Z3_goal_inc_ref(self.ctxctx.ref(), self.goalgoal)
5205 
5206  def __deepcopy__(self, memo={}):
5207  return Goal(False, False, False, self.ctxctx, self.goalgoal)
5208 
5209  def __del__(self):
5210  if self.goalgoal is not None and self.ctxctx.ref() is not None:
5211  Z3_goal_dec_ref(self.ctxctx.ref(), self.goalgoal)
5212 
5213  def depth(self):
5214  """Return the depth of the goal `self`. The depth corresponds to the number of tactics applied to `self`.
5215 
5216  >>> x, y = Ints('x y')
5217  >>> g = Goal()
5218  >>> g.add(x == 0, y >= x + 1)
5219  >>> g.depth()
5220  0
5221  >>> r = Then('simplify', 'solve-eqs')(g)
5222  >>> # r has 1 subgoal
5223  >>> len(r)
5224  1
5225  >>> r[0].depth()
5226  2
5227  """
5228  return int(Z3_goal_depth(self.ctxctx.ref(), self.goalgoal))
5229 
5230  def inconsistent(self):
5231  """Return `True` if `self` contains the `False` constraints.
5232 
5233  >>> x, y = Ints('x y')
5234  >>> g = Goal()
5235  >>> g.inconsistent()
5236  False
5237  >>> g.add(x == 0, x == 1)
5238  >>> g
5239  [x == 0, x == 1]
5240  >>> g.inconsistent()
5241  False
5242  >>> g2 = Tactic('propagate-values')(g)[0]
5243  >>> g2.inconsistent()
5244  True
5245  """
5246  return Z3_goal_inconsistent(self.ctxctx.ref(), self.goalgoal)
5247 
5248  def prec(self):
5249  """Return the precision (under-approximation, over-approximation, or precise) of the goal `self`.
5250 
5251  >>> g = Goal()
5252  >>> g.prec() == Z3_GOAL_PRECISE
5253  True
5254  >>> x, y = Ints('x y')
5255  >>> g.add(x == y + 1)
5256  >>> g.prec() == Z3_GOAL_PRECISE
5257  True
5258  >>> t = With(Tactic('add-bounds'), add_bound_lower=0, add_bound_upper=10)
5259  >>> g2 = t(g)[0]
5260  >>> g2
5261  [x == y + 1, x <= 10, x >= 0, y <= 10, y >= 0]
5262  >>> g2.prec() == Z3_GOAL_PRECISE
5263  False
5264  >>> g2.prec() == Z3_GOAL_UNDER
5265  True
5266  """
5267  return Z3_goal_precision(self.ctxctx.ref(), self.goalgoal)
5268 
5269  def precision(self):
5270  """Alias for `prec()`.
5271 
5272  >>> g = Goal()
5273  >>> g.precision() == Z3_GOAL_PRECISE
5274  True
5275  """
5276  return self.precprec()
5277 
5278  def size(self):
5279  """Return the number of constraints in the goal `self`.
5280 
5281  >>> g = Goal()
5282  >>> g.size()
5283  0
5284  >>> x, y = Ints('x y')
5285  >>> g.add(x == 0, y > x)
5286  >>> g.size()
5287  2
5288  """
5289  return int(Z3_goal_size(self.ctxctx.ref(), self.goalgoal))
5290 
5291  def __len__(self):
5292  """Return the number of constraints in the goal `self`.
5293 
5294  >>> g = Goal()
5295  >>> len(g)
5296  0
5297  >>> x, y = Ints('x y')
5298  >>> g.add(x == 0, y > x)
5299  >>> len(g)
5300  2
5301  """
5302  return self.sizesize()
5303 
5304  def get(self, i):
5305  """Return a constraint in the goal `self`.
5306 
5307  >>> g = Goal()
5308  >>> x, y = Ints('x y')
5309  >>> g.add(x == 0, y > x)
5310  >>> g.get(0)
5311  x == 0
5312  >>> g.get(1)
5313  y > x
5314  """
5315  return _to_expr_ref(Z3_goal_formula(self.ctxctx.ref(), self.goalgoal, i), self.ctxctx)
5316 
5317  def __getitem__(self, arg):
5318  """Return a constraint in the goal `self`.
5319 
5320  >>> g = Goal()
5321  >>> x, y = Ints('x y')
5322  >>> g.add(x == 0, y > x)
5323  >>> g[0]
5324  x == 0
5325  >>> g[1]
5326  y > x
5327  """
5328  if arg >= len(self):
5329  raise IndexError
5330  return self.getget(arg)
5331 
5332  def assert_exprs(self, *args):
5333  """Assert constraints into the goal.
5334 
5335  >>> x = Int('x')
5336  >>> g = Goal()
5337  >>> g.assert_exprs(x > 0, x < 2)
5338  >>> g
5339  [x > 0, x < 2]
5340  """
5341  args = _get_args(args)
5342  s = BoolSort(self.ctxctx)
5343  for arg in args:
5344  arg = s.cast(arg)
5345  Z3_goal_assert(self.ctxctx.ref(), self.goalgoal, arg.as_ast())
5346 
5347  def append(self, *args):
5348  """Add constraints.
5349 
5350  >>> x = Int('x')
5351  >>> g = Goal()
5352  >>> g.append(x > 0, x < 2)
5353  >>> g
5354  [x > 0, x < 2]
5355  """
5356  self.assert_exprsassert_exprs(*args)
5357 
5358  def insert(self, *args):
5359  """Add constraints.
5360 
5361  >>> x = Int('x')
5362  >>> g = Goal()
5363  >>> g.insert(x > 0, x < 2)
5364  >>> g
5365  [x > 0, x < 2]
5366  """
5367  self.assert_exprsassert_exprs(*args)
5368 
5369  def add(self, *args):
5370  """Add constraints.
5371 
5372  >>> x = Int('x')
5373  >>> g = Goal()
5374  >>> g.add(x > 0, x < 2)
5375  >>> g
5376  [x > 0, x < 2]
5377  """
5378  self.assert_exprsassert_exprs(*args)
5379 
5380  def convert_model(self, model):
5381  """Retrieve model from a satisfiable goal
5382  >>> a, b = Ints('a b')
5383  >>> g = Goal()
5384  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
5385  >>> t = Then(Tactic('split-clause'), Tactic('solve-eqs'))
5386  >>> r = t(g)
5387  >>> r[0]
5388  [Or(b == 0, b == 1), Not(0 <= b)]
5389  >>> r[1]
5390  [Or(b == 0, b == 1), Not(1 <= b)]
5391  >>> # Remark: the subgoal r[0] is unsatisfiable
5392  >>> # Creating a solver for solving the second subgoal
5393  >>> s = Solver()
5394  >>> s.add(r[1])
5395  >>> s.check()
5396  sat
5397  >>> s.model()
5398  [b = 0]
5399  >>> # Model s.model() does not assign a value to `a`
5400  >>> # It is a model for subgoal `r[1]`, but not for goal `g`
5401  >>> # The method convert_model creates a model for `g` from a model for `r[1]`.
5402  >>> r[1].convert_model(s.model())
5403  [b = 0, a = 1]
5404  """
5405  if z3_debug():
5406  _z3_assert(isinstance(model, ModelRef), "Z3 Model expected")
5407  return ModelRef(Z3_goal_convert_model(self.ctxctx.ref(), self.goalgoal, model.model), self.ctxctx)
5408 
5409  def __repr__(self):
5410  return obj_to_string(self)
5411 
5412  def sexpr(self):
5413  """Return a textual representation of the s-expression representing the goal."""
5414  return Z3_goal_to_string(self.ctxctx.ref(), self.goalgoal)
5415 
5416  def dimacs(self, include_names = True):
5417  """Return a textual representation of the goal in DIMACS format."""
5418  return Z3_goal_to_dimacs_string(self.ctxctx.ref(), self.goalgoal, include_names)
5419 
5420  def translate(self, target):
5421  """Copy goal `self` to context `target`.
5422 
5423  >>> x = Int('x')
5424  >>> g = Goal()
5425  >>> g.add(x > 10)
5426  >>> g
5427  [x > 10]
5428  >>> c2 = Context()
5429  >>> g2 = g.translate(c2)
5430  >>> g2
5431  [x > 10]
5432  >>> g.ctx == main_ctx()
5433  True
5434  >>> g2.ctx == c2
5435  True
5436  >>> g2.ctx == main_ctx()
5437  False
5438  """
5439  if z3_debug():
5440  _z3_assert(isinstance(target, Context), "target must be a context")
5441  return Goal(goal=Z3_goal_translate(self.ctxctx.ref(), self.goalgoal, target.ref()), ctx=target)
5442 
5443  def __copy__(self):
5444  return self.translatetranslate(self.ctxctx)
5445 
5446  def __deepcopy__(self, memo={}):
5447  return self.translatetranslate(self.ctxctx)
5448 
5449  def simplify(self, *arguments, **keywords):
5450  """Return a new simplified goal.
5451 
5452  This method is essentially invoking the simplify tactic.
5453 
5454  >>> g = Goal()
5455  >>> x = Int('x')
5456  >>> g.add(x + 1 >= 2)
5457  >>> g
5458  [x + 1 >= 2]
5459  >>> g2 = g.simplify()
5460  >>> g2
5461  [x >= 1]
5462  >>> # g was not modified
5463  >>> g
5464  [x + 1 >= 2]
5465  """
5466  t = Tactic('simplify')
5467  return t.apply(self, *arguments, **keywords)[0]
5468 
5469  def as_expr(self):
5470  """Return goal `self` as a single Z3 expression.
5471 
5472  >>> x = Int('x')
5473  >>> g = Goal()
5474  >>> g.as_expr()
5475  True
5476  >>> g.add(x > 1)
5477  >>> g.as_expr()
5478  x > 1
5479  >>> g.add(x < 10)
5480  >>> g.as_expr()
5481  And(x > 1, x < 10)
5482  """
5483  sz = len(self)
5484  if sz == 0:
5485  return BoolVal(True, self.ctxctx)
5486  elif sz == 1:
5487  return self.getget(0)
5488  else:
5489  return And([ self.getget(i) for i in range(len(self)) ], self.ctxctx)
5490 
5491 
5497  """A collection (vector) of ASTs."""
5498 
5499  def __init__(self, v=None, ctx=None):
5500  self.vectorvector = None
5501  if v is None:
5502  self.ctxctx = _get_ctx(ctx)
5503  self.vectorvector = Z3_mk_ast_vector(self.ctxctx.ref())
5504  else:
5505  self.vectorvector = v
5506  assert ctx is not None
5507  self.ctxctx = ctx
5508  Z3_ast_vector_inc_ref(self.ctxctx.ref(), self.vectorvector)
5509 
5510  def __deepcopy__(self, memo={}):
5511  return AstVector(self.vectorvector, self.ctxctx)
5512 
5513  def __del__(self):
5514  if self.vectorvector is not None and self.ctxctx.ref() is not None:
5515  Z3_ast_vector_dec_ref(self.ctxctx.ref(), self.vectorvector)
5516 
5517  def __len__(self):
5518  """Return the size of the vector `self`.
5519 
5520  >>> A = AstVector()
5521  >>> len(A)
5522  0
5523  >>> A.push(Int('x'))
5524  >>> A.push(Int('x'))
5525  >>> len(A)
5526  2
5527  """
5528  return int(Z3_ast_vector_size(self.ctxctx.ref(), self.vectorvector))
5529 
5530  def __getitem__(self, i):
5531  """Return the AST at position `i`.
5532 
5533  >>> A = AstVector()
5534  >>> A.push(Int('x') + 1)
5535  >>> A.push(Int('y'))
5536  >>> A[0]
5537  x + 1
5538  >>> A[1]
5539  y
5540  """
5541 
5542  if isinstance(i, int):
5543  if i < 0:
5544  i += self.__len____len__()
5545 
5546  if i >= self.__len____len__():
5547  raise IndexError
5548  return _to_ast_ref(Z3_ast_vector_get(self.ctxctx.ref(), self.vectorvector, i), self.ctxctx)
5549 
5550  elif isinstance(i, slice):
5551  return [_to_ast_ref(Z3_ast_vector_get(self.ctxctx.ref(), self.vectorvector, ii), self.ctxctx) for ii in range(*i.indices(self.__len____len__()))]
5552 
5553 
5554  def __setitem__(self, i, v):
5555  """Update AST at position `i`.
5556 
5557  >>> A = AstVector()
5558  >>> A.push(Int('x') + 1)
5559  >>> A.push(Int('y'))
5560  >>> A[0]
5561  x + 1
5562  >>> A[0] = Int('x')
5563  >>> A[0]
5564  x
5565  """
5566  if i >= self.__len____len__():
5567  raise IndexError
5568  Z3_ast_vector_set(self.ctxctx.ref(), self.vectorvector, i, v.as_ast())
5569 
5570  def push(self, v):
5571  """Add `v` in the end of the vector.
5572 
5573  >>> A = AstVector()
5574  >>> len(A)
5575  0
5576  >>> A.push(Int('x'))
5577  >>> len(A)
5578  1
5579  """
5580  Z3_ast_vector_push(self.ctxctx.ref(), self.vectorvector, v.as_ast())
5581 
5582  def resize(self, sz):
5583  """Resize the vector to `sz` elements.
5584 
5585  >>> A = AstVector()
5586  >>> A.resize(10)
5587  >>> len(A)
5588  10
5589  >>> for i in range(10): A[i] = Int('x')
5590  >>> A[5]
5591  x
5592  """
5593  Z3_ast_vector_resize(self.ctxctx.ref(), self.vectorvector, sz)
5594 
5595  def __contains__(self, item):
5596  """Return `True` if the vector contains `item`.
5597 
5598  >>> x = Int('x')
5599  >>> A = AstVector()
5600  >>> x in A
5601  False
5602  >>> A.push(x)
5603  >>> x in A
5604  True
5605  >>> (x+1) in A
5606  False
5607  >>> A.push(x+1)
5608  >>> (x+1) in A
5609  True
5610  >>> A
5611  [x, x + 1]
5612  """
5613  for elem in self:
5614  if elem.eq(item):
5615  return True
5616  return False
5617 
5618  def translate(self, other_ctx):
5619  """Copy vector `self` to context `other_ctx`.
5620 
5621  >>> x = Int('x')
5622  >>> A = AstVector()
5623  >>> A.push(x)
5624  >>> c2 = Context()
5625  >>> B = A.translate(c2)
5626  >>> B
5627  [x]
5628  """
5629  return AstVector(Z3_ast_vector_translate(self.ctxctx.ref(), self.vectorvector, other_ctx.ref()), other_ctx)
5630 
5631  def __copy__(self):
5632  return self.translatetranslate(self.ctxctx)
5633 
5634  def __deepcopy__(self, memo={}):
5635  return self.translatetranslate(self.ctxctx)
5636 
5637  def __repr__(self):
5638  return obj_to_string(self)
5639 
5640  def sexpr(self):
5641  """Return a textual representation of the s-expression representing the vector."""
5642  return Z3_ast_vector_to_string(self.ctxctx.ref(), self.vectorvector)
5643 
5644 
5649 class AstMap:
5650  """A mapping from ASTs to ASTs."""
5651 
5652  def __init__(self, m=None, ctx=None):
5653  self.mapmap = None
5654  if m is None:
5655  self.ctxctx = _get_ctx(ctx)
5656  self.mapmap = Z3_mk_ast_map(self.ctxctx.ref())
5657  else:
5658  self.mapmap = m
5659  assert ctx is not None
5660  self.ctxctx = ctx
5661  Z3_ast_map_inc_ref(self.ctxctx.ref(), self.mapmap)
5662 
5663  def __deepcopy__(self, memo={}):
5664  return AstMap(self.mapmap, self.ctxctx)
5665 
5666  def __del__(self):
5667  if self.mapmap is not None and self.ctxctx.ref() is not None:
5668  Z3_ast_map_dec_ref(self.ctxctx.ref(), self.mapmap)
5669 
5670  def __len__(self):
5671  """Return the size of the map.
5672 
5673  >>> M = AstMap()
5674  >>> len(M)
5675  0
5676  >>> x = Int('x')
5677  >>> M[x] = IntVal(1)
5678  >>> len(M)
5679  1
5680  """
5681  return int(Z3_ast_map_size(self.ctxctx.ref(), self.mapmap))
5682 
5683  def __contains__(self, key):
5684  """Return `True` if the map contains key `key`.
5685 
5686  >>> M = AstMap()
5687  >>> x = Int('x')
5688  >>> M[x] = x + 1
5689  >>> x in M
5690  True
5691  >>> x+1 in M
5692  False
5693  """
5694  return Z3_ast_map_contains(self.ctxctx.ref(), self.mapmap, key.as_ast())
5695 
5696  def __getitem__(self, key):
5697  """Retrieve the value associated with key `key`.
5698 
5699  >>> M = AstMap()
5700  >>> x = Int('x')
5701  >>> M[x] = x + 1
5702  >>> M[x]
5703  x + 1
5704  """
5705  return _to_ast_ref(Z3_ast_map_find(self.ctxctx.ref(), self.mapmap, key.as_ast()), self.ctxctx)
5706 
5707  def __setitem__(self, k, v):
5708  """Add/Update key `k` with value `v`.
5709 
5710  >>> M = AstMap()
5711  >>> x = Int('x')
5712  >>> M[x] = x + 1
5713  >>> len(M)
5714  1
5715  >>> M[x]
5716  x + 1
5717  >>> M[x] = IntVal(1)
5718  >>> M[x]
5719  1
5720  """
5721  Z3_ast_map_insert(self.ctxctx.ref(), self.mapmap, k.as_ast(), v.as_ast())
5722 
5723  def __repr__(self):
5724  return Z3_ast_map_to_string(self.ctxctx.ref(), self.mapmap)
5725 
5726  def erase(self, k):
5727  """Remove the entry associated with key `k`.
5728 
5729  >>> M = AstMap()
5730  >>> x = Int('x')
5731  >>> M[x] = x + 1
5732  >>> len(M)
5733  1
5734  >>> M.erase(x)
5735  >>> len(M)
5736  0
5737  """
5738  Z3_ast_map_erase(self.ctxctx.ref(), self.mapmap, k.as_ast())
5739 
5740  def reset(self):
5741  """Remove all entries from the map.
5742 
5743  >>> M = AstMap()
5744  >>> x = Int('x')
5745  >>> M[x] = x + 1
5746  >>> M[x+x] = IntVal(1)
5747  >>> len(M)
5748  2
5749  >>> M.reset()
5750  >>> len(M)
5751  0
5752  """
5753  Z3_ast_map_reset(self.ctxctx.ref(), self.mapmap)
5754 
5755  def keys(self):
5756  """Return an AstVector containing all keys in the map.
5757 
5758  >>> M = AstMap()
5759  >>> x = Int('x')
5760  >>> M[x] = x + 1
5761  >>> M[x+x] = IntVal(1)
5762  >>> M.keys()
5763  [x, x + x]
5764  """
5765  return AstVector(Z3_ast_map_keys(self.ctxctx.ref(), self.mapmap), self.ctxctx)
5766 
5767 
5772 
5774  """Store the value of the interpretation of a function in a particular point."""
5775 
5776  def __init__(self, entry, ctx):
5777  self.entryentry = entry
5778  self.ctxctx = ctx
5779  Z3_func_entry_inc_ref(self.ctxctx.ref(), self.entryentry)
5780 
5781  def __deepcopy__(self, memo={}):
5782  return FuncEntry(self.entryentry, self.ctxctx)
5783 
5784  def __del__(self):
5785  if self.ctxctx.ref() is not None:
5786  Z3_func_entry_dec_ref(self.ctxctx.ref(), self.entryentry)
5787 
5788  def num_args(self):
5789  """Return the number of arguments in the given entry.
5790 
5791  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5792  >>> s = Solver()
5793  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5794  >>> s.check()
5795  sat
5796  >>> m = s.model()
5797  >>> f_i = m[f]
5798  >>> f_i.num_entries()
5799  1
5800  >>> e = f_i.entry(0)
5801  >>> e.num_args()
5802  2
5803  """
5804  return int(Z3_func_entry_get_num_args(self.ctxctx.ref(), self.entryentry))
5805 
5806  def arg_value(self, idx):
5807  """Return the value of argument `idx`.
5808 
5809  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5810  >>> s = Solver()
5811  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5812  >>> s.check()
5813  sat
5814  >>> m = s.model()
5815  >>> f_i = m[f]
5816  >>> f_i.num_entries()
5817  1
5818  >>> e = f_i.entry(0)
5819  >>> e
5820  [1, 2, 20]
5821  >>> e.num_args()
5822  2
5823  >>> e.arg_value(0)
5824  1
5825  >>> e.arg_value(1)
5826  2
5827  >>> try:
5828  ... e.arg_value(2)
5829  ... except IndexError:
5830  ... print("index error")
5831  index error
5832  """
5833  if idx >= self.num_argsnum_args():
5834  raise IndexError
5835  return _to_expr_ref(Z3_func_entry_get_arg(self.ctxctx.ref(), self.entryentry, idx), self.ctxctx)
5836 
5837  def value(self):
5838  """Return the value of the function at point `self`.
5839 
5840  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5841  >>> s = Solver()
5842  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5843  >>> s.check()
5844  sat
5845  >>> m = s.model()
5846  >>> f_i = m[f]
5847  >>> f_i.num_entries()
5848  1
5849  >>> e = f_i.entry(0)
5850  >>> e
5851  [1, 2, 20]
5852  >>> e.num_args()
5853  2
5854  >>> e.value()
5855  20
5856  """
5857  return _to_expr_ref(Z3_func_entry_get_value(self.ctxctx.ref(), self.entryentry), self.ctxctx)
5858 
5859  def as_list(self):
5860  """Return entry `self` as a Python list.
5861  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5862  >>> s = Solver()
5863  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5864  >>> s.check()
5865  sat
5866  >>> m = s.model()
5867  >>> f_i = m[f]
5868  >>> f_i.num_entries()
5869  1
5870  >>> e = f_i.entry(0)
5871  >>> e.as_list()
5872  [1, 2, 20]
5873  """
5874  args = [ self.arg_valuearg_value(i) for i in range(self.num_argsnum_args())]
5875  args.append(self.valuevalue())
5876  return args
5877 
5878  def __repr__(self):
5879  return repr(self.as_listas_list())
5880 
5882  """Stores the interpretation of a function in a Z3 model."""
5883 
5884  def __init__(self, f, ctx):
5885  self.ff = f
5886  self.ctxctx = ctx
5887  if self.ff is not None:
5888  Z3_func_interp_inc_ref(self.ctxctx.ref(), self.ff)
5889 
5890  def __deepcopy__(self, memo={}):
5891  return FuncInterp(self.ff, self.ctxctx)
5892 
5893  def __del__(self):
5894  if self.ff is not None and self.ctxctx.ref() is not None:
5895  Z3_func_interp_dec_ref(self.ctxctx.ref(), self.ff)
5896 
5897  def else_value(self):
5898  """
5899  Return the `else` value for a function interpretation.
5900  Return None if Z3 did not specify the `else` value for
5901  this object.
5902 
5903  >>> f = Function('f', IntSort(), IntSort())
5904  >>> s = Solver()
5905  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5906  >>> s.check()
5907  sat
5908  >>> m = s.model()
5909  >>> m[f]
5910  [2 -> 0, else -> 1]
5911  >>> m[f].else_value()
5912  1
5913  """
5914  r = Z3_func_interp_get_else(self.ctxctx.ref(), self.ff)
5915  if r:
5916  return _to_expr_ref(r, self.ctxctx)
5917  else:
5918  return None
5919 
5920  def num_entries(self):
5921  """Return the number of entries/points in the function interpretation `self`.
5922 
5923  >>> f = Function('f', IntSort(), IntSort())
5924  >>> s = Solver()
5925  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5926  >>> s.check()
5927  sat
5928  >>> m = s.model()
5929  >>> m[f]
5930  [2 -> 0, else -> 1]
5931  >>> m[f].num_entries()
5932  1
5933  """
5934  return int(Z3_func_interp_get_num_entries(self.ctxctx.ref(), self.ff))
5935 
5936  def arity(self):
5937  """Return the number of arguments for each entry in the function interpretation `self`.
5938 
5939  >>> f = Function('f', IntSort(), IntSort())
5940  >>> s = Solver()
5941  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5942  >>> s.check()
5943  sat
5944  >>> m = s.model()
5945  >>> m[f].arity()
5946  1
5947  """
5948  return int(Z3_func_interp_get_arity(self.ctxctx.ref(), self.ff))
5949 
5950  def entry(self, idx):
5951  """Return an entry at position `idx < self.num_entries()` in the function interpretation `self`.
5952 
5953  >>> f = Function('f', IntSort(), IntSort())
5954  >>> s = Solver()
5955  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5956  >>> s.check()
5957  sat
5958  >>> m = s.model()
5959  >>> m[f]
5960  [2 -> 0, else -> 1]
5961  >>> m[f].num_entries()
5962  1
5963  >>> m[f].entry(0)
5964  [2, 0]
5965  """
5966  if idx >= self.num_entriesnum_entries():
5967  raise IndexError
5968  return FuncEntry(Z3_func_interp_get_entry(self.ctxctx.ref(), self.ff, idx), self.ctxctx)
5969 
5970  def translate(self, other_ctx):
5971  """Copy model 'self' to context 'other_ctx'.
5972  """
5973  return ModelRef(Z3_model_translate(self.ctxctx.ref(), self.model, other_ctx.ref()), other_ctx)
5974 
5975  def __copy__(self):
5976  return self.translatetranslate(self.ctxctx)
5977 
5978  def __deepcopy__(self, memo={}):
5979  return self.translatetranslate(self.ctxctx)
5980 
5981  def as_list(self):
5982  """Return the function interpretation as a Python list.
5983  >>> f = Function('f', IntSort(), IntSort())
5984  >>> s = Solver()
5985  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5986  >>> s.check()
5987  sat
5988  >>> m = s.model()
5989  >>> m[f]
5990  [2 -> 0, else -> 1]
5991  >>> m[f].as_list()
5992  [[2, 0], 1]
5993  """
5994  r = [ self.entryentry(i).as_list() for i in range(self.num_entriesnum_entries())]
5995  r.append(self.else_valueelse_value())
5996  return r
5997 
5998  def __repr__(self):
5999  return obj_to_string(self)
6000 
6002  """Model/Solution of a satisfiability problem (aka system of constraints)."""
6003 
6004  def __init__(self, m, ctx):
6005  assert ctx is not None
6006  self.modelmodel = m
6007  self.ctxctx = ctx
6008  Z3_model_inc_ref(self.ctxctx.ref(), self.modelmodel)
6009 
6010  def __del__(self):
6011  if self.ctxctx.ref() is not None:
6012  Z3_model_dec_ref(self.ctxctx.ref(), self.modelmodel)
6013 
6014  def __repr__(self):
6015  return obj_to_string(self)
6016 
6017  def sexpr(self):
6018  """Return a textual representation of the s-expression representing the model."""
6019  return Z3_model_to_string(self.ctxctx.ref(), self.modelmodel)
6020 
6021  def eval(self, t, model_completion=False):
6022  """Evaluate the expression `t` in the model `self`. If `model_completion` is enabled, then a default interpretation is automatically added for symbols that do not have an interpretation in the model `self`.
6023 
6024  >>> x = Int('x')
6025  >>> s = Solver()
6026  >>> s.add(x > 0, x < 2)
6027  >>> s.check()
6028  sat
6029  >>> m = s.model()
6030  >>> m.eval(x + 1)
6031  2
6032  >>> m.eval(x == 1)
6033  True
6034  >>> y = Int('y')
6035  >>> m.eval(y + x)
6036  1 + y
6037  >>> m.eval(y)
6038  y
6039  >>> m.eval(y, model_completion=True)
6040  0
6041  >>> # Now, m contains an interpretation for y
6042  >>> m.eval(y + x)
6043  1
6044  """
6045  r = (Ast * 1)()
6046  if Z3_model_eval(self.ctxctx.ref(), self.modelmodel, t.as_ast(), model_completion, r):
6047  return _to_expr_ref(r[0], self.ctxctx)
6048  raise Z3Exception("failed to evaluate expression in the model")
6049 
6050  def evaluate(self, t, model_completion=False):
6051  """Alias for `eval`.
6052 
6053  >>> x = Int('x')
6054  >>> s = Solver()
6055  >>> s.add(x > 0, x < 2)
6056  >>> s.check()
6057  sat
6058  >>> m = s.model()
6059  >>> m.evaluate(x + 1)
6060  2
6061  >>> m.evaluate(x == 1)
6062  True
6063  >>> y = Int('y')
6064  >>> m.evaluate(y + x)
6065  1 + y
6066  >>> m.evaluate(y)
6067  y
6068  >>> m.evaluate(y, model_completion=True)
6069  0
6070  >>> # Now, m contains an interpretation for y
6071  >>> m.evaluate(y + x)
6072  1
6073  """
6074  return self.evaleval(t, model_completion)
6075 
6076  def __len__(self):
6077  """Return the number of constant and function declarations in the model `self`.
6078 
6079  >>> f = Function('f', IntSort(), IntSort())
6080  >>> x = Int('x')
6081  >>> s = Solver()
6082  >>> s.add(x > 0, f(x) != x)
6083  >>> s.check()
6084  sat
6085  >>> m = s.model()
6086  >>> len(m)
6087  2
6088  """
6089  return int(Z3_model_get_num_consts(self.ctxctx.ref(), self.modelmodel)) + int(Z3_model_get_num_funcs(self.ctxctx.ref(), self.modelmodel))
6090 
6091  def get_interp(self, decl):
6092  """Return the interpretation for a given declaration or constant.
6093 
6094  >>> f = Function('f', IntSort(), IntSort())
6095  >>> x = Int('x')
6096  >>> s = Solver()
6097  >>> s.add(x > 0, x < 2, f(x) == 0)
6098  >>> s.check()
6099  sat
6100  >>> m = s.model()
6101  >>> m[x]
6102  1
6103  >>> m[f]
6104  [else -> 0]
6105  """
6106  if z3_debug():
6107  _z3_assert(isinstance(decl, FuncDeclRef) or is_const(decl), "Z3 declaration expected")
6108  if is_const(decl):
6109  decl = decl.decl()
6110  try:
6111  if decl.arity() == 0:
6112  _r = Z3_model_get_const_interp(self.ctxctx.ref(), self.modelmodel, decl.ast)
6113  if _r.value is None:
6114  return None
6115  r = _to_expr_ref(_r, self.ctxctx)
6116  if is_as_array(r):
6117  return self.get_interpget_interp(get_as_array_func(r))
6118  else:
6119  return r
6120  else:
6121  return FuncInterp(Z3_model_get_func_interp(self.ctxctx.ref(), self.modelmodel, decl.ast), self.ctxctx)
6122  except Z3Exception:
6123  return None
6124 
6125  def num_sorts(self):
6126  """Return the number of uninterpreted sorts that contain an interpretation in the model `self`.
6127 
6128  >>> A = DeclareSort('A')
6129  >>> a, b = Consts('a b', A)
6130  >>> s = Solver()
6131  >>> s.add(a != b)
6132  >>> s.check()
6133  sat
6134  >>> m = s.model()
6135  >>> m.num_sorts()
6136  1
6137  """
6138  return int(Z3_model_get_num_sorts(self.ctxctx.ref(), self.modelmodel))
6139 
6140  def get_sort(self, idx):
6141  """Return the uninterpreted sort at position `idx` < self.num_sorts().
6142 
6143  >>> A = DeclareSort('A')
6144  >>> B = DeclareSort('B')
6145  >>> a1, a2 = Consts('a1 a2', A)
6146  >>> b1, b2 = Consts('b1 b2', B)
6147  >>> s = Solver()
6148  >>> s.add(a1 != a2, b1 != b2)
6149  >>> s.check()
6150  sat
6151  >>> m = s.model()
6152  >>> m.num_sorts()
6153  2
6154  >>> m.get_sort(0)
6155  A
6156  >>> m.get_sort(1)
6157  B
6158  """
6159  if idx >= self.num_sortsnum_sorts():
6160  raise IndexError
6161  return _to_sort_ref(Z3_model_get_sort(self.ctxctx.ref(), self.modelmodel, idx), self.ctxctx)
6162 
6163  def sorts(self):
6164  """Return all uninterpreted sorts that have an interpretation in the model `self`.
6165 
6166  >>> A = DeclareSort('A')
6167  >>> B = DeclareSort('B')
6168  >>> a1, a2 = Consts('a1 a2', A)
6169  >>> b1, b2 = Consts('b1 b2', B)
6170  >>> s = Solver()
6171  >>> s.add(a1 != a2, b1 != b2)
6172  >>> s.check()
6173  sat
6174  >>> m = s.model()
6175  >>> m.sorts()
6176  [A, B]
6177  """
6178  return [ self.get_sortget_sort(i) for i in range(self.num_sortsnum_sorts()) ]
6179 
6180  def get_universe(self, s):
6181  """Return the interpretation for the uninterpreted sort `s` in the model `self`.
6182 
6183  >>> A = DeclareSort('A')
6184  >>> a, b = Consts('a b', A)
6185  >>> s = Solver()
6186  >>> s.add(a != b)
6187  >>> s.check()
6188  sat
6189  >>> m = s.model()
6190  >>> m.get_universe(A)
6191  [A!val!0, A!val!1]
6192  """
6193  if z3_debug():
6194  _z3_assert(isinstance(s, SortRef), "Z3 sort expected")
6195  try:
6196  return AstVector(Z3_model_get_sort_universe(self.ctxctx.ref(), self.modelmodel, s.ast), self.ctxctx)
6197  except Z3Exception:
6198  return None
6199 
6200  def __getitem__(self, idx):
6201  """If `idx` is an integer, then the declaration at position `idx` in the model `self` is returned. If `idx` is a declaration, then the actual interpretation is returned.
6202 
6203  The elements can be retrieved using position or the actual declaration.
6204 
6205  >>> f = Function('f', IntSort(), IntSort())
6206  >>> x = Int('x')
6207  >>> s = Solver()
6208  >>> s.add(x > 0, x < 2, f(x) == 0)
6209  >>> s.check()
6210  sat
6211  >>> m = s.model()
6212  >>> len(m)
6213  2
6214  >>> m[0]
6215  x
6216  >>> m[1]
6217  f
6218  >>> m[x]
6219  1
6220  >>> m[f]
6221  [else -> 0]
6222  >>> for d in m: print("%s -> %s" % (d, m[d]))
6223  x -> 1
6224  f -> [else -> 0]
6225  """
6226  if _is_int(idx):
6227  if idx >= len(self):
6228  raise IndexError
6229  num_consts = Z3_model_get_num_consts(self.ctxctx.ref(), self.modelmodel)
6230  if (idx < num_consts):
6231  return FuncDeclRef(Z3_model_get_const_decl(self.ctxctx.ref(), self.modelmodel, idx), self.ctxctx)
6232  else:
6233  return FuncDeclRef(Z3_model_get_func_decl(self.ctxctx.ref(), self.modelmodel, idx - num_consts), self.ctxctx)
6234  if isinstance(idx, FuncDeclRef):
6235  return self.get_interpget_interp(idx)
6236  if is_const(idx):
6237  return self.get_interpget_interp(idx.decl())
6238  if isinstance(idx, SortRef):
6239  return self.get_universeget_universe(idx)
6240  if z3_debug():
6241  _z3_assert(False, "Integer, Z3 declaration, or Z3 constant expected")
6242  return None
6243 
6244  def decls(self):
6245  """Return a list with all symbols that have an interpretation in the model `self`.
6246  >>> f = Function('f', IntSort(), IntSort())
6247  >>> x = Int('x')
6248  >>> s = Solver()
6249  >>> s.add(x > 0, x < 2, f(x) == 0)
6250  >>> s.check()
6251  sat
6252  >>> m = s.model()
6253  >>> m.decls()
6254  [x, f]
6255  """
6256  r = []
6257  for i in range(Z3_model_get_num_consts(self.ctxctx.ref(), self.modelmodel)):
6258  r.append(FuncDeclRef(Z3_model_get_const_decl(self.ctxctx.ref(), self.modelmodel, i), self.ctxctx))
6259  for i in range(Z3_model_get_num_funcs(self.ctxctx.ref(), self.modelmodel)):
6260  r.append(FuncDeclRef(Z3_model_get_func_decl(self.ctxctx.ref(), self.modelmodel, i), self.ctxctx))
6261  return r
6262 
6263  def translate(self, target):
6264  """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
6265  """
6266  if z3_debug():
6267  _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
6268  model = Z3_model_translate(self.ctxctx.ref(), self.modelmodel, target.ref())
6269  return ModelRef(model, target)
6270 
6271  def __copy__(self):
6272  return self.translatetranslate(self.ctxctx)
6273 
6274  def __deepcopy__(self, memo={}):
6275  return self.translatetranslate(self.ctxctx)
6276 
6277 def Model(ctx = None):
6278  ctx = _get_ctx(ctx)
6279  return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6280 
6282  """Return true if n is a Z3 expression of the form (_ as-array f)."""
6283  return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6284 
6286  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6287  if z3_debug():
6288  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6289  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6290 
6291 
6297  """Statistics for `Solver.check()`."""
6298 
6299  def __init__(self, stats, ctx):
6300  self.statsstats = stats
6301  self.ctxctx = ctx
6302  Z3_stats_inc_ref(self.ctxctx.ref(), self.statsstats)
6303 
6304  def __deepcopy__(self, memo={}):
6305  return Statistics(self.statsstats, self.ctxctx)
6306 
6307  def __del__(self):
6308  if self.ctxctx.ref() is not None:
6309  Z3_stats_dec_ref(self.ctxctx.ref(), self.statsstats)
6310 
6311  def __repr__(self):
6312  if in_html_mode():
6313  out = io.StringIO()
6314  even = True
6315  out.write(u('<table border="1" cellpadding="2" cellspacing="0">'))
6316  for k, v in self:
6317  if even:
6318  out.write(u('<tr style="background-color:#CFCFCF">'))
6319  even = False
6320  else:
6321  out.write(u('<tr>'))
6322  even = True
6323  out.write(u('<td>%s</td><td>%s</td></tr>' % (k, v)))
6324  out.write(u('</table>'))
6325  return out.getvalue()
6326  else:
6327  return Z3_stats_to_string(self.ctxctx.ref(), self.statsstats)
6328 
6329  def __len__(self):
6330  """Return the number of statistical counters.
6331 
6332  >>> x = Int('x')
6333  >>> s = Then('simplify', 'nlsat').solver()
6334  >>> s.add(x > 0)
6335  >>> s.check()
6336  sat
6337  >>> st = s.statistics()
6338  >>> len(st)
6339  6
6340  """
6341  return int(Z3_stats_size(self.ctxctx.ref(), self.statsstats))
6342 
6343  def __getitem__(self, idx):
6344  """Return the value of statistical counter at position `idx`. The result is a pair (key, value).
6345 
6346  >>> x = Int('x')
6347  >>> s = Then('simplify', 'nlsat').solver()
6348  >>> s.add(x > 0)
6349  >>> s.check()
6350  sat
6351  >>> st = s.statistics()
6352  >>> len(st)
6353  6
6354  >>> st[0]
6355  ('nlsat propagations', 2)
6356  >>> st[1]
6357  ('nlsat stages', 2)
6358  """
6359  if idx >= len(self):
6360  raise IndexError
6361  if Z3_stats_is_uint(self.ctxctx.ref(), self.statsstats, idx):
6362  val = int(Z3_stats_get_uint_value(self.ctxctx.ref(), self.statsstats, idx))
6363  else:
6364  val = Z3_stats_get_double_value(self.ctxctx.ref(), self.statsstats, idx)
6365  return (Z3_stats_get_key(self.ctxctx.ref(), self.statsstats, idx), val)
6366 
6367  def keys(self):
6368  """Return the list of statistical counters.
6369 
6370  >>> x = Int('x')
6371  >>> s = Then('simplify', 'nlsat').solver()
6372  >>> s.add(x > 0)
6373  >>> s.check()
6374  sat
6375  >>> st = s.statistics()
6376  """
6377  return [Z3_stats_get_key(self.ctxctx.ref(), self.statsstats, idx) for idx in range(len(self))]
6378 
6379  def get_key_value(self, key):
6380  """Return the value of a particular statistical counter.
6381 
6382  >>> x = Int('x')
6383  >>> s = Then('simplify', 'nlsat').solver()
6384  >>> s.add(x > 0)
6385  >>> s.check()
6386  sat
6387  >>> st = s.statistics()
6388  >>> st.get_key_value('nlsat propagations')
6389  2
6390  """
6391  for idx in range(len(self)):
6392  if key == Z3_stats_get_key(self.ctxctx.ref(), self.statsstats, idx):
6393  if Z3_stats_is_uint(self.ctxctx.ref(), self.statsstats, idx):
6394  return int(Z3_stats_get_uint_value(self.ctxctx.ref(), self.statsstats, idx))
6395  else:
6396  return Z3_stats_get_double_value(self.ctxctx.ref(), self.statsstats, idx)
6397  raise Z3Exception("unknown key")
6398 
6399  def __getattr__(self, name):
6400  """Access the value of statistical using attributes.
6401 
6402  Remark: to access a counter containing blank spaces (e.g., 'nlsat propagations'),
6403  we should use '_' (e.g., 'nlsat_propagations').
6404 
6405  >>> x = Int('x')
6406  >>> s = Then('simplify', 'nlsat').solver()
6407  >>> s.add(x > 0)
6408  >>> s.check()
6409  sat
6410  >>> st = s.statistics()
6411  >>> st.nlsat_propagations
6412  2
6413  >>> st.nlsat_stages
6414  2
6415  """
6416  key = name.replace('_', ' ')
6417  try:
6418  return self.get_key_valueget_key_value(key)
6419  except Z3Exception:
6420  raise AttributeError
6421 
6422 
6428  """Represents the result of a satisfiability check: sat, unsat, unknown.
6429 
6430  >>> s = Solver()
6431  >>> s.check()
6432  sat
6433  >>> r = s.check()
6434  >>> isinstance(r, CheckSatResult)
6435  True
6436  """
6437 
6438  def __init__(self, r):
6439  self.rr = r
6440 
6441  def __deepcopy__(self, memo={}):
6442  return CheckSatResult(self.rr)
6443 
6444  def __eq__(self, other):
6445  return isinstance(other, CheckSatResult) and self.rr == other.r
6446 
6447  def __ne__(self, other):
6448  return not self.__eq____eq__(other)
6449 
6450  def __repr__(self):
6451  if in_html_mode():
6452  if self.rr == Z3_L_TRUE:
6453  return "<b>sat</b>"
6454  elif self.rr == Z3_L_FALSE:
6455  return "<b>unsat</b>"
6456  else:
6457  return "<b>unknown</b>"
6458  else:
6459  if self.rr == Z3_L_TRUE:
6460  return "sat"
6461  elif self.rr == Z3_L_FALSE:
6462  return "unsat"
6463  else:
6464  return "unknown"
6465 
6466  def _repr_html_(self):
6467  in_html = in_html_mode()
6468  set_html_mode(True)
6469  res = repr(self)
6470  set_html_mode(in_html)
6471  return res
6472 
6473 sat = CheckSatResult(Z3_L_TRUE)
6474 unsat = CheckSatResult(Z3_L_FALSE)
6475 unknown = CheckSatResult(Z3_L_UNDEF)
6476 
6478  """Solver API provides methods for implementing the main SMT 2.0 commands: push, pop, check, get-model, etc."""
6479 
6480  def __init__(self, solver=None, ctx=None, logFile=None):
6481  assert solver is None or ctx is not None
6482  self.ctxctx = _get_ctx(ctx)
6483  self.backtrack_levelbacktrack_level = 4000000000
6484  self.solversolver = None
6485  if solver is None:
6486  self.solversolver = Z3_mk_solver(self.ctxctx.ref())
6487  else:
6488  self.solversolver = solver
6489  Z3_solver_inc_ref(self.ctxctx.ref(), self.solversolver)
6490  if logFile is not None:
6491  self.setset("smtlib2_log", logFile)
6492 
6493  def __del__(self):
6494  if self.solversolver is not None and self.ctxctx.ref() is not None:
6495  Z3_solver_dec_ref(self.ctxctx.ref(), self.solversolver)
6496 
6497  def set(self, *args, **keys):
6498  """Set a configuration option. The method `help()` return a string containing all available options.
6499 
6500  >>> s = Solver()
6501  >>> # The option MBQI can be set using three different approaches.
6502  >>> s.set(mbqi=True)
6503  >>> s.set('MBQI', True)
6504  >>> s.set(':mbqi', True)
6505  """
6506  p = args2params(args, keys, self.ctxctx)
6507  Z3_solver_set_params(self.ctxctx.ref(), self.solversolver, p.params)
6508 
6509  def push(self):
6510  """Create a backtracking point.
6511 
6512  >>> x = Int('x')
6513  >>> s = Solver()
6514  >>> s.add(x > 0)
6515  >>> s
6516  [x > 0]
6517  >>> s.push()
6518  >>> s.add(x < 1)
6519  >>> s
6520  [x > 0, x < 1]
6521  >>> s.check()
6522  unsat
6523  >>> s.pop()
6524  >>> s.check()
6525  sat
6526  >>> s
6527  [x > 0]
6528  """
6529  Z3_solver_push(self.ctxctx.ref(), self.solversolver)
6530 
6531  def pop(self, num=1):
6532  """Backtrack \c num backtracking points.
6533 
6534  >>> x = Int('x')
6535  >>> s = Solver()
6536  >>> s.add(x > 0)
6537  >>> s
6538  [x > 0]
6539  >>> s.push()
6540  >>> s.add(x < 1)
6541  >>> s
6542  [x > 0, x < 1]
6543  >>> s.check()
6544  unsat
6545  >>> s.pop()
6546  >>> s.check()
6547  sat
6548  >>> s
6549  [x > 0]
6550  """
6551  Z3_solver_pop(self.ctxctx.ref(), self.solversolver, num)
6552 
6553  def num_scopes(self):
6554  """Return the current number of backtracking points.
6555 
6556  >>> s = Solver()
6557  >>> s.num_scopes()
6558  0L
6559  >>> s.push()
6560  >>> s.num_scopes()
6561  1L
6562  >>> s.push()
6563  >>> s.num_scopes()
6564  2L
6565  >>> s.pop()
6566  >>> s.num_scopes()
6567  1L
6568  """
6569  return Z3_solver_get_num_scopes(self.ctxctx.ref(), self.solversolver)
6570 
6571  def reset(self):
6572  """Remove all asserted constraints and backtracking points created using `push()`.
6573 
6574  >>> x = Int('x')
6575  >>> s = Solver()
6576  >>> s.add(x > 0)
6577  >>> s
6578  [x > 0]
6579  >>> s.reset()
6580  >>> s
6581  []
6582  """
6583  Z3_solver_reset(self.ctxctx.ref(), self.solversolver)
6584 
6585  def assert_exprs(self, *args):
6586  """Assert constraints into the solver.
6587 
6588  >>> x = Int('x')
6589  >>> s = Solver()
6590  >>> s.assert_exprs(x > 0, x < 2)
6591  >>> s
6592  [x > 0, x < 2]
6593  """
6594  args = _get_args(args)
6595  s = BoolSort(self.ctxctx)
6596  for arg in args:
6597  if isinstance(arg, Goal) or isinstance(arg, AstVector):
6598  for f in arg:
6599  Z3_solver_assert(self.ctxctx.ref(), self.solversolver, f.as_ast())
6600  else:
6601  arg = s.cast(arg)
6602  Z3_solver_assert(self.ctxctx.ref(), self.solversolver, arg.as_ast())
6603 
6604  def add(self, *args):
6605  """Assert constraints into the solver.
6606 
6607  >>> x = Int('x')
6608  >>> s = Solver()
6609  >>> s.add(x > 0, x < 2)
6610  >>> s
6611  [x > 0, x < 2]
6612  """
6613  self.assert_exprsassert_exprs(*args)
6614 
6615  def __iadd__(self, fml):
6616  self.addadd(fml)
6617  return self
6618 
6619  def append(self, *args):
6620  """Assert constraints into the solver.
6621 
6622  >>> x = Int('x')
6623  >>> s = Solver()
6624  >>> s.append(x > 0, x < 2)
6625  >>> s
6626  [x > 0, x < 2]
6627  """
6628  self.assert_exprsassert_exprs(*args)
6629 
6630  def insert(self, *args):
6631  """Assert constraints into the solver.
6632 
6633  >>> x = Int('x')
6634  >>> s = Solver()
6635  >>> s.insert(x > 0, x < 2)
6636  >>> s
6637  [x > 0, x < 2]
6638  """
6639  self.assert_exprsassert_exprs(*args)
6640 
6641  def assert_and_track(self, a, p):
6642  """Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.
6643 
6644  If `p` is a string, it will be automatically converted into a Boolean constant.
6645 
6646  >>> x = Int('x')
6647  >>> p3 = Bool('p3')
6648  >>> s = Solver()
6649  >>> s.set(unsat_core=True)
6650  >>> s.assert_and_track(x > 0, 'p1')
6651  >>> s.assert_and_track(x != 1, 'p2')
6652  >>> s.assert_and_track(x < 0, p3)
6653  >>> print(s.check())
6654  unsat
6655  >>> c = s.unsat_core()
6656  >>> len(c)
6657  2
6658  >>> Bool('p1') in c
6659  True
6660  >>> Bool('p2') in c
6661  False
6662  >>> p3 in c
6663  True
6664  """
6665  if isinstance(p, str):
6666  p = Bool(p, self.ctxctx)
6667  _z3_assert(isinstance(a, BoolRef), "Boolean expression expected")
6668  _z3_assert(isinstance(p, BoolRef) and is_const(p), "Boolean expression expected")
6669  Z3_solver_assert_and_track(self.ctxctx.ref(), self.solversolver, a.as_ast(), p.as_ast())
6670 
6671  def check(self, *assumptions):
6672  """Check whether the assertions in the given solver plus the optional assumptions are consistent or not.
6673 
6674  >>> x = Int('x')
6675  >>> s = Solver()
6676  >>> s.check()
6677  sat
6678  >>> s.add(x > 0, x < 2)
6679  >>> s.check()
6680  sat
6681  >>> s.model().eval(x)
6682  1
6683  >>> s.add(x < 1)
6684  >>> s.check()
6685  unsat
6686  >>> s.reset()
6687  >>> s.add(2**x == 4)
6688  >>> s.check()
6689  unknown
6690  """
6691  s = BoolSort(self.ctxctx)
6692  assumptions = _get_args(assumptions)
6693  num = len(assumptions)
6694  _assumptions = (Ast * num)()
6695  for i in range(num):
6696  _assumptions[i] = s.cast(assumptions[i]).as_ast()
6697  r = Z3_solver_check_assumptions(self.ctxctx.ref(), self.solversolver, num, _assumptions)
6698  return CheckSatResult(r)
6699 
6700  def model(self):
6701  """Return a model for the last `check()`.
6702 
6703  This function raises an exception if
6704  a model is not available (e.g., last `check()` returned unsat).
6705 
6706  >>> s = Solver()
6707  >>> a = Int('a')
6708  >>> s.add(a + 2 == 0)
6709  >>> s.check()
6710  sat
6711  >>> s.model()
6712  [a = -2]
6713  """
6714  try:
6715  return ModelRef(Z3_solver_get_model(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6716  except Z3Exception:
6717  raise Z3Exception("model is not available")
6718 
6719  def import_model_converter(self, other):
6720  """Import model converter from other into the current solver"""
6721  Z3_solver_import_model_converter(self.ctxctx.ref(), other.solver, self.solversolver)
6722 
6723  def unsat_core(self):
6724  """Return a subset (as an AST vector) of the assumptions provided to the last check().
6725 
6726  These are the assumptions Z3 used in the unsatisfiability proof.
6727  Assumptions are available in Z3. They are used to extract unsatisfiable cores.
6728  They may be also used to "retract" assumptions. Note that, assumptions are not really
6729  "soft constraints", but they can be used to implement them.
6730 
6731  >>> p1, p2, p3 = Bools('p1 p2 p3')
6732  >>> x, y = Ints('x y')
6733  >>> s = Solver()
6734  >>> s.add(Implies(p1, x > 0))
6735  >>> s.add(Implies(p2, y > x))
6736  >>> s.add(Implies(p2, y < 1))
6737  >>> s.add(Implies(p3, y > -3))
6738  >>> s.check(p1, p2, p3)
6739  unsat
6740  >>> core = s.unsat_core()
6741  >>> len(core)
6742  2
6743  >>> p1 in core
6744  True
6745  >>> p2 in core
6746  True
6747  >>> p3 in core
6748  False
6749  >>> # "Retracting" p2
6750  >>> s.check(p1, p3)
6751  sat
6752  """
6753  return AstVector(Z3_solver_get_unsat_core(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6754 
6755  def consequences(self, assumptions, variables):
6756  """Determine fixed values for the variables based on the solver state and assumptions.
6757  >>> s = Solver()
6758  >>> a, b, c, d = Bools('a b c d')
6759  >>> s.add(Implies(a,b), Implies(b, c))
6760  >>> s.consequences([a],[b,c,d])
6761  (sat, [Implies(a, b), Implies(a, c)])
6762  >>> s.consequences([Not(c),d],[a,b,c,d])
6763  (sat, [Implies(d, d), Implies(Not(c), Not(c)), Implies(Not(c), Not(b)), Implies(Not(c), Not(a))])
6764  """
6765  if isinstance(assumptions, list):
6766  _asms = AstVector(None, self.ctxctx)
6767  for a in assumptions:
6768  _asms.push(a)
6769  assumptions = _asms
6770  if isinstance(variables, list):
6771  _vars = AstVector(None, self.ctxctx)
6772  for a in variables:
6773  _vars.push(a)
6774  variables = _vars
6775  _z3_assert(isinstance(assumptions, AstVector), "ast vector expected")
6776  _z3_assert(isinstance(variables, AstVector), "ast vector expected")
6777  consequences = AstVector(None, self.ctxctx)
6778  r = Z3_solver_get_consequences(self.ctxctx.ref(), self.solversolver, assumptions.vector, variables.vector, consequences.vector)
6779  sz = len(consequences)
6780  consequences = [ consequences[i] for i in range(sz) ]
6781  return CheckSatResult(r), consequences
6782 
6783  def from_file(self, filename):
6784  """Parse assertions from a file"""
6785  Z3_solver_from_file(self.ctxctx.ref(), self.solversolver, filename)
6786 
6787  def from_string(self, s):
6788  """Parse assertions from a string"""
6789  Z3_solver_from_string(self.ctxctx.ref(), self.solversolver, s)
6790 
6791  def cube(self, vars = None):
6792  """Get set of cubes
6793  The method takes an optional set of variables that restrict which
6794  variables may be used as a starting point for cubing.
6795  If vars is not None, then the first case split is based on a variable in
6796  this set.
6797  """
6798  self.cube_vscube_vs = AstVector(None, self.ctxctx)
6799  if vars is not None:
6800  for v in vars:
6801  self.cube_vscube_vs.push(v)
6802  while True:
6803  lvl = self.backtrack_levelbacktrack_level
6804  self.backtrack_levelbacktrack_level = 4000000000
6805  r = AstVector(Z3_solver_cube(self.ctxctx.ref(), self.solversolver, self.cube_vscube_vs.vector, lvl), self.ctxctx)
6806  if (len(r) == 1 and is_false(r[0])):
6807  return
6808  yield r
6809  if (len(r) == 0):
6810  return
6811 
6812  def cube_vars(self):
6813  """Access the set of variables that were touched by the most recently generated cube.
6814  This set of variables can be used as a starting point for additional cubes.
6815  The idea is that variables that appear in clauses that are reduced by the most recent
6816  cube are likely more useful to cube on."""
6817  return self.cube_vscube_vs
6818 
6819  def proof(self):
6820  """Return a proof for the last `check()`. Proof construction must be enabled."""
6821  return _to_expr_ref(Z3_solver_get_proof(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6822 
6823  def assertions(self):
6824  """Return an AST vector containing all added constraints.
6825 
6826  >>> s = Solver()
6827  >>> s.assertions()
6828  []
6829  >>> a = Int('a')
6830  >>> s.add(a > 0)
6831  >>> s.add(a < 10)
6832  >>> s.assertions()
6833  [a > 0, a < 10]
6834  """
6835  return AstVector(Z3_solver_get_assertions(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6836 
6837  def units(self):
6838  """Return an AST vector containing all currently inferred units.
6839  """
6840  return AstVector(Z3_solver_get_units(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6841 
6842  def non_units(self):
6843  """Return an AST vector containing all atomic formulas in solver state that are not units.
6844  """
6845  return AstVector(Z3_solver_get_non_units(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6846 
6847  def trail_levels(self):
6848  """Return trail and decision levels of the solver state after a check() call.
6849  """
6850  trail = self.trailtrail()
6851  levels = (ctypes.c_uint * len(trail))()
6852  Z3_solver_get_levels(self.ctxctx.ref(), self.solversolver, trail.vector, len(trail), levels)
6853  return trail, levels
6854 
6855  def trail(self):
6856  """Return trail of the solver state after a check() call.
6857  """
6858  return AstVector(Z3_solver_get_trail(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6859 
6860  def statistics(self):
6861  """Return statistics for the last `check()`.
6862 
6863  >>> s = SimpleSolver()
6864  >>> x = Int('x')
6865  >>> s.add(x > 0)
6866  >>> s.check()
6867  sat
6868  >>> st = s.statistics()
6869  >>> st.get_key_value('final checks')
6870  1
6871  >>> len(st) > 0
6872  True
6873  >>> st[0] != 0
6874  True
6875  """
6876  return Statistics(Z3_solver_get_statistics(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6877 
6878  def reason_unknown(self):
6879  """Return a string describing why the last `check()` returned `unknown`.
6880 
6881  >>> x = Int('x')
6882  >>> s = SimpleSolver()
6883  >>> s.add(2**x == 4)
6884  >>> s.check()
6885  unknown
6886  >>> s.reason_unknown()
6887  '(incomplete (theory arithmetic))'
6888  """
6889  return Z3_solver_get_reason_unknown(self.ctxctx.ref(), self.solversolver)
6890 
6891  def help(self):
6892  """Display a string describing all available options."""
6893  print(Z3_solver_get_help(self.ctxctx.ref(), self.solversolver))
6894 
6895  def param_descrs(self):
6896  """Return the parameter description set."""
6897  return ParamDescrsRef(Z3_solver_get_param_descrs(self.ctxctx.ref(), self.solversolver), self.ctxctx)
6898 
6899  def __repr__(self):
6900  """Return a formatted string with all added constraints."""
6901  return obj_to_string(self)
6902 
6903  def translate(self, target):
6904  """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
6905 
6906  >>> c1 = Context()
6907  >>> c2 = Context()
6908  >>> s1 = Solver(ctx=c1)
6909  >>> s2 = s1.translate(c2)
6910  """
6911  if z3_debug():
6912  _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
6913  solver = Z3_solver_translate(self.ctxctx.ref(), self.solversolver, target.ref())
6914  return Solver(solver, target)
6915 
6916  def __copy__(self):
6917  return self.translatetranslate(self.ctxctx)
6918 
6919  def __deepcopy__(self, memo={}):
6920  return self.translatetranslate(self.ctxctx)
6921 
6922  def sexpr(self):
6923  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
6924 
6925  >>> x = Int('x')
6926  >>> s = Solver()
6927  >>> s.add(x > 0)
6928  >>> s.add(x < 2)
6929  >>> r = s.sexpr()
6930  """
6931  return Z3_solver_to_string(self.ctxctx.ref(), self.solversolver)
6932 
6933  def dimacs(self, include_names=True):
6934  """Return a textual representation of the solver in DIMACS format."""
6935  return Z3_solver_to_dimacs_string(self.ctxctx.ref(), self.solversolver, include_names)
6936 
6937  def to_smt2(self):
6938  """return SMTLIB2 formatted benchmark for solver's assertions"""
6939  es = self.assertionsassertions()
6940  sz = len(es)
6941  sz1 = sz
6942  if sz1 > 0:
6943  sz1 -= 1
6944  v = (Ast * sz1)()
6945  for i in range(sz1):
6946  v[i] = es[i].as_ast()
6947  if sz > 0:
6948  e = es[sz1].as_ast()
6949  else:
6950  e = BoolVal(True, self.ctxctx).as_ast()
6951  return Z3_benchmark_to_smtlib_string(self.ctxctx.ref(), "benchmark generated from python API", "", "unknown", "", sz1, v, e)
6952 
6953 def SolverFor(logic, ctx=None, logFile=None):
6954  """Create a solver customized for the given logic.
6955 
6956  The parameter `logic` is a string. It should be contains
6957  the name of a SMT-LIB logic.
6958  See http://www.smtlib.org/ for the name of all available logics.
6959 
6960  >>> s = SolverFor("QF_LIA")
6961  >>> x = Int('x')
6962  >>> s.add(x > 0)
6963  >>> s.add(x < 2)
6964  >>> s.check()
6965  sat
6966  >>> s.model()
6967  [x = 1]
6968  """
6969  ctx = _get_ctx(ctx)
6970  logic = to_symbol(logic)
6971  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6972 
6973 def SimpleSolver(ctx=None, logFile=None):
6974  """Return a simple general purpose solver with limited amount of preprocessing.
6975 
6976  >>> s = SimpleSolver()
6977  >>> x = Int('x')
6978  >>> s.add(x > 0)
6979  >>> s.check()
6980  sat
6981  """
6982  ctx = _get_ctx(ctx)
6983  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6984 
6985 
6990 
6992  """Fixedpoint API provides methods for solving with recursive predicates"""
6993 
6994  def __init__(self, fixedpoint=None, ctx=None):
6995  assert fixedpoint is None or ctx is not None
6996  self.ctxctx = _get_ctx(ctx)
6997  self.fixedpointfixedpoint = None
6998  if fixedpoint is None:
6999  self.fixedpointfixedpoint = Z3_mk_fixedpoint(self.ctxctx.ref())
7000  else:
7001  self.fixedpointfixedpoint = fixedpoint
7002  Z3_fixedpoint_inc_ref(self.ctxctx.ref(), self.fixedpointfixedpoint)
7003  self.varsvars = []
7004 
7005  def __deepcopy__(self, memo={}):
7006  return FixedPoint(self.fixedpointfixedpoint, self.ctxctx)
7007 
7008  def __del__(self):
7009  if self.fixedpointfixedpoint is not None and self.ctxctx.ref() is not None:
7010  Z3_fixedpoint_dec_ref(self.ctxctx.ref(), self.fixedpointfixedpoint)
7011 
7012  def set(self, *args, **keys):
7013  """Set a configuration option. The method `help()` return a string containing all available options.
7014  """
7015  p = args2params(args, keys, self.ctxctx)
7016  Z3_fixedpoint_set_params(self.ctxctx.ref(), self.fixedpointfixedpoint, p.params)
7017 
7018  def help(self):
7019  """Display a string describing all available options."""
7020  print(Z3_fixedpoint_get_help(self.ctxctx.ref(), self.fixedpointfixedpoint))
7021 
7022  def param_descrs(self):
7023  """Return the parameter description set."""
7024  return ParamDescrsRef(Z3_fixedpoint_get_param_descrs(self.ctxctx.ref(), self.fixedpointfixedpoint), self.ctxctx)
7025 
7026  def assert_exprs(self, *args):
7027  """Assert constraints as background axioms for the fixedpoint solver."""
7028  args = _get_args(args)
7029  s = BoolSort(self.ctxctx)
7030  for arg in args:
7031  if isinstance(arg, Goal) or isinstance(arg, AstVector):
7032  for f in arg:
7033  f = self.abstractabstract(f)
7034  Z3_fixedpoint_assert(self.ctxctx.ref(), self.fixedpointfixedpoint, f.as_ast())
7035  else:
7036  arg = s.cast(arg)
7037  arg = self.abstractabstract(arg)
7038  Z3_fixedpoint_assert(self.ctxctx.ref(), self.fixedpointfixedpoint, arg.as_ast())
7039 
7040  def add(self, *args):
7041  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7042  self.assert_exprsassert_exprs(*args)
7043 
7044  def __iadd__(self, fml):
7045  self.addadd(fml)
7046  return self
7047 
7048  def append(self, *args):
7049  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7050  self.assert_exprsassert_exprs(*args)
7051 
7052  def insert(self, *args):
7053  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7054  self.assert_exprsassert_exprs(*args)
7055 
7056  def add_rule(self, head, body = None, name = None):
7057  """Assert rules defining recursive predicates to the fixedpoint solver.
7058  >>> a = Bool('a')
7059  >>> b = Bool('b')
7060  >>> s = Fixedpoint()
7061  >>> s.register_relation(a.decl())
7062  >>> s.register_relation(b.decl())
7063  >>> s.fact(a)
7064  >>> s.rule(b, a)
7065  >>> s.query(b)
7066  sat
7067  """
7068  if name is None:
7069  name = ""
7070  name = to_symbol(name, self.ctxctx)
7071  if body is None:
7072  head = self.abstractabstract(head)
7073  Z3_fixedpoint_add_rule(self.ctxctx.ref(), self.fixedpointfixedpoint, head.as_ast(), name)
7074  else:
7075  body = _get_args(body)
7076  f = self.abstractabstract(Implies(And(body, self.ctxctx),head))
7077  Z3_fixedpoint_add_rule(self.ctxctx.ref(), self.fixedpointfixedpoint, f.as_ast(), name)
7078 
7079  def rule(self, head, body = None, name = None):
7080  """Assert rules defining recursive predicates to the fixedpoint solver. Alias for add_rule."""
7081  self.add_ruleadd_rule(head, body, name)
7082 
7083  def fact(self, head, name = None):
7084  """Assert facts defining recursive predicates to the fixedpoint solver. Alias for add_rule."""
7085  self.add_ruleadd_rule(head, None, name)
7086 
7087  def query(self, *query):
7088  """Query the fixedpoint engine whether formula is derivable.
7089  You can also pass an tuple or list of recursive predicates.
7090  """
7091  query = _get_args(query)
7092  sz = len(query)
7093  if sz >= 1 and isinstance(query[0], FuncDeclRef):
7094  _decls = (FuncDecl * sz)()
7095  i = 0
7096  for q in query:
7097  _decls[i] = q.ast
7098  i = i + 1
7099  r = Z3_fixedpoint_query_relations(self.ctxctx.ref(), self.fixedpointfixedpoint, sz, _decls)
7100  else:
7101  if sz == 1:
7102  query = query[0]
7103  else:
7104  query = And(query, self.ctxctx)
7105  query = self.abstractabstract(query, False)
7106  r = Z3_fixedpoint_query(self.ctxctx.ref(), self.fixedpointfixedpoint, query.as_ast())
7107  return CheckSatResult(r)
7108 
7109  def query_from_lvl (self, lvl, *query):
7110  """Query the fixedpoint engine whether formula is derivable starting at the given query level.
7111  """
7112  query = _get_args(query)
7113  sz = len(query)
7114  if sz >= 1 and isinstance(query[0], FuncDecl):
7115  _z3_assert (False, "unsupported")
7116  else:
7117  if sz == 1:
7118  query = query[0]
7119  else:
7120  query = And(query)
7121  query = self.abstractabstract(query, False)
7122  r = Z3_fixedpoint_query_from_lvl (self.ctxctx.ref(), self.fixedpointfixedpoint, query.as_ast(), lvl)
7123  return CheckSatResult(r)
7124 
7125  def update_rule(self, head, body, name):
7126  """update rule"""
7127  if name is None:
7128  name = ""
7129  name = to_symbol(name, self.ctxctx)
7130  body = _get_args(body)
7131  f = self.abstractabstract(Implies(And(body, self.ctxctx),head))
7132  Z3_fixedpoint_update_rule(self.ctxctx.ref(), self.fixedpointfixedpoint, f.as_ast(), name)
7133 
7134  def get_answer(self):
7135  """Retrieve answer from last query call."""
7136  r = Z3_fixedpoint_get_answer(self.ctxctx.ref(), self.fixedpointfixedpoint)
7137  return _to_expr_ref(r, self.ctxctx)
7138 
7140  """Retrieve a ground cex from last query call."""
7141  r = Z3_fixedpoint_get_ground_sat_answer(self.ctxctx.ref(), self.fixedpointfixedpoint)
7142  return _to_expr_ref(r, self.ctxctx)
7143 
7145  """retrieve rules along the counterexample trace"""
7146  return AstVector(Z3_fixedpoint_get_rules_along_trace(self.ctxctx.ref(), self.fixedpointfixedpoint), self.ctxctx)
7147 
7149  """retrieve rule names along the counterexample trace"""
7150  # this is a hack as I don't know how to return a list of symbols from C++;
7151  # obtain names as a single string separated by semicolons
7152  names = _symbol2py (self.ctxctx, Z3_fixedpoint_get_rule_names_along_trace(self.ctxctx.ref(), self.fixedpointfixedpoint))
7153  # split into individual names
7154  return names.split (';')
7155 
7156  def get_num_levels(self, predicate):
7157  """Retrieve number of levels used for predicate in PDR engine"""
7158  return Z3_fixedpoint_get_num_levels(self.ctxctx.ref(), self.fixedpointfixedpoint, predicate.ast)
7159 
7160  def get_cover_delta(self, level, predicate):
7161  """Retrieve properties known about predicate for the level'th unfolding. -1 is treated as the limit (infinity)"""
7162  r = Z3_fixedpoint_get_cover_delta(self.ctxctx.ref(), self.fixedpointfixedpoint, level, predicate.ast)
7163  return _to_expr_ref(r, self.ctxctx)
7164 
7165  def add_cover(self, level, predicate, property):
7166  """Add property to predicate for the level'th unfolding. -1 is treated as infinity (infinity)"""
7167  Z3_fixedpoint_add_cover(self.ctxctx.ref(), self.fixedpointfixedpoint, level, predicate.ast, property.ast)
7168 
7169  def register_relation(self, *relations):
7170  """Register relation as recursive"""
7171  relations = _get_args(relations)
7172  for f in relations:
7173  Z3_fixedpoint_register_relation(self.ctxctx.ref(), self.fixedpointfixedpoint, f.ast)
7174 
7175  def set_predicate_representation(self, f, *representations):
7176  """Control how relation is represented"""
7177  representations = _get_args(representations)
7178  representations = [to_symbol(s) for s in representations]
7179  sz = len(representations)
7180  args = (Symbol * sz)()
7181  for i in range(sz):
7182  args[i] = representations[i]
7183  Z3_fixedpoint_set_predicate_representation(self.ctxctx.ref(), self.fixedpointfixedpoint, f.ast, sz, args)
7184 
7185  def parse_string(self, s):
7186  """Parse rules and queries from a string"""
7187  return AstVector(Z3_fixedpoint_from_string(self.ctxctx.ref(), self.fixedpointfixedpoint, s), self.ctxctx)
7188 
7189  def parse_file(self, f):
7190  """Parse rules and queries from a file"""
7191  return AstVector(Z3_fixedpoint_from_file(self.ctxctx.ref(), self.fixedpointfixedpoint, f), self.ctxctx)
7192 
7193  def get_rules(self):
7194  """retrieve rules that have been added to fixedpoint context"""
7195  return AstVector(Z3_fixedpoint_get_rules(self.ctxctx.ref(), self.fixedpointfixedpoint), self.ctxctx)
7196 
7197  def get_assertions(self):
7198  """retrieve assertions that have been added to fixedpoint context"""
7199  return AstVector(Z3_fixedpoint_get_assertions(self.ctxctx.ref(), self.fixedpointfixedpoint), self.ctxctx)
7200 
7201  def __repr__(self):
7202  """Return a formatted string with all added rules and constraints."""
7203  return self.sexprsexpr()
7204 
7205  def sexpr(self):
7206  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
7207  """
7208  return Z3_fixedpoint_to_string(self.ctxctx.ref(), self.fixedpointfixedpoint, 0, (Ast * 0)())
7209 
7210  def to_string(self, queries):
7211  """Return a formatted string (in Lisp-like format) with all added constraints.
7212  We say the string is in s-expression format.
7213  Include also queries.
7214  """
7215  args, len = _to_ast_array(queries)
7216  return Z3_fixedpoint_to_string(self.ctxctx.ref(), self.fixedpointfixedpoint, len, args)
7217 
7218  def statistics(self):
7219  """Return statistics for the last `query()`.
7220  """
7221  return Statistics(Z3_fixedpoint_get_statistics(self.ctxctx.ref(), self.fixedpointfixedpoint), self.ctxctx)
7222 
7223  def reason_unknown(self):
7224  """Return a string describing why the last `query()` returned `unknown`.
7225  """
7226  return Z3_fixedpoint_get_reason_unknown(self.ctxctx.ref(), self.fixedpointfixedpoint)
7227 
7228  def declare_var(self, *vars):
7229  """Add variable or several variables.
7230  The added variable or variables will be bound in the rules
7231  and queries
7232  """
7233  vars = _get_args(vars)
7234  for v in vars:
7235  self.varsvars += [v]
7236 
7237  def abstract(self, fml, is_forall=True):
7238  if self.varsvars == []:
7239  return fml
7240  if is_forall:
7241  return ForAll(self.varsvars, fml)
7242  else:
7243  return Exists(self.varsvars, fml)
7244 
7245 
7246 
7251 
7253  """Finite domain sort."""
7254 
7255  def size(self):
7256  """Return the size of the finite domain sort"""
7257  r = (ctypes.c_ulonglong * 1)()
7258  if Z3_get_finite_domain_sort_size(self.ctx_refctx_ref(), self.astast, r):
7259  return r[0]
7260  else:
7261  raise Z3Exception("Failed to retrieve finite domain sort size")
7262 
7263 def FiniteDomainSort(name, sz, ctx=None):
7264  """Create a named finite domain sort of a given size sz"""
7265  if not isinstance(name, Symbol):
7266  name = to_symbol(name)
7267  ctx = _get_ctx(ctx)
7268  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7269 
7271  """Return True if `s` is a Z3 finite-domain sort.
7272 
7273  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7274  True
7275  >>> is_finite_domain_sort(IntSort())
7276  False
7277  """
7278  return isinstance(s, FiniteDomainSortRef)
7279 
7280 
7282  """Finite-domain expressions."""
7283 
7284  def sort(self):
7285  """Return the sort of the finite-domain expression `self`."""
7286  return FiniteDomainSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
7287 
7288  def as_string(self):
7289  """Return a Z3 floating point expression as a Python string."""
7290  return Z3_ast_to_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
7291 
7293  """Return `True` if `a` is a Z3 finite-domain expression.
7294 
7295  >>> s = FiniteDomainSort('S', 100)
7296  >>> b = Const('b', s)
7297  >>> is_finite_domain(b)
7298  True
7299  >>> is_finite_domain(Int('x'))
7300  False
7301  """
7302  return isinstance(a, FiniteDomainRef)
7303 
7304 
7306  """Integer values."""
7307 
7308  def as_long(self):
7309  """Return a Z3 finite-domain numeral as a Python long (bignum) numeral.
7310 
7311  >>> s = FiniteDomainSort('S', 100)
7312  >>> v = FiniteDomainVal(3, s)
7313  >>> v
7314  3
7315  >>> v.as_long() + 1
7316  4
7317  """
7318  return int(self.as_stringas_stringas_string())
7319 
7320  def as_string(self):
7321  """Return a Z3 finite-domain numeral as a Python string.
7322 
7323  >>> s = FiniteDomainSort('S', 100)
7324  >>> v = FiniteDomainVal(42, s)
7325  >>> v.as_string()
7326  '42'
7327  """
7328  return Z3_get_numeral_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
7329 
7330 
7331 def FiniteDomainVal(val, sort, ctx=None):
7332  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7333 
7334  >>> s = FiniteDomainSort('S', 256)
7335  >>> FiniteDomainVal(255, s)
7336  255
7337  >>> FiniteDomainVal('100', s)
7338  100
7339  """
7340  if z3_debug():
7341  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7342  ctx = sort.ctx
7343  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7344 
7346  """Return `True` if `a` is a Z3 finite-domain value.
7347 
7348  >>> s = FiniteDomainSort('S', 100)
7349  >>> b = Const('b', s)
7350  >>> is_finite_domain_value(b)
7351  False
7352  >>> b = FiniteDomainVal(10, s)
7353  >>> b
7354  10
7355  >>> is_finite_domain_value(b)
7356  True
7357  """
7358  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7359 
7360 
7361 
7366 
7368  def __init__(self, opt, value, is_max):
7369  self._opt_opt = opt
7370  self._value_value = value
7371  self._is_max_is_max = is_max
7372 
7373  def lower(self):
7374  opt = self._opt_opt
7375  return _to_expr_ref(Z3_optimize_get_lower(opt.ctx.ref(), opt.optimize, self._value_value), opt.ctx)
7376 
7377  def upper(self):
7378  opt = self._opt_opt
7379  return _to_expr_ref(Z3_optimize_get_upper(opt.ctx.ref(), opt.optimize, self._value_value), opt.ctx)
7380 
7381  def lower_values(self):
7382  opt = self._opt_opt
7383  return AstVector(Z3_optimize_get_lower_as_vector(opt.ctx.ref(), opt.optimize, self._value_value), opt.ctx)
7384 
7385  def upper_values(self):
7386  opt = self._opt_opt
7387  return AstVector(Z3_optimize_get_upper_as_vector(opt.ctx.ref(), opt.optimize, self._value_value), opt.ctx)
7388 
7389  def value(self):
7390  if self._is_max_is_max:
7391  return self.upperupper()
7392  else:
7393  return self.lowerlower()
7394 
7395  def __str__(self):
7396  return "%s:%s" % (self._value_value, self._is_max_is_max)
7397 
7398 
7400  """Optimize API provides methods for solving using objective functions and weighted soft constraints"""
7401 
7402  def __init__(self, ctx=None):
7403  self.ctxctx = _get_ctx(ctx)
7404  self.optimizeoptimize = Z3_mk_optimize(self.ctxctx.ref())
7405  Z3_optimize_inc_ref(self.ctxctx.ref(), self.optimizeoptimize)
7406 
7407  def __deepcopy__(self, memo={}):
7408  return Optimize(self.optimizeoptimize, self.ctxctx)
7409 
7410  def __del__(self):
7411  if self.optimizeoptimize is not None and self.ctxctx.ref() is not None:
7412  Z3_optimize_dec_ref(self.ctxctx.ref(), self.optimizeoptimize)
7413 
7414  def set(self, *args, **keys):
7415  """Set a configuration option. The method `help()` return a string containing all available options.
7416  """
7417  p = args2params(args, keys, self.ctxctx)
7418  Z3_optimize_set_params(self.ctxctx.ref(), self.optimizeoptimize, p.params)
7419 
7420  def help(self):
7421  """Display a string describing all available options."""
7422  print(Z3_optimize_get_help(self.ctxctx.ref(), self.optimizeoptimize))
7423 
7424  def param_descrs(self):
7425  """Return the parameter description set."""
7426  return ParamDescrsRef(Z3_optimize_get_param_descrs(self.ctxctx.ref(), self.optimizeoptimize), self.ctxctx)
7427 
7428  def assert_exprs(self, *args):
7429  """Assert constraints as background axioms for the optimize solver."""
7430  args = _get_args(args)
7431  s = BoolSort(self.ctxctx)
7432  for arg in args:
7433  if isinstance(arg, Goal) or isinstance(arg, AstVector):
7434  for f in arg:
7435  Z3_optimize_assert(self.ctxctx.ref(), self.optimizeoptimize, f.as_ast())
7436  else:
7437  arg = s.cast(arg)
7438  Z3_optimize_assert(self.ctxctx.ref(), self.optimizeoptimize, arg.as_ast())
7439 
7440  def add(self, *args):
7441  """Assert constraints as background axioms for the optimize solver. Alias for assert_expr."""
7442  self.assert_exprsassert_exprs(*args)
7443 
7444  def __iadd__(self, fml):
7445  self.addadd(fml)
7446  return self
7447 
7448  def assert_and_track(self, a, p):
7449  """Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.
7450 
7451  If `p` is a string, it will be automatically converted into a Boolean constant.
7452 
7453  >>> x = Int('x')
7454  >>> p3 = Bool('p3')
7455  >>> s = Optimize()
7456  >>> s.assert_and_track(x > 0, 'p1')
7457  >>> s.assert_and_track(x != 1, 'p2')
7458  >>> s.assert_and_track(x < 0, p3)
7459  >>> print(s.check())
7460  unsat
7461  >>> c = s.unsat_core()
7462  >>> len(c)
7463  2
7464  >>> Bool('p1') in c
7465  True
7466  >>> Bool('p2') in c
7467  False
7468  >>> p3 in c
7469  True
7470  """
7471  if isinstance(p, str):
7472  p = Bool(p, self.ctxctx)
7473  _z3_assert(isinstance(a, BoolRef), "Boolean expression expected")
7474  _z3_assert(isinstance(p, BoolRef) and is_const(p), "Boolean expression expected")
7475  Z3_optimize_assert_and_track(self.ctxctx.ref(), self.optimizeoptimize, a.as_ast(), p.as_ast())
7476 
7477  def add_soft(self, arg, weight = "1", id = None):
7478  """Add soft constraint with optional weight and optional identifier.
7479  If no weight is supplied, then the penalty for violating the soft constraint
7480  is 1.
7481  Soft constraints are grouped by identifiers. Soft constraints that are
7482  added without identifiers are grouped by default.
7483  """
7484  if _is_int(weight):
7485  weight = "%d" % weight
7486  elif isinstance(weight, float):
7487  weight = "%f" % weight
7488  if not isinstance(weight, str):
7489  raise Z3Exception("weight should be a string or an integer")
7490  if id is None:
7491  id = ""
7492  id = to_symbol(id, self.ctxctx)
7493  v = Z3_optimize_assert_soft(self.ctxctx.ref(), self.optimizeoptimize, arg.as_ast(), weight, id)
7494  return OptimizeObjective(self, v, False)
7495 
7496  def maximize(self, arg):
7497  """Add objective function to maximize."""
7498  return OptimizeObjective(self, Z3_optimize_maximize(self.ctxctx.ref(), self.optimizeoptimize, arg.as_ast()), True)
7499 
7500  def minimize(self, arg):
7501  """Add objective function to minimize."""
7502  return OptimizeObjective(self, Z3_optimize_minimize(self.ctxctx.ref(), self.optimizeoptimize, arg.as_ast()), False)
7503 
7504  def push(self):
7505  """create a backtracking point for added rules, facts and assertions"""
7506  Z3_optimize_push(self.ctxctx.ref(), self.optimizeoptimize)
7507 
7508  def pop(self):
7509  """restore to previously created backtracking point"""
7510  Z3_optimize_pop(self.ctxctx.ref(), self.optimizeoptimize)
7511 
7512  def check(self, *assumptions):
7513  """Check satisfiability while optimizing objective functions."""
7514  assumptions = _get_args(assumptions)
7515  num = len(assumptions)
7516  _assumptions = (Ast * num)()
7517  for i in range(num):
7518  _assumptions[i] = assumptions[i].as_ast()
7519  return CheckSatResult(Z3_optimize_check(self.ctxctx.ref(), self.optimizeoptimize, num, _assumptions))
7520 
7521  def reason_unknown(self):
7522  """Return a string that describes why the last `check()` returned `unknown`."""
7523  return Z3_optimize_get_reason_unknown(self.ctxctx.ref(), self.optimizeoptimize)
7524 
7525  def model(self):
7526  """Return a model for the last check()."""
7527  try:
7528  return ModelRef(Z3_optimize_get_model(self.ctxctx.ref(), self.optimizeoptimize), self.ctxctx)
7529  except Z3Exception:
7530  raise Z3Exception("model is not available")
7531 
7532  def unsat_core(self):
7533  return AstVector(Z3_optimize_get_unsat_core(self.ctxctx.ref(), self.optimizeoptimize), self.ctxctx)
7534 
7535  def lower(self, obj):
7536  if not isinstance(obj, OptimizeObjective):
7537  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7538  return obj.lower()
7539 
7540  def upper(self, obj):
7541  if not isinstance(obj, OptimizeObjective):
7542  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7543  return obj.upper()
7544 
7545  def lower_values(self, obj):
7546  if not isinstance(obj, OptimizeObjective):
7547  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7548  return obj.lower_values()
7549 
7550  def upper_values(self, obj):
7551  if not isinstance(obj, OptimizeObjective):
7552  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7553  return obj.upper_values()
7554 
7555  def from_file(self, filename):
7556  """Parse assertions and objectives from a file"""
7557  Z3_optimize_from_file(self.ctxctx.ref(), self.optimizeoptimize, filename)
7558 
7559  def from_string(self, s):
7560  """Parse assertions and objectives from a string"""
7561  Z3_optimize_from_string(self.ctxctx.ref(), self.optimizeoptimize, s)
7562 
7563  def assertions(self):
7564  """Return an AST vector containing all added constraints."""
7565  return AstVector(Z3_optimize_get_assertions(self.ctxctx.ref(), self.optimizeoptimize), self.ctxctx)
7566 
7567  def objectives(self):
7568  """returns set of objective functions"""
7569  return AstVector(Z3_optimize_get_objectives(self.ctxctx.ref(), self.optimizeoptimize), self.ctxctx)
7570 
7571  def __repr__(self):
7572  """Return a formatted string with all added rules and constraints."""
7573  return self.sexprsexpr()
7574 
7575  def sexpr(self):
7576  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
7577  """
7578  return Z3_optimize_to_string(self.ctxctx.ref(), self.optimizeoptimize)
7579 
7580  def statistics(self):
7581  """Return statistics for the last check`.
7582  """
7583  return Statistics(Z3_optimize_get_statistics(self.ctxctx.ref(), self.optimizeoptimize), self.ctxctx)
7584 
7585 
7586 
7587 
7588 
7594  """An ApplyResult object contains the subgoals produced by a tactic when applied to a goal. It also contains model and proof converters."""
7595 
7596  def __init__(self, result, ctx):
7597  self.resultresult = result
7598  self.ctxctx = ctx
7599  Z3_apply_result_inc_ref(self.ctxctx.ref(), self.resultresult)
7600 
7601  def __deepcopy__(self, memo={}):
7602  return ApplyResult(self.resultresult, self.ctxctx)
7603 
7604  def __del__(self):
7605  if self.ctxctx.ref() is not None:
7606  Z3_apply_result_dec_ref(self.ctxctx.ref(), self.resultresult)
7607 
7608  def __len__(self):
7609  """Return the number of subgoals in `self`.
7610 
7611  >>> a, b = Ints('a b')
7612  >>> g = Goal()
7613  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
7614  >>> t = Tactic('split-clause')
7615  >>> r = t(g)
7616  >>> len(r)
7617  2
7618  >>> t = Then(Tactic('split-clause'), Tactic('split-clause'))
7619  >>> len(t(g))
7620  4
7621  >>> t = Then(Tactic('split-clause'), Tactic('split-clause'), Tactic('propagate-values'))
7622  >>> len(t(g))
7623  1
7624  """
7625  return int(Z3_apply_result_get_num_subgoals(self.ctxctx.ref(), self.resultresult))
7626 
7627  def __getitem__(self, idx):
7628  """Return one of the subgoals stored in ApplyResult object `self`.
7629 
7630  >>> a, b = Ints('a b')
7631  >>> g = Goal()
7632  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
7633  >>> t = Tactic('split-clause')
7634  >>> r = t(g)
7635  >>> r[0]
7636  [a == 0, Or(b == 0, b == 1), a > b]
7637  >>> r[1]
7638  [a == 1, Or(b == 0, b == 1), a > b]
7639  """
7640  if idx >= len(self):
7641  raise IndexError
7642  return Goal(goal=Z3_apply_result_get_subgoal(self.ctxctx.ref(), self.resultresult, idx), ctx=self.ctxctx)
7643 
7644  def __repr__(self):
7645  return obj_to_string(self)
7646 
7647  def sexpr(self):
7648  """Return a textual representation of the s-expression representing the set of subgoals in `self`."""
7649  return Z3_apply_result_to_string(self.ctxctx.ref(), self.resultresult)
7650 
7651 
7652  def as_expr(self):
7653  """Return a Z3 expression consisting of all subgoals.
7654 
7655  >>> x = Int('x')
7656  >>> g = Goal()
7657  >>> g.add(x > 1)
7658  >>> g.add(Or(x == 2, x == 3))
7659  >>> r = Tactic('simplify')(g)
7660  >>> r
7661  [[Not(x <= 1), Or(x == 2, x == 3)]]
7662  >>> r.as_expr()
7663  And(Not(x <= 1), Or(x == 2, x == 3))
7664  >>> r = Tactic('split-clause')(g)
7665  >>> r
7666  [[x > 1, x == 2], [x > 1, x == 3]]
7667  >>> r.as_expr()
7668  Or(And(x > 1, x == 2), And(x > 1, x == 3))
7669  """
7670  sz = len(self)
7671  if sz == 0:
7672  return BoolVal(False, self.ctxctx)
7673  elif sz == 1:
7674  return self[0].as_expr()
7675  else:
7676  return Or([ self[i].as_expr() for i in range(len(self)) ])
7677 
7678 
7683 class Tactic:
7684  """Tactics transform, solver and/or simplify sets of constraints (Goal). A Tactic can be converted into a Solver using the method solver().
7685 
7686  Several combinators are available for creating new tactics using the built-in ones: Then(), OrElse(), FailIf(), Repeat(), When(), Cond().
7687  """
7688  def __init__(self, tactic, ctx=None):
7689  self.ctxctx = _get_ctx(ctx)
7690  self.tactictactic = None
7691  if isinstance(tactic, TacticObj):
7692  self.tactictactic = tactic
7693  else:
7694  if z3_debug():
7695  _z3_assert(isinstance(tactic, str), "tactic name expected")
7696  try:
7697  self.tactictactic = Z3_mk_tactic(self.ctxctx.ref(), str(tactic))
7698  except Z3Exception:
7699  raise Z3Exception("unknown tactic '%s'" % tactic)
7700  Z3_tactic_inc_ref(self.ctxctx.ref(), self.tactictactic)
7701 
7702  def __deepcopy__(self, memo={}):
7703  return Tactic(self.tactictactic, self.ctxctx)
7704 
7705  def __del__(self):
7706  if self.tactictactic is not None and self.ctxctx.ref() is not None:
7707  Z3_tactic_dec_ref(self.ctxctx.ref(), self.tactictactic)
7708 
7709  def solver(self, logFile=None):
7710  """Create a solver using the tactic `self`.
7711 
7712  The solver supports the methods `push()` and `pop()`, but it
7713  will always solve each `check()` from scratch.
7714 
7715  >>> t = Then('simplify', 'nlsat')
7716  >>> s = t.solver()
7717  >>> x = Real('x')
7718  >>> s.add(x**2 == 2, x > 0)
7719  >>> s.check()
7720  sat
7721  >>> s.model()
7722  [x = 1.4142135623?]
7723  """
7724  return Solver(Z3_mk_solver_from_tactic(self.ctxctx.ref(), self.tactictactic), self.ctxctx, logFile)
7725 
7726  def apply(self, goal, *arguments, **keywords):
7727  """Apply tactic `self` to the given goal or Z3 Boolean expression using the given options.
7728 
7729  >>> x, y = Ints('x y')
7730  >>> t = Tactic('solve-eqs')
7731  >>> t.apply(And(x == 0, y >= x + 1))
7732  [[y >= 1]]
7733  """
7734  if z3_debug():
7735  _z3_assert(isinstance(goal, Goal) or isinstance(goal, BoolRef), "Z3 Goal or Boolean expressions expected")
7736  goal = _to_goal(goal)
7737  if len(arguments) > 0 or len(keywords) > 0:
7738  p = args2params(arguments, keywords, self.ctxctx)
7739  return ApplyResult(Z3_tactic_apply_ex(self.ctxctx.ref(), self.tactictactic, goal.goal, p.params), self.ctxctx)
7740  else:
7741  return ApplyResult(Z3_tactic_apply(self.ctxctx.ref(), self.tactictactic, goal.goal), self.ctxctx)
7742 
7743  def __call__(self, goal, *arguments, **keywords):
7744  """Apply tactic `self` to the given goal or Z3 Boolean expression using the given options.
7745 
7746  >>> x, y = Ints('x y')
7747  >>> t = Tactic('solve-eqs')
7748  >>> t(And(x == 0, y >= x + 1))
7749  [[y >= 1]]
7750  """
7751  return self.applyapply(goal, *arguments, **keywords)
7752 
7753  def help(self):
7754  """Display a string containing a description of the available options for the `self` tactic."""
7755  print(Z3_tactic_get_help(self.ctxctx.ref(), self.tactictactic))
7756 
7757  def param_descrs(self):
7758  """Return the parameter description set."""
7759  return ParamDescrsRef(Z3_tactic_get_param_descrs(self.ctxctx.ref(), self.tactictactic), self.ctxctx)
7760 
7761 def _to_goal(a):
7762  if isinstance(a, BoolRef):
7763  goal = Goal(ctx = a.ctx)
7764  goal.add(a)
7765  return goal
7766  else:
7767  return a
7768 
7769 def _to_tactic(t, ctx=None):
7770  if isinstance(t, Tactic):
7771  return t
7772  else:
7773  return Tactic(t, ctx)
7774 
7775 def _and_then(t1, t2, ctx=None):
7776  t1 = _to_tactic(t1, ctx)
7777  t2 = _to_tactic(t2, ctx)
7778  if z3_debug():
7779  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7780  return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7781 
7782 def _or_else(t1, t2, ctx=None):
7783  t1 = _to_tactic(t1, ctx)
7784  t2 = _to_tactic(t2, ctx)
7785  if z3_debug():
7786  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7787  return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7788 
7789 def AndThen(*ts, **ks):
7790  """Return a tactic that applies the tactics in `*ts` in sequence.
7791 
7792  >>> x, y = Ints('x y')
7793  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7794  >>> t(And(x == 0, y > x + 1))
7795  [[Not(y <= 1)]]
7796  >>> t(And(x == 0, y > x + 1)).as_expr()
7797  Not(y <= 1)
7798  """
7799  if z3_debug():
7800  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7801  ctx = ks.get('ctx', None)
7802  num = len(ts)
7803  r = ts[0]
7804  for i in range(num - 1):
7805  r = _and_then(r, ts[i+1], ctx)
7806  return r
7807 
7808 def Then(*ts, **ks):
7809  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7810 
7811  >>> x, y = Ints('x y')
7812  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7813  >>> t(And(x == 0, y > x + 1))
7814  [[Not(y <= 1)]]
7815  >>> t(And(x == 0, y > x + 1)).as_expr()
7816  Not(y <= 1)
7817  """
7818  return AndThen(*ts, **ks)
7819 
7820 def OrElse(*ts, **ks):
7821  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7822 
7823  >>> x = Int('x')
7824  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7825  >>> # Tactic split-clause fails if there is no clause in the given goal.
7826  >>> t(x == 0)
7827  [[x == 0]]
7828  >>> t(Or(x == 0, x == 1))
7829  [[x == 0], [x == 1]]
7830  """
7831  if z3_debug():
7832  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7833  ctx = ks.get('ctx', None)
7834  num = len(ts)
7835  r = ts[0]
7836  for i in range(num - 1):
7837  r = _or_else(r, ts[i+1], ctx)
7838  return r
7839 
7840 def ParOr(*ts, **ks):
7841  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7842 
7843  >>> x = Int('x')
7844  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7845  >>> t(x + 1 == 2)
7846  [[x == 1]]
7847  """
7848  if z3_debug():
7849  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7850  ctx = _get_ctx(ks.get('ctx', None))
7851  ts = [ _to_tactic(t, ctx) for t in ts ]
7852  sz = len(ts)
7853  _args = (TacticObj * sz)()
7854  for i in range(sz):
7855  _args[i] = ts[i].tactic
7856  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7857 
7858 def ParThen(t1, t2, ctx=None):
7859  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7860 
7861  >>> x, y = Ints('x y')
7862  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7863  >>> t(And(Or(x == 1, x == 2), y == x + 1))
7864  [[x == 1, y == 2], [x == 2, y == 3]]
7865  """
7866  t1 = _to_tactic(t1, ctx)
7867  t2 = _to_tactic(t2, ctx)
7868  if z3_debug():
7869  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7870  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7871 
7872 def ParAndThen(t1, t2, ctx=None):
7873  """Alias for ParThen(t1, t2, ctx)."""
7874  return ParThen(t1, t2, ctx)
7875 
7876 def With(t, *args, **keys):
7877  """Return a tactic that applies tactic `t` using the given configuration options.
7878 
7879  >>> x, y = Ints('x y')
7880  >>> t = With(Tactic('simplify'), som=True)
7881  >>> t((x + 1)*(y + 2) == 0)
7882  [[2*x + y + x*y == -2]]
7883  """
7884  ctx = keys.pop('ctx', None)
7885  t = _to_tactic(t, ctx)
7886  p = args2params(args, keys, t.ctx)
7887  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7888 
7889 def WithParams(t, p):
7890  """Return a tactic that applies tactic `t` using the given configuration options.
7891 
7892  >>> x, y = Ints('x y')
7893  >>> p = ParamsRef()
7894  >>> p.set("som", True)
7895  >>> t = WithParams(Tactic('simplify'), p)
7896  >>> t((x + 1)*(y + 2) == 0)
7897  [[2*x + y + x*y == -2]]
7898  """
7899  t = _to_tactic(t, None)
7900  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7901 
7902 def Repeat(t, max=4294967295, ctx=None):
7903  """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7904 
7905  >>> x, y = Ints('x y')
7906  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7907  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7908  >>> r = t(c)
7909  >>> for subgoal in r: print(subgoal)
7910  [x == 0, y == 0, x > y]
7911  [x == 0, y == 1, x > y]
7912  [x == 1, y == 0, x > y]
7913  [x == 1, y == 1, x > y]
7914  >>> t = Then(t, Tactic('propagate-values'))
7915  >>> t(c)
7916  [[x == 1, y == 0]]
7917  """
7918  t = _to_tactic(t, ctx)
7919  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7920 
7921 def TryFor(t, ms, ctx=None):
7922  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7923 
7924  If `t` does not terminate in `ms` milliseconds, then it fails.
7925  """
7926  t = _to_tactic(t, ctx)
7927  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7928 
7929 def tactics(ctx=None):
7930  """Return a list of all available tactics in Z3.
7931 
7932  >>> l = tactics()
7933  >>> l.count('simplify') == 1
7934  True
7935  """
7936  ctx = _get_ctx(ctx)
7937  return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7938 
7939 def tactic_description(name, ctx=None):
7940  """Return a short description for the tactic named `name`.
7941 
7942  >>> d = tactic_description('simplify')
7943  """
7944  ctx = _get_ctx(ctx)
7945  return Z3_tactic_get_descr(ctx.ref(), name)
7946 
7948  """Display a (tabular) description of all available tactics in Z3."""
7949  if in_html_mode():
7950  even = True
7951  print('<table border="1" cellpadding="2" cellspacing="0">')
7952  for t in tactics():
7953  if even:
7954  print('<tr style="background-color:#CFCFCF">')
7955  even = False
7956  else:
7957  print('<tr>')
7958  even = True
7959  print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7960  print('</table>')
7961  else:
7962  for t in tactics():
7963  print('%s : %s' % (t, tactic_description(t)))
7964 
7965 class Probe:
7966  """Probes are used to inspect a goal (aka problem) and collect information that may be used to decide which solver and/or preprocessing step will be used."""
7967  def __init__(self, probe, ctx=None):
7968  self.ctxctx = _get_ctx(ctx)
7969  self.probeprobe = None
7970  if isinstance(probe, ProbeObj):
7971  self.probeprobe = probe
7972  elif isinstance(probe, float):
7973  self.probeprobe = Z3_probe_const(self.ctxctx.ref(), probe)
7974  elif _is_int(probe):
7975  self.probeprobe = Z3_probe_const(self.ctxctx.ref(), float(probe))
7976  elif isinstance(probe, bool):
7977  if probe:
7978  self.probeprobe = Z3_probe_const(self.ctxctx.ref(), 1.0)
7979  else:
7980  self.probeprobe = Z3_probe_const(self.ctxctx.ref(), 0.0)
7981  else:
7982  if z3_debug():
7983  _z3_assert(isinstance(probe, str), "probe name expected")
7984  try:
7985  self.probeprobe = Z3_mk_probe(self.ctxctx.ref(), probe)
7986  except Z3Exception:
7987  raise Z3Exception("unknown probe '%s'" % probe)
7988  Z3_probe_inc_ref(self.ctxctx.ref(), self.probeprobe)
7989 
7990  def __deepcopy__(self, memo={}):
7991  return Probe(self.probeprobe, self.ctxctx)
7992 
7993  def __del__(self):
7994  if self.probeprobe is not None and self.ctxctx.ref() is not None:
7995  Z3_probe_dec_ref(self.ctxctx.ref(), self.probeprobe)
7996 
7997  def __lt__(self, other):
7998  """Return a probe that evaluates to "true" when the value returned by `self` is less than the value returned by `other`.
7999 
8000  >>> p = Probe('size') < 10
8001  >>> x = Int('x')
8002  >>> g = Goal()
8003  >>> g.add(x > 0)
8004  >>> g.add(x < 10)
8005  >>> p(g)
8006  1.0
8007  """
8008  return Probe(Z3_probe_lt(self.ctxctx.ref(), self.probeprobe, _to_probe(other, self.ctxctx).probe), self.ctxctx)
8009 
8010  def __gt__(self, other):
8011  """Return a probe that evaluates to "true" when the value returned by `self` is greater than the value returned by `other`.
8012 
8013  >>> p = Probe('size') > 10
8014  >>> x = Int('x')
8015  >>> g = Goal()
8016  >>> g.add(x > 0)
8017  >>> g.add(x < 10)
8018  >>> p(g)
8019  0.0
8020  """
8021  return Probe(Z3_probe_gt(self.ctxctx.ref(), self.probeprobe, _to_probe(other, self.ctxctx).probe), self.ctxctx)
8022 
8023  def __le__(self, other):
8024  """Return a probe that evaluates to "true" when the value returned by `self` is less than or equal to the value returned by `other`.
8025 
8026  >>> p = Probe('size') <= 2
8027  >>> x = Int('x')
8028  >>> g = Goal()
8029  >>> g.add(x > 0)
8030  >>> g.add(x < 10)
8031  >>> p(g)
8032  1.0
8033  """
8034  return Probe(Z3_probe_le(self.ctxctx.ref(), self.probeprobe, _to_probe(other, self.ctxctx).probe), self.ctxctx)
8035 
8036  def __ge__(self, other):
8037  """Return a probe that evaluates to "true" when the value returned by `self` is greater than or equal to the value returned by `other`.
8038 
8039  >>> p = Probe('size') >= 2
8040  >>> x = Int('x')
8041  >>> g = Goal()
8042  >>> g.add(x > 0)
8043  >>> g.add(x < 10)
8044  >>> p(g)
8045  1.0
8046  """
8047  return Probe(Z3_probe_ge(self.ctxctx.ref(), self.probeprobe, _to_probe(other, self.ctxctx).probe), self.ctxctx)
8048 
8049  def __eq__(self, other):
8050  """Return a probe that evaluates to "true" when the value returned by `self` is equal to the value returned by `other`.
8051 
8052  >>> p = Probe('size') == 2
8053  >>> x = Int('x')
8054  >>> g = Goal()
8055  >>> g.add(x > 0)
8056  >>> g.add(x < 10)
8057  >>> p(g)
8058  1.0
8059  """
8060  return Probe(Z3_probe_eq(self.ctxctx.ref(), self.probeprobe, _to_probe(other, self.ctxctx).probe), self.ctxctx)
8061 
8062  def __ne__(self, other):
8063  """Return a probe that evaluates to "true" when the value returned by `self` is not equal to the value returned by `other`.
8064 
8065  >>> p = Probe('size') != 2
8066  >>> x = Int('x')
8067  >>> g = Goal()
8068  >>> g.add(x > 0)
8069  >>> g.add(x < 10)
8070  >>> p(g)
8071  0.0
8072  """
8073  p = self.__eq____eq__(other)
8074  return Probe(Z3_probe_not(self.ctxctx.ref(), p.probe), self.ctxctx)
8075 
8076  def __call__(self, goal):
8077  """Evaluate the probe `self` in the given goal.
8078 
8079  >>> p = Probe('size')
8080  >>> x = Int('x')
8081  >>> g = Goal()
8082  >>> g.add(x > 0)
8083  >>> g.add(x < 10)
8084  >>> p(g)
8085  2.0
8086  >>> g.add(x < 20)
8087  >>> p(g)
8088  3.0
8089  >>> p = Probe('num-consts')
8090  >>> p(g)
8091  1.0
8092  >>> p = Probe('is-propositional')
8093  >>> p(g)
8094  0.0
8095  >>> p = Probe('is-qflia')
8096  >>> p(g)
8097  1.0
8098  """
8099  if z3_debug():
8100  _z3_assert(isinstance(goal, Goal) or isinstance(goal, BoolRef), "Z3 Goal or Boolean expression expected")
8101  goal = _to_goal(goal)
8102  return Z3_probe_apply(self.ctxctx.ref(), self.probeprobe, goal.goal)
8103 
8104 def is_probe(p):
8105  """Return `True` if `p` is a Z3 probe.
8106 
8107  >>> is_probe(Int('x'))
8108  False
8109  >>> is_probe(Probe('memory'))
8110  True
8111  """
8112  return isinstance(p, Probe)
8113 
8114 def _to_probe(p, ctx=None):
8115  if is_probe(p):
8116  return p
8117  else:
8118  return Probe(p, ctx)
8119 
8120 def probes(ctx=None):
8121  """Return a list of all available probes in Z3.
8122 
8123  >>> l = probes()
8124  >>> l.count('memory') == 1
8125  True
8126  """
8127  ctx = _get_ctx(ctx)
8128  return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8129 
8130 def probe_description(name, ctx=None):
8131  """Return a short description for the probe named `name`.
8132 
8133  >>> d = probe_description('memory')
8134  """
8135  ctx = _get_ctx(ctx)
8136  return Z3_probe_get_descr(ctx.ref(), name)
8137 
8139  """Display a (tabular) description of all available probes in Z3."""
8140  if in_html_mode():
8141  even = True
8142  print('<table border="1" cellpadding="2" cellspacing="0">')
8143  for p in probes():
8144  if even:
8145  print('<tr style="background-color:#CFCFCF">')
8146  even = False
8147  else:
8148  print('<tr>')
8149  even = True
8150  print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8151  print('</table>')
8152  else:
8153  for p in probes():
8154  print('%s : %s' % (p, probe_description(p)))
8155 
8156 def _probe_nary(f, args, ctx):
8157  if z3_debug():
8158  _z3_assert(len(args) > 0, "At least one argument expected")
8159  num = len(args)
8160  r = _to_probe(args[0], ctx)
8161  for i in range(num - 1):
8162  r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i+1], ctx).probe), ctx)
8163  return r
8164 
8165 def _probe_and(args, ctx):
8166  return _probe_nary(Z3_probe_and, args, ctx)
8167 
8168 def _probe_or(args, ctx):
8169  return _probe_nary(Z3_probe_or, args, ctx)
8170 
8171 def FailIf(p, ctx=None):
8172  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8173 
8174  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8175 
8176  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8177  >>> x, y = Ints('x y')
8178  >>> g = Goal()
8179  >>> g.add(x > 0)
8180  >>> g.add(y > 0)
8181  >>> t(g)
8182  [[x > 0, y > 0]]
8183  >>> g.add(x == y + 1)
8184  >>> t(g)
8185  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8186  """
8187  p = _to_probe(p, ctx)
8188  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8189 
8190 def When(p, t, ctx=None):
8191  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8192 
8193  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8194  >>> x, y = Ints('x y')
8195  >>> g = Goal()
8196  >>> g.add(x > 0)
8197  >>> g.add(y > 0)
8198  >>> t(g)
8199  [[x > 0, y > 0]]
8200  >>> g.add(x == y + 1)
8201  >>> t(g)
8202  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8203  """
8204  p = _to_probe(p, ctx)
8205  t = _to_tactic(t, ctx)
8206  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8207 
8208 def Cond(p, t1, t2, ctx=None):
8209  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8210 
8211  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8212  """
8213  p = _to_probe(p, ctx)
8214  t1 = _to_tactic(t1, ctx)
8215  t2 = _to_tactic(t2, ctx)
8216  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8217 
8218 
8223 
8224 def simplify(a, *arguments, **keywords):
8225  """Simplify the expression `a` using the given options.
8226 
8227  This function has many options. Use `help_simplify` to obtain the complete list.
8228 
8229  >>> x = Int('x')
8230  >>> y = Int('y')
8231  >>> simplify(x + 1 + y + x + 1)
8232  2 + 2*x + y
8233  >>> simplify((x + 1)*(y + 1), som=True)
8234  1 + x + y + x*y
8235  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8236  And(Not(x == y), Not(x == 1), Not(y == 1))
8237  >>> simplify(And(x == 0, y == 1), elim_and=True)
8238  Not(Or(Not(x == 0), Not(y == 1)))
8239  """
8240  if z3_debug():
8241  _z3_assert(is_expr(a), "Z3 expression expected")
8242  if len(arguments) > 0 or len(keywords) > 0:
8243  p = args2params(arguments, keywords, a.ctx)
8244  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8245  else:
8246  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8247 
8249  """Return a string describing all options available for Z3 `simplify` procedure."""
8250  print(Z3_simplify_get_help(main_ctx().ref()))
8251 
8253  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8255 
8256 def substitute(t, *m):
8257  """Apply substitution m on t, m is a list of pairs of the form (from, to). Every occurrence in t of from is replaced with to.
8258 
8259  >>> x = Int('x')
8260  >>> y = Int('y')
8261  >>> substitute(x + 1, (x, y + 1))
8262  y + 1 + 1
8263  >>> f = Function('f', IntSort(), IntSort())
8264  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8265  1 + 1
8266  """
8267  if isinstance(m, tuple):
8268  m1 = _get_args(m)
8269  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8270  m = m1
8271  if z3_debug():
8272  _z3_assert(is_expr(t), "Z3 expression expected")
8273  _z3_assert(all([isinstance(p, tuple) and is_expr(p[0]) and is_expr(p[1]) and p[0].sort().eq(p[1].sort()) for p in m]), "Z3 invalid substitution, expression pairs expected.")
8274  num = len(m)
8275  _from = (Ast * num)()
8276  _to = (Ast * num)()
8277  for i in range(num):
8278  _from[i] = m[i][0].as_ast()
8279  _to[i] = m[i][1].as_ast()
8280  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8281 
8282 def substitute_vars(t, *m):
8283  """Substitute the free variables in t with the expression in m.
8284 
8285  >>> v0 = Var(0, IntSort())
8286  >>> v1 = Var(1, IntSort())
8287  >>> x = Int('x')
8288  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8289  >>> # replace v0 with x+1 and v1 with x
8290  >>> substitute_vars(f(v0, v1), x + 1, x)
8291  f(x + 1, x)
8292  """
8293  if z3_debug():
8294  _z3_assert(is_expr(t), "Z3 expression expected")
8295  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8296  num = len(m)
8297  _to = (Ast * num)()
8298  for i in range(num):
8299  _to[i] = m[i].as_ast()
8300  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8301 
8302 def Sum(*args):
8303  """Create the sum of the Z3 expressions.
8304 
8305  >>> a, b, c = Ints('a b c')
8306  >>> Sum(a, b, c)
8307  a + b + c
8308  >>> Sum([a, b, c])
8309  a + b + c
8310  >>> A = IntVector('a', 5)
8311  >>> Sum(A)
8312  a__0 + a__1 + a__2 + a__3 + a__4
8313  """
8314  args = _get_args(args)
8315  if len(args) == 0:
8316  return 0
8317  ctx = _ctx_from_ast_arg_list(args)
8318  if ctx is None:
8319  return _reduce(lambda a, b: a + b, args, 0)
8320  args = _coerce_expr_list(args, ctx)
8321  if is_bv(args[0]):
8322  return _reduce(lambda a, b: a + b, args, 0)
8323  else:
8324  _args, sz = _to_ast_array(args)
8325  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8326 
8327 
8328 def Product(*args):
8329  """Create the product of the Z3 expressions.
8330 
8331  >>> a, b, c = Ints('a b c')
8332  >>> Product(a, b, c)
8333  a*b*c
8334  >>> Product([a, b, c])
8335  a*b*c
8336  >>> A = IntVector('a', 5)
8337  >>> Product(A)
8338  a__0*a__1*a__2*a__3*a__4
8339  """
8340  args = _get_args(args)
8341  if len(args) == 0:
8342  return 1
8343  ctx = _ctx_from_ast_arg_list(args)
8344  if ctx is None:
8345  return _reduce(lambda a, b: a * b, args, 1)
8346  args = _coerce_expr_list(args, ctx)
8347  if is_bv(args[0]):
8348  return _reduce(lambda a, b: a * b, args, 1)
8349  else:
8350  _args, sz = _to_ast_array(args)
8351  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8352 
8353 def AtMost(*args):
8354  """Create an at-most Pseudo-Boolean k constraint.
8355 
8356  >>> a, b, c = Bools('a b c')
8357  >>> f = AtMost(a, b, c, 2)
8358  """
8359  args = _get_args(args)
8360  if z3_debug():
8361  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8362  ctx = _ctx_from_ast_arg_list(args)
8363  if z3_debug():
8364  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8365  args1 = _coerce_expr_list(args[:-1], ctx)
8366  k = args[-1]
8367  _args, sz = _to_ast_array(args1)
8368  return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
8369 
8370 def AtLeast(*args):
8371  """Create an at-most Pseudo-Boolean k constraint.
8372 
8373  >>> a, b, c = Bools('a b c')
8374  >>> f = AtLeast(a, b, c, 2)
8375  """
8376  args = _get_args(args)
8377  if z3_debug():
8378  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8379  ctx = _ctx_from_ast_arg_list(args)
8380  if z3_debug():
8381  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8382  args1 = _coerce_expr_list(args[:-1], ctx)
8383  k = args[-1]
8384  _args, sz = _to_ast_array(args1)
8385  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8386 
8387 def _reorder_pb_arg(arg):
8388  a, b = arg
8389  if not _is_int(b) and _is_int(a):
8390  return b, a
8391  return arg
8392 
8393 def _pb_args_coeffs(args, default_ctx = None):
8394  args = _get_args_ast_list(args)
8395  if len(args) == 0:
8396  return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
8397  args = [_reorder_pb_arg(arg) for arg in args]
8398  args, coeffs = zip(*args)
8399  if z3_debug():
8400  _z3_assert(len(args) > 0, "Non empty list of arguments expected")
8401  ctx = _ctx_from_ast_arg_list(args)
8402  if z3_debug():
8403  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8404  args = _coerce_expr_list(args, ctx)
8405  _args, sz = _to_ast_array(args)
8406  _coeffs = (ctypes.c_int * len(coeffs))()
8407  for i in range(len(coeffs)):
8408  _z3_check_cint_overflow(coeffs[i], "coefficient")
8409  _coeffs[i] = coeffs[i]
8410  return ctx, sz, _args, _coeffs
8411 
8412 def PbLe(args, k):
8413  """Create a Pseudo-Boolean inequality k constraint.
8414 
8415  >>> a, b, c = Bools('a b c')
8416  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
8417  """
8418  _z3_check_cint_overflow(k, "k")
8419  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8420  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
8421 
8422 def PbGe(args, k):
8423  """Create a Pseudo-Boolean inequality k constraint.
8424 
8425  >>> a, b, c = Bools('a b c')
8426  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8427  """
8428  _z3_check_cint_overflow(k, "k")
8429  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8430  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8431 
8432 def PbEq(args, k, ctx = None):
8433  """Create a Pseudo-Boolean inequality k constraint.
8434 
8435  >>> a, b, c = Bools('a b c')
8436  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8437  """
8438  _z3_check_cint_overflow(k, "k")
8439  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8440  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8441 
8442 
8443 def solve(*args, **keywords):
8444  """Solve the constraints `*args`.
8445 
8446  This is a simple function for creating demonstrations. It creates a solver,
8447  configure it using the options in `keywords`, adds the constraints
8448  in `args`, and invokes check.
8449 
8450  >>> a = Int('a')
8451  >>> solve(a > 0, a < 2)
8452  [a = 1]
8453  """
8454  s = Solver()
8455  s.set(**keywords)
8456  s.add(*args)
8457  if keywords.get('show', False):
8458  print(s)
8459  r = s.check()
8460  if r == unsat:
8461  print("no solution")
8462  elif r == unknown:
8463  print("failed to solve")
8464  try:
8465  print(s.model())
8466  except Z3Exception:
8467  return
8468  else:
8469  print(s.model())
8470 
8471 def solve_using(s, *args, **keywords):
8472  """Solve the constraints `*args` using solver `s`.
8473 
8474  This is a simple function for creating demonstrations. It is similar to `solve`,
8475  but it uses the given solver `s`.
8476  It configures solver `s` using the options in `keywords`, adds the constraints
8477  in `args`, and invokes check.
8478  """
8479  if z3_debug():
8480  _z3_assert(isinstance(s, Solver), "Solver object expected")
8481  s.set(**keywords)
8482  s.add(*args)
8483  if keywords.get('show', False):
8484  print("Problem:")
8485  print(s)
8486  r = s.check()
8487  if r == unsat:
8488  print("no solution")
8489  elif r == unknown:
8490  print("failed to solve")
8491  try:
8492  print(s.model())
8493  except Z3Exception:
8494  return
8495  else:
8496  if keywords.get('show', False):
8497  print("Solution:")
8498  print(s.model())
8499 
8500 def prove(claim, **keywords):
8501  """Try to prove the given claim.
8502 
8503  This is a simple function for creating demonstrations. It tries to prove
8504  `claim` by showing the negation is unsatisfiable.
8505 
8506  >>> p, q = Bools('p q')
8507  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8508  proved
8509  """
8510  if z3_debug():
8511  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8512  s = Solver()
8513  s.set(**keywords)
8514  s.add(Not(claim))
8515  if keywords.get('show', False):
8516  print(s)
8517  r = s.check()
8518  if r == unsat:
8519  print("proved")
8520  elif r == unknown:
8521  print("failed to prove")
8522  print(s.model())
8523  else:
8524  print("counterexample")
8525  print(s.model())
8526 
8527 def _solve_html(*args, **keywords):
8528  """Version of function `solve` used in RiSE4Fun."""
8529  s = Solver()
8530  s.set(**keywords)
8531  s.add(*args)
8532  if keywords.get('show', False):
8533  print("<b>Problem:</b>")
8534  print(s)
8535  r = s.check()
8536  if r == unsat:
8537  print("<b>no solution</b>")
8538  elif r == unknown:
8539  print("<b>failed to solve</b>")
8540  try:
8541  print(s.model())
8542  except Z3Exception:
8543  return
8544  else:
8545  if keywords.get('show', False):
8546  print("<b>Solution:</b>")
8547  print(s.model())
8548 
8549 def _solve_using_html(s, *args, **keywords):
8550  """Version of function `solve_using` used in RiSE4Fun."""
8551  if z3_debug():
8552  _z3_assert(isinstance(s, Solver), "Solver object expected")
8553  s.set(**keywords)
8554  s.add(*args)
8555  if keywords.get('show', False):
8556  print("<b>Problem:</b>")
8557  print(s)
8558  r = s.check()
8559  if r == unsat:
8560  print("<b>no solution</b>")
8561  elif r == unknown:
8562  print("<b>failed to solve</b>")
8563  try:
8564  print(s.model())
8565  except Z3Exception:
8566  return
8567  else:
8568  if keywords.get('show', False):
8569  print("<b>Solution:</b>")
8570  print(s.model())
8571 
8572 def _prove_html(claim, **keywords):
8573  """Version of function `prove` used in RiSE4Fun."""
8574  if z3_debug():
8575  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8576  s = Solver()
8577  s.set(**keywords)
8578  s.add(Not(claim))
8579  if keywords.get('show', False):
8580  print(s)
8581  r = s.check()
8582  if r == unsat:
8583  print("<b>proved</b>")
8584  elif r == unknown:
8585  print("<b>failed to prove</b>")
8586  print(s.model())
8587  else:
8588  print("<b>counterexample</b>")
8589  print(s.model())
8590 
8591 def _dict2sarray(sorts, ctx):
8592  sz = len(sorts)
8593  _names = (Symbol * sz)()
8594  _sorts = (Sort * sz) ()
8595  i = 0
8596  for k in sorts:
8597  v = sorts[k]
8598  if z3_debug():
8599  _z3_assert(isinstance(k, str), "String expected")
8600  _z3_assert(is_sort(v), "Z3 sort expected")
8601  _names[i] = to_symbol(k, ctx)
8602  _sorts[i] = v.ast
8603  i = i + 1
8604  return sz, _names, _sorts
8605 
8606 def _dict2darray(decls, ctx):
8607  sz = len(decls)
8608  _names = (Symbol * sz)()
8609  _decls = (FuncDecl * sz) ()
8610  i = 0
8611  for k in decls:
8612  v = decls[k]
8613  if z3_debug():
8614  _z3_assert(isinstance(k, str), "String expected")
8615  _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
8616  _names[i] = to_symbol(k, ctx)
8617  if is_const(v):
8618  _decls[i] = v.decl().ast
8619  else:
8620  _decls[i] = v.ast
8621  i = i + 1
8622  return sz, _names, _decls
8623 
8624 
8625 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8626  """Parse a string in SMT 2.0 format using the given sorts and decls.
8627 
8628  The arguments sorts and decls are Python dictionaries used to initialize
8629  the symbol table used for the SMT 2.0 parser.
8630 
8631  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8632  [x > 0, x < 10]
8633  >>> x, y = Ints('x y')
8634  >>> f = Function('f', IntSort(), IntSort())
8635  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8636  [x + f(y) > 0]
8637  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8638  [a > 0]
8639  """
8640  ctx = _get_ctx(ctx)
8641  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8642  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8643  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8644 
8645 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8646  """Parse a file in SMT 2.0 format using the given sorts and decls.
8647 
8648  This function is similar to parse_smt2_string().
8649  """
8650  ctx = _get_ctx(ctx)
8651  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8652  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8653  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8654 
8655 
8656 
8661 
8662 
8663 # Global default rounding mode
8664 _dflt_rounding_mode = Z3_OP_FPA_RM_TOWARD_ZERO
8665 _dflt_fpsort_ebits = 11
8666 _dflt_fpsort_sbits = 53
8667 
8669  """Retrieves the global default rounding mode."""
8670  global _dflt_rounding_mode
8671  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8672  return RTZ(ctx)
8673  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8674  return RTN(ctx)
8675  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8676  return RTP(ctx)
8677  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8678  return RNE(ctx)
8679  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8680  return RNA(ctx)
8681 
8682 def set_default_rounding_mode(rm, ctx=None):
8683  global _dflt_rounding_mode
8684  if is_fprm_value(rm):
8685  _dflt_rounding_mode = rm.decl().kind()
8686  else:
8687  _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8688  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8689  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8690  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8691  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8692  "illegal rounding mode")
8693  _dflt_rounding_mode = rm
8694 
8695 def get_default_fp_sort(ctx=None):
8696  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8697 
8698 def set_default_fp_sort(ebits, sbits, ctx=None):
8699  global _dflt_fpsort_ebits
8700  global _dflt_fpsort_sbits
8701  _dflt_fpsort_ebits = ebits
8702  _dflt_fpsort_sbits = sbits
8703 
8704 def _dflt_rm(ctx=None):
8705  return get_default_rounding_mode(ctx)
8706 
8707 def _dflt_fps(ctx=None):
8708  return get_default_fp_sort(ctx)
8709 
8710 def _coerce_fp_expr_list(alist, ctx):
8711  first_fp_sort = None
8712  for a in alist:
8713  if is_fp(a):
8714  if first_fp_sort is None:
8715  first_fp_sort = a.sort()
8716  elif first_fp_sort == a.sort():
8717  pass # OK, same as before
8718  else:
8719  # we saw at least 2 different float sorts; something will
8720  # throw a sort mismatch later, for now assume None.
8721  first_fp_sort = None
8722  break
8723 
8724  r = []
8725  for i in range(len(alist)):
8726  a = alist[i]
8727  if (isinstance(a, str) and a.contains('2**(') and a.endswith(')')) or _is_int(a) or isinstance(a, float) or isinstance(a, bool):
8728  r.append(FPVal(a, None, first_fp_sort, ctx))
8729  else:
8730  r.append(a)
8731  return _coerce_expr_list(r, ctx)
8732 
8733 
8734 
8735 
8737  """Floating-point sort."""
8738 
8739  def ebits(self):
8740  """Retrieves the number of bits reserved for the exponent in the FloatingPoint sort `self`.
8741  >>> b = FPSort(8, 24)
8742  >>> b.ebits()
8743  8
8744  """
8745  return int(Z3_fpa_get_ebits(self.ctx_refctx_ref(), self.astast))
8746 
8747  def sbits(self):
8748  """Retrieves the number of bits reserved for the significand in the FloatingPoint sort `self`.
8749  >>> b = FPSort(8, 24)
8750  >>> b.sbits()
8751  24
8752  """
8753  return int(Z3_fpa_get_sbits(self.ctx_refctx_ref(), self.astast))
8754 
8755  def cast(self, val):
8756  """Try to cast `val` as a floating-point expression.
8757  >>> b = FPSort(8, 24)
8758  >>> b.cast(1.0)
8759  1
8760  >>> b.cast(1.0).sexpr()
8761  '(fp #b0 #x7f #b00000000000000000000000)'
8762  """
8763  if is_expr(val):
8764  if z3_debug():
8765  _z3_assert(self.ctxctxctx == val.ctx, "Context mismatch")
8766  return val
8767  else:
8768  return FPVal(val, None, self, self.ctxctxctx)
8769 
8770 
8771 def Float16(ctx=None):
8772  """Floating-point 16-bit (half) sort."""
8773  ctx = _get_ctx(ctx)
8774  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8775 
8776 def FloatHalf(ctx=None):
8777  """Floating-point 16-bit (half) sort."""
8778  ctx = _get_ctx(ctx)
8779  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8780 
8781 def Float32(ctx=None):
8782  """Floating-point 32-bit (single) sort."""
8783  ctx = _get_ctx(ctx)
8784  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8785 
8786 def FloatSingle(ctx=None):
8787  """Floating-point 32-bit (single) sort."""
8788  ctx = _get_ctx(ctx)
8789  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8790 
8791 def Float64(ctx=None):
8792  """Floating-point 64-bit (double) sort."""
8793  ctx = _get_ctx(ctx)
8794  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8795 
8796 def FloatDouble(ctx=None):
8797  """Floating-point 64-bit (double) sort."""
8798  ctx = _get_ctx(ctx)
8799  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8800 
8801 def Float128(ctx=None):
8802  """Floating-point 128-bit (quadruple) sort."""
8803  ctx = _get_ctx(ctx)
8804  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8805 
8806 def FloatQuadruple(ctx=None):
8807  """Floating-point 128-bit (quadruple) sort."""
8808  ctx = _get_ctx(ctx)
8809  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8810 
8812  """"Floating-point rounding mode sort."""
8813 
8814 
8815 def is_fp_sort(s):
8816  """Return True if `s` is a Z3 floating-point sort.
8817 
8818  >>> is_fp_sort(FPSort(8, 24))
8819  True
8820  >>> is_fp_sort(IntSort())
8821  False
8822  """
8823  return isinstance(s, FPSortRef)
8824 
8826  """Return True if `s` is a Z3 floating-point rounding mode sort.
8827 
8828  >>> is_fprm_sort(FPSort(8, 24))
8829  False
8830  >>> is_fprm_sort(RNE().sort())
8831  True
8832  """
8833  return isinstance(s, FPRMSortRef)
8834 
8835 
8836 
8838  """Floating-point expressions."""
8839 
8840  def sort(self):
8841  """Return the sort of the floating-point expression `self`.
8842 
8843  >>> x = FP('1.0', FPSort(8, 24))
8844  >>> x.sort()
8845  FPSort(8, 24)
8846  >>> x.sort() == FPSort(8, 24)
8847  True
8848  """
8849  return FPSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
8850 
8851  def ebits(self):
8852  """Retrieves the number of bits reserved for the exponent in the FloatingPoint expression `self`.
8853  >>> b = FPSort(8, 24)
8854  >>> b.ebits()
8855  8
8856  """
8857  return self.sortsortsort().ebits();
8858 
8859  def sbits(self):
8860  """Retrieves the number of bits reserved for the exponent in the FloatingPoint expression `self`.
8861  >>> b = FPSort(8, 24)
8862  >>> b.sbits()
8863  24
8864  """
8865  return self.sortsortsort().sbits();
8866 
8867  def as_string(self):
8868  """Return a Z3 floating point expression as a Python string."""
8869  return Z3_ast_to_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
8870 
8871  def __le__(self, other):
8872  return fpLEQ(self, other, self.ctxctx)
8873 
8874  def __lt__(self, other):
8875  return fpLT(self, other, self.ctxctx)
8876 
8877  def __ge__(self, other):
8878  return fpGEQ(self, other, self.ctxctx)
8879 
8880  def __gt__(self, other):
8881  return fpGT(self, other, self.ctxctx)
8882 
8883  def __add__(self, other):
8884  """Create the Z3 expression `self + other`.
8885 
8886  >>> x = FP('x', FPSort(8, 24))
8887  >>> y = FP('y', FPSort(8, 24))
8888  >>> x + y
8889  x + y
8890  >>> (x + y).sort()
8891  FPSort(8, 24)
8892  """
8893  [a, b] = _coerce_fp_expr_list([self, other], self.ctxctx)
8894  return fpAdd(_dflt_rm(), a, b, self.ctxctx)
8895 
8896  def __radd__(self, other):
8897  """Create the Z3 expression `other + self`.
8898 
8899  >>> x = FP('x', FPSort(8, 24))
8900  >>> 10 + x
8901  1.25*(2**3) + x
8902  """
8903  [a, b] = _coerce_fp_expr_list([other, self], self.ctxctx)
8904  return fpAdd(_dflt_rm(), a, b, self.ctxctx)
8905 
8906  def __sub__(self, other):
8907  """Create the Z3 expression `self - other`.
8908 
8909  >>> x = FP('x', FPSort(8, 24))
8910  >>> y = FP('y', FPSort(8, 24))
8911  >>> x - y
8912  x - y
8913  >>> (x - y).sort()
8914  FPSort(8, 24)
8915  """
8916  [a, b] = _coerce_fp_expr_list([self, other], self.ctxctx)
8917  return fpSub(_dflt_rm(), a, b, self.ctxctx)
8918 
8919  def __rsub__(self, other):
8920  """Create the Z3 expression `other - self`.
8921 
8922  >>> x = FP('x', FPSort(8, 24))
8923  >>> 10 - x
8924  1.25*(2**3) - x
8925  """
8926  [a, b] = _coerce_fp_expr_list([other, self], self.ctxctx)
8927  return fpSub(_dflt_rm(), a, b, self.ctxctx)
8928 
8929  def __mul__(self, other):
8930  """Create the Z3 expression `self * other`.
8931 
8932  >>> x = FP('x', FPSort(8, 24))
8933  >>> y = FP('y', FPSort(8, 24))
8934  >>> x * y
8935  x * y
8936  >>> (x * y).sort()
8937  FPSort(8, 24)
8938  >>> 10 * y
8939  1.25*(2**3) * y
8940  """
8941  [a, b] = _coerce_fp_expr_list([self, other], self.ctxctx)
8942  return fpMul(_dflt_rm(), a, b, self.ctxctx)
8943 
8944  def __rmul__(self, other):
8945  """Create the Z3 expression `other * self`.
8946 
8947  >>> x = FP('x', FPSort(8, 24))
8948  >>> y = FP('y', FPSort(8, 24))
8949  >>> x * y
8950  x * y
8951  >>> x * 10
8952  x * 1.25*(2**3)
8953  """
8954  [a, b] = _coerce_fp_expr_list([other, self], self.ctxctx)
8955  return fpMul(_dflt_rm(), a, b, self.ctxctx)
8956 
8957  def __pos__(self):
8958  """Create the Z3 expression `+self`."""
8959  return self
8960 
8961  def __neg__(self):
8962  """Create the Z3 expression `-self`.
8963 
8964  >>> x = FP('x', Float32())
8965  >>> -x
8966  -x
8967  """
8968  return fpNeg(self)
8969 
8970  def __div__(self, other):
8971  """Create the Z3 expression `self / other`.
8972 
8973  >>> x = FP('x', FPSort(8, 24))
8974  >>> y = FP('y', FPSort(8, 24))
8975  >>> x / y
8976  x / y
8977  >>> (x / y).sort()
8978  FPSort(8, 24)
8979  >>> 10 / y
8980  1.25*(2**3) / y
8981  """
8982  [a, b] = _coerce_fp_expr_list([self, other], self.ctxctx)
8983  return fpDiv(_dflt_rm(), a, b, self.ctxctx)
8984 
8985  def __rdiv__(self, other):
8986  """Create the Z3 expression `other / self`.
8987 
8988  >>> x = FP('x', FPSort(8, 24))
8989  >>> y = FP('y', FPSort(8, 24))
8990  >>> x / y
8991  x / y
8992  >>> x / 10
8993  x / 1.25*(2**3)
8994  """
8995  [a, b] = _coerce_fp_expr_list([other, self], self.ctxctx)
8996  return fpDiv(_dflt_rm(), a, b, self.ctxctx)
8997 
8998  def __truediv__(self, other):
8999  """Create the Z3 expression division `self / other`."""
9000  return self.__div____div__(other)
9001 
9002  def __rtruediv__(self, other):
9003  """Create the Z3 expression division `other / self`."""
9004  return self.__rdiv____rdiv__(other)
9005 
9006  def __mod__(self, other):
9007  """Create the Z3 expression mod `self % other`."""
9008  return fpRem(self, other)
9009 
9010  def __rmod__(self, other):
9011  """Create the Z3 expression mod `other % self`."""
9012  return fpRem(other, self)
9013 
9015  """Floating-point rounding mode expressions"""
9016 
9017  def as_string(self):
9018  """Return a Z3 floating point expression as a Python string."""
9019  return Z3_ast_to_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
9020 
9021 
9023  ctx = _get_ctx(ctx)
9024  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9025 
9026 def RNE (ctx=None):
9027  ctx = _get_ctx(ctx)
9028  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9029 
9031  ctx = _get_ctx(ctx)
9032  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9033 
9034 def RNA (ctx=None):
9035  ctx = _get_ctx(ctx)
9036  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9037 
9038 def RoundTowardPositive(ctx=None):
9039  ctx = _get_ctx(ctx)
9040  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9041 
9042 def RTP(ctx=None):
9043  ctx = _get_ctx(ctx)
9044  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9045 
9046 def RoundTowardNegative(ctx=None):
9047  ctx = _get_ctx(ctx)
9048  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9049 
9050 def RTN(ctx=None):
9051  ctx = _get_ctx(ctx)
9052  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9053 
9054 def RoundTowardZero(ctx=None):
9055  ctx = _get_ctx(ctx)
9056  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9057 
9058 def RTZ(ctx=None):
9059  ctx = _get_ctx(ctx)
9060  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9061 
9062 def is_fprm(a):
9063  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9064 
9065  >>> rm = RNE()
9066  >>> is_fprm(rm)
9067  True
9068  >>> rm = 1.0
9069  >>> is_fprm(rm)
9070  False
9071  """
9072  return isinstance(a, FPRMRef)
9073 
9075  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9076  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9077 
9078 
9079 
9081  """The sign of the numeral.
9082 
9083  >>> x = FPVal(+1.0, FPSort(8, 24))
9084  >>> x.sign()
9085  False
9086  >>> x = FPVal(-1.0, FPSort(8, 24))
9087  >>> x.sign()
9088  True
9089  """
9090  def sign(self):
9091  l = (ctypes.c_int)()
9092  if Z3_fpa_get_numeral_sign(self.ctxctx.ref(), self.as_astas_astas_ast(), byref(l)) == False:
9093  raise Z3Exception("error retrieving the sign of a numeral.")
9094  return l.value != 0
9095 
9096  """The sign of a floating-point numeral as a bit-vector expression.
9097 
9098  Remark: NaN's are invalid arguments.
9099  """
9100  def sign_as_bv(self):
9101  return BitVecNumRef(Z3_fpa_get_numeral_sign_bv(self.ctxctx.ref(), self.as_astas_astas_ast()), self.ctxctx)
9102 
9103  """The significand of the numeral.
9104 
9105  >>> x = FPVal(2.5, FPSort(8, 24))
9106  >>> x.significand()
9107  1.25
9108  """
9109  def significand(self):
9110  return Z3_fpa_get_numeral_significand_string(self.ctxctx.ref(), self.as_astas_astas_ast())
9111 
9112  """The significand of the numeral as a long.
9113 
9114  >>> x = FPVal(2.5, FPSort(8, 24))
9115  >>> x.significand_as_long()
9116  1.25
9117  """
9119  ptr = (ctypes.c_ulonglong * 1)()
9120  if not Z3_fpa_get_numeral_significand_uint64(self.ctxctx.ref(), self.as_astas_astas_ast(), ptr):
9121  raise Z3Exception("error retrieving the significand of a numeral.")
9122  return ptr[0]
9123 
9124  """The significand of the numeral as a bit-vector expression.
9125 
9126  Remark: NaN are invalid arguments.
9127  """
9129  return BitVecNumRef(Z3_fpa_get_numeral_significand_bv(self.ctxctx.ref(), self.as_astas_astas_ast()), self.ctxctx)
9130 
9131  """The exponent of the numeral.
9132 
9133  >>> x = FPVal(2.5, FPSort(8, 24))
9134  >>> x.exponent()
9135  1
9136  """
9137  def exponent(self, biased=True):
9138  return Z3_fpa_get_numeral_exponent_string(self.ctxctx.ref(), self.as_astas_astas_ast(), biased)
9139 
9140  """The exponent of the numeral as a long.
9141 
9142  >>> x = FPVal(2.5, FPSort(8, 24))
9143  >>> x.exponent_as_long()
9144  1
9145  """
9146  def exponent_as_long(self, biased=True):
9147  ptr = (ctypes.c_longlong * 1)()
9148  if not Z3_fpa_get_numeral_exponent_int64(self.ctxctx.ref(), self.as_astas_astas_ast(), ptr, biased):
9149  raise Z3Exception("error retrieving the exponent of a numeral.")
9150  return ptr[0]
9151 
9152  """The exponent of the numeral as a bit-vector expression.
9153 
9154  Remark: NaNs are invalid arguments.
9155  """
9156  def exponent_as_bv(self, biased=True):
9157  return BitVecNumRef(Z3_fpa_get_numeral_exponent_bv(self.ctxctx.ref(), self.as_astas_astas_ast(), biased), self.ctxctx)
9158 
9159  """Indicates whether the numeral is a NaN."""
9160  def isNaN(self):
9161  return Z3_fpa_is_numeral_nan(self.ctxctx.ref(), self.as_astas_astas_ast())
9162 
9163  """Indicates whether the numeral is +oo or -oo."""
9164  def isInf(self):
9165  return Z3_fpa_is_numeral_inf(self.ctxctx.ref(), self.as_astas_astas_ast())
9166 
9167  """Indicates whether the numeral is +zero or -zero."""
9168  def isZero(self):
9169  return Z3_fpa_is_numeral_zero(self.ctxctx.ref(), self.as_astas_astas_ast())
9170 
9171  """Indicates whether the numeral is normal."""
9172  def isNormal(self):
9173  return Z3_fpa_is_numeral_normal(self.ctxctx.ref(), self.as_astas_astas_ast())
9174 
9175  """Indicates whether the numeral is subnormal."""
9176  def isSubnormal(self):
9177  return Z3_fpa_is_numeral_subnormal(self.ctxctx.ref(), self.as_astas_astas_ast())
9178 
9179  """Indicates whether the numeral is positive."""
9180  def isPositive(self):
9181  return Z3_fpa_is_numeral_positive(self.ctxctx.ref(), self.as_astas_astas_ast())
9182 
9183  """Indicates whether the numeral is negative."""
9184  def isNegative(self):
9185  return Z3_fpa_is_numeral_negative(self.ctxctx.ref(), self.as_astas_astas_ast())
9186 
9187  """
9188  The string representation of the numeral.
9189 
9190  >>> x = FPVal(20, FPSort(8, 24))
9191  >>> x.as_string()
9192  1.25*(2**4)
9193  """
9194  def as_string(self):
9195  s = Z3_get_numeral_string(self.ctxctx.ref(), self.as_astas_astas_ast())
9196  return ("FPVal(%s, %s)" % (s, self.sortsortsort()))
9197 
9198 def is_fp(a):
9199  """Return `True` if `a` is a Z3 floating-point expression.
9200 
9201  >>> b = FP('b', FPSort(8, 24))
9202  >>> is_fp(b)
9203  True
9204  >>> is_fp(b + 1.0)
9205  True
9206  >>> is_fp(Int('x'))
9207  False
9208  """
9209  return isinstance(a, FPRef)
9210 
9212  """Return `True` if `a` is a Z3 floating-point numeral value.
9213 
9214  >>> b = FP('b', FPSort(8, 24))
9215  >>> is_fp_value(b)
9216  False
9217  >>> b = FPVal(1.0, FPSort(8, 24))
9218  >>> b
9219  1
9220  >>> is_fp_value(b)
9221  True
9222  """
9223  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9224 
9225 def FPSort(ebits, sbits, ctx=None):
9226  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9227 
9228  >>> Single = FPSort(8, 24)
9229  >>> Double = FPSort(11, 53)
9230  >>> Single
9231  FPSort(8, 24)
9232  >>> x = Const('x', Single)
9233  >>> eq(x, FP('x', FPSort(8, 24)))
9234  True
9235  """
9236  ctx = _get_ctx(ctx)
9237  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9238 
9239 def _to_float_str(val, exp=0):
9240  if isinstance(val, float):
9241  if math.isnan(val):
9242  res = "NaN"
9243  elif val == 0.0:
9244  sone = math.copysign(1.0, val)
9245  if sone < 0.0:
9246  return "-0.0"
9247  else:
9248  return "+0.0"
9249  elif val == float("+inf"):
9250  res = "+oo"
9251  elif val == float("-inf"):
9252  res = "-oo"
9253  else:
9254  v = val.as_integer_ratio()
9255  num = v[0]
9256  den = v[1]
9257  rvs = str(num) + '/' + str(den)
9258  res = rvs + 'p' + _to_int_str(exp)
9259  elif isinstance(val, bool):
9260  if val:
9261  res = "1.0"
9262  else:
9263  res = "0.0"
9264  elif _is_int(val):
9265  res = str(val)
9266  elif isinstance(val, str):
9267  inx = val.find('*(2**')
9268  if inx == -1:
9269  res = val
9270  elif val[-1] == ')':
9271  res = val[0:inx]
9272  exp = str(int(val[inx+5:-1]) + int(exp))
9273  else:
9274  _z3_assert(False, "String does not have floating-point numeral form.")
9275  elif z3_debug():
9276  _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
9277  if exp == 0:
9278  return res
9279  else:
9280  return res + 'p' + exp
9281 
9282 
9283 def fpNaN(s):
9284  """Create a Z3 floating-point NaN term.
9285 
9286  >>> s = FPSort(8, 24)
9287  >>> set_fpa_pretty(True)
9288  >>> fpNaN(s)
9289  NaN
9290  >>> pb = get_fpa_pretty()
9291  >>> set_fpa_pretty(False)
9292  >>> fpNaN(s)
9293  fpNaN(FPSort(8, 24))
9294  >>> set_fpa_pretty(pb)
9295  """
9296  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9297  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9298 
9300  """Create a Z3 floating-point +oo term.
9301 
9302  >>> s = FPSort(8, 24)
9303  >>> pb = get_fpa_pretty()
9304  >>> set_fpa_pretty(True)
9305  >>> fpPlusInfinity(s)
9306  +oo
9307  >>> set_fpa_pretty(False)
9308  >>> fpPlusInfinity(s)
9309  fpPlusInfinity(FPSort(8, 24))
9310  >>> set_fpa_pretty(pb)
9311  """
9312  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9313  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9314 
9316  """Create a Z3 floating-point -oo term."""
9317  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9318  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9319 
9320 def fpInfinity(s, negative):
9321  """Create a Z3 floating-point +oo or -oo term."""
9322  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9323  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9324  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9325 
9326 def fpPlusZero(s):
9327  """Create a Z3 floating-point +0.0 term."""
9328  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9329  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9330 
9332  """Create a Z3 floating-point -0.0 term."""
9333  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9334  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9335 
9336 def fpZero(s, negative):
9337  """Create a Z3 floating-point +0.0 or -0.0 term."""
9338  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9339  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9340  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9341 
9342 def FPVal(sig, exp=None, fps=None, ctx=None):
9343  """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9344 
9345  >>> v = FPVal(20.0, FPSort(8, 24))
9346  >>> v
9347  1.25*(2**4)
9348  >>> print("0x%.8x" % v.exponent_as_long(False))
9349  0x00000004
9350  >>> v = FPVal(2.25, FPSort(8, 24))
9351  >>> v
9352  1.125*(2**1)
9353  >>> v = FPVal(-2.25, FPSort(8, 24))
9354  >>> v
9355  -1.125*(2**1)
9356  >>> FPVal(-0.0, FPSort(8, 24))
9357  -0.0
9358  >>> FPVal(0.0, FPSort(8, 24))
9359  +0.0
9360  >>> FPVal(+0.0, FPSort(8, 24))
9361  +0.0
9362  """
9363  ctx = _get_ctx(ctx)
9364  if is_fp_sort(exp):
9365  fps = exp
9366  exp = None
9367  elif fps is None:
9368  fps = _dflt_fps(ctx)
9369  _z3_assert(is_fp_sort(fps), "sort mismatch")
9370  if exp is None:
9371  exp = 0
9372  val = _to_float_str(sig)
9373  if val == "NaN" or val == "nan":
9374  return fpNaN(fps)
9375  elif val == "-0.0":
9376  return fpMinusZero(fps)
9377  elif val == "0.0" or val == "+0.0":
9378  return fpPlusZero(fps)
9379  elif val == "+oo" or val == "+inf" or val == "+Inf":
9380  return fpPlusInfinity(fps)
9381  elif val == "-oo" or val == "-inf" or val == "-Inf":
9382  return fpMinusInfinity(fps)
9383  else:
9384  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9385 
9386 def FP(name, fpsort, ctx=None):
9387  """Return a floating-point constant named `name`.
9388  `fpsort` is the floating-point sort.
9389  If `ctx=None`, then the global context is used.
9390 
9391  >>> x = FP('x', FPSort(8, 24))
9392  >>> is_fp(x)
9393  True
9394  >>> x.ebits()
9395  8
9396  >>> x.sort()
9397  FPSort(8, 24)
9398  >>> word = FPSort(8, 24)
9399  >>> x2 = FP('x', word)
9400  >>> eq(x, x2)
9401  True
9402  """
9403  if isinstance(fpsort, FPSortRef) and ctx is None:
9404  ctx = fpsort.ctx
9405  else:
9406  ctx = _get_ctx(ctx)
9407  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9408 
9409 def FPs(names, fpsort, ctx=None):
9410  """Return an array of floating-point constants.
9411 
9412  >>> x, y, z = FPs('x y z', FPSort(8, 24))
9413  >>> x.sort()
9414  FPSort(8, 24)
9415  >>> x.sbits()
9416  24
9417  >>> x.ebits()
9418  8
9419  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9420  fpMul(RNE(), fpAdd(RNE(), x, y), z)
9421  """
9422  ctx = _get_ctx(ctx)
9423  if isinstance(names, str):
9424  names = names.split(" ")
9425  return [FP(name, fpsort, ctx) for name in names]
9426 
9427 def fpAbs(a, ctx=None):
9428  """Create a Z3 floating-point absolute value expression.
9429 
9430  >>> s = FPSort(8, 24)
9431  >>> rm = RNE()
9432  >>> x = FPVal(1.0, s)
9433  >>> fpAbs(x)
9434  fpAbs(1)
9435  >>> y = FPVal(-20.0, s)
9436  >>> y
9437  -1.25*(2**4)
9438  >>> fpAbs(y)
9439  fpAbs(-1.25*(2**4))
9440  >>> fpAbs(-1.25*(2**4))
9441  fpAbs(-1.25*(2**4))
9442  >>> fpAbs(x).sort()
9443  FPSort(8, 24)
9444  """
9445  ctx = _get_ctx(ctx)
9446  [a] = _coerce_fp_expr_list([a], ctx)
9447  return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
9448 
9449 def fpNeg(a, ctx=None):
9450  """Create a Z3 floating-point addition expression.
9451 
9452  >>> s = FPSort(8, 24)
9453  >>> rm = RNE()
9454  >>> x = FP('x', s)
9455  >>> fpNeg(x)
9456  -x
9457  >>> fpNeg(x).sort()
9458  FPSort(8, 24)
9459  """
9460  ctx = _get_ctx(ctx)
9461  [a] = _coerce_fp_expr_list([a], ctx)
9462  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9463 
9464 def _mk_fp_unary(f, rm, a, ctx):
9465  ctx = _get_ctx(ctx)
9466  [a] = _coerce_fp_expr_list([a], ctx)
9467  if z3_debug():
9468  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9469  _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
9470  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
9471 
9472 def _mk_fp_unary_pred(f, a, ctx):
9473  ctx = _get_ctx(ctx)
9474  [a] = _coerce_fp_expr_list([a], ctx)
9475  if z3_debug():
9476  _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
9477  return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
9478 
9479 def _mk_fp_bin(f, rm, a, b, ctx):
9480  ctx = _get_ctx(ctx)
9481  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9482  if z3_debug():
9483  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9484  _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
9485  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
9486 
9487 def _mk_fp_bin_norm(f, a, b, ctx):
9488  ctx = _get_ctx(ctx)
9489  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9490  if z3_debug():
9491  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9492  return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
9493 
9494 def _mk_fp_bin_pred(f, a, b, ctx):
9495  ctx = _get_ctx(ctx)
9496  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9497  if z3_debug():
9498  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9499  return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
9500 
9501 def _mk_fp_tern(f, rm, a, b, c, ctx):
9502  ctx = _get_ctx(ctx)
9503  [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
9504  if z3_debug():
9505  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9506  _z3_assert(is_fp(a) or is_fp(b) or is_fp(c), "Second, third or fourth argument must be a Z3 floating-point expression")
9507  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
9508 
9509 def fpAdd(rm, a, b, ctx=None):
9510  """Create a Z3 floating-point addition expression.
9511 
9512  >>> s = FPSort(8, 24)
9513  >>> rm = RNE()
9514  >>> x = FP('x', s)
9515  >>> y = FP('y', s)
9516  >>> fpAdd(rm, x, y)
9517  fpAdd(RNE(), x, y)
9518  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9519  x + y
9520  >>> fpAdd(rm, x, y).sort()
9521  FPSort(8, 24)
9522  """
9523  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9524 
9525 def fpSub(rm, a, b, ctx=None):
9526  """Create a Z3 floating-point subtraction expression.
9527 
9528  >>> s = FPSort(8, 24)
9529  >>> rm = RNE()
9530  >>> x = FP('x', s)
9531  >>> y = FP('y', s)
9532  >>> fpSub(rm, x, y)
9533  fpSub(RNE(), x, y)
9534  >>> fpSub(rm, x, y).sort()
9535  FPSort(8, 24)
9536  """
9537  return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
9538 
9539 def fpMul(rm, a, b, ctx=None):
9540  """Create a Z3 floating-point multiplication expression.
9541 
9542  >>> s = FPSort(8, 24)
9543  >>> rm = RNE()
9544  >>> x = FP('x', s)
9545  >>> y = FP('y', s)
9546  >>> fpMul(rm, x, y)
9547  fpMul(RNE(), x, y)
9548  >>> fpMul(rm, x, y).sort()
9549  FPSort(8, 24)
9550  """
9551  return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
9552 
9553 def fpDiv(rm, a, b, ctx=None):
9554  """Create a Z3 floating-point division expression.
9555 
9556  >>> s = FPSort(8, 24)
9557  >>> rm = RNE()
9558  >>> x = FP('x', s)
9559  >>> y = FP('y', s)
9560  >>> fpDiv(rm, x, y)
9561  fpDiv(RNE(), x, y)
9562  >>> fpDiv(rm, x, y).sort()
9563  FPSort(8, 24)
9564  """
9565  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
9566 
9567 def fpRem(a, b, ctx=None):
9568  """Create a Z3 floating-point remainder expression.
9569 
9570  >>> s = FPSort(8, 24)
9571  >>> x = FP('x', s)
9572  >>> y = FP('y', s)
9573  >>> fpRem(x, y)
9574  fpRem(x, y)
9575  >>> fpRem(x, y).sort()
9576  FPSort(8, 24)
9577  """
9578  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9579 
9580 def fpMin(a, b, ctx=None):
9581  """Create a Z3 floating-point minimum expression.
9582 
9583  >>> s = FPSort(8, 24)
9584  >>> rm = RNE()
9585  >>> x = FP('x', s)
9586  >>> y = FP('y', s)
9587  >>> fpMin(x, y)
9588  fpMin(x, y)
9589  >>> fpMin(x, y).sort()
9590  FPSort(8, 24)
9591  """
9592  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
9593 
9594 def fpMax(a, b, ctx=None):
9595  """Create a Z3 floating-point maximum expression.
9596 
9597  >>> s = FPSort(8, 24)
9598  >>> rm = RNE()
9599  >>> x = FP('x', s)
9600  >>> y = FP('y', s)
9601  >>> fpMax(x, y)
9602  fpMax(x, y)
9603  >>> fpMax(x, y).sort()
9604  FPSort(8, 24)
9605  """
9606  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9607 
9608 def fpFMA(rm, a, b, c, ctx=None):
9609  """Create a Z3 floating-point fused multiply-add expression.
9610  """
9611  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9612 
9613 def fpSqrt(rm, a, ctx=None):
9614  """Create a Z3 floating-point square root expression.
9615  """
9616  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9617 
9618 def fpRoundToIntegral(rm, a, ctx=None):
9619  """Create a Z3 floating-point roundToIntegral expression.
9620  """
9621  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9622 
9623 def fpIsNaN(a, ctx=None):
9624  """Create a Z3 floating-point isNaN expression.
9625 
9626  >>> s = FPSort(8, 24)
9627  >>> x = FP('x', s)
9628  >>> y = FP('y', s)
9629  >>> fpIsNaN(x)
9630  fpIsNaN(x)
9631  """
9632  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9633 
9634 def fpIsInf(a, ctx=None):
9635  """Create a Z3 floating-point isInfinite expression.
9636 
9637  >>> s = FPSort(8, 24)
9638  >>> x = FP('x', s)
9639  >>> fpIsInf(x)
9640  fpIsInf(x)
9641  """
9642  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9643 
9644 def fpIsZero(a, ctx=None):
9645  """Create a Z3 floating-point isZero expression.
9646  """
9647  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9648 
9649 def fpIsNormal(a, ctx=None):
9650  """Create a Z3 floating-point isNormal expression.
9651  """
9652  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9653 
9654 def fpIsSubnormal(a, ctx=None):
9655  """Create a Z3 floating-point isSubnormal expression.
9656  """
9657  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9658 
9659 def fpIsNegative(a, ctx=None):
9660  """Create a Z3 floating-point isNegative expression.
9661  """
9662  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9663 
9664 def fpIsPositive(a, ctx=None):
9665  """Create a Z3 floating-point isPositive expression.
9666  """
9667  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9668 
9669 def _check_fp_args(a, b):
9670  if z3_debug():
9671  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9672 
9673 def fpLT(a, b, ctx=None):
9674  """Create the Z3 floating-point expression `other < self`.
9675 
9676  >>> x, y = FPs('x y', FPSort(8, 24))
9677  >>> fpLT(x, y)
9678  x < y
9679  >>> (x < y).sexpr()
9680  '(fp.lt x y)'
9681  """
9682  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
9683 
9684 def fpLEQ(a, b, ctx=None):
9685  """Create the Z3 floating-point expression `other <= self`.
9686 
9687  >>> x, y = FPs('x y', FPSort(8, 24))
9688  >>> fpLEQ(x, y)
9689  x <= y
9690  >>> (x <= y).sexpr()
9691  '(fp.leq x y)'
9692  """
9693  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
9694 
9695 def fpGT(a, b, ctx=None):
9696  """Create the Z3 floating-point expression `other > self`.
9697 
9698  >>> x, y = FPs('x y', FPSort(8, 24))
9699  >>> fpGT(x, y)
9700  x > y
9701  >>> (x > y).sexpr()
9702  '(fp.gt x y)'
9703  """
9704  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
9705 
9706 def fpGEQ(a, b, ctx=None):
9707  """Create the Z3 floating-point expression `other >= self`.
9708 
9709  >>> x, y = FPs('x y', FPSort(8, 24))
9710  >>> fpGEQ(x, y)
9711  x >= y
9712  >>> (x >= y).sexpr()
9713  '(fp.geq x y)'
9714  """
9715  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
9716 
9717 def fpEQ(a, b, ctx=None):
9718  """Create the Z3 floating-point expression `fpEQ(other, self)`.
9719 
9720  >>> x, y = FPs('x y', FPSort(8, 24))
9721  >>> fpEQ(x, y)
9722  fpEQ(x, y)
9723  >>> fpEQ(x, y).sexpr()
9724  '(fp.eq x y)'
9725  """
9726  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
9727 
9728 def fpNEQ(a, b, ctx=None):
9729  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9730 
9731  >>> x, y = FPs('x y', FPSort(8, 24))
9732  >>> fpNEQ(x, y)
9733  Not(fpEQ(x, y))
9734  >>> (x != y).sexpr()
9735  '(distinct x y)'
9736  """
9737  return Not(fpEQ(a, b, ctx))
9738 
9739 def fpFP(sgn, exp, sig, ctx=None):
9740  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9741 
9742  >>> s = FPSort(8, 24)
9743  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9744  >>> print(x)
9745  fpFP(1, 127, 4194304)
9746  >>> xv = FPVal(-1.5, s)
9747  >>> print(xv)
9748  -1.5
9749  >>> slvr = Solver()
9750  >>> slvr.add(fpEQ(x, xv))
9751  >>> slvr.check()
9752  sat
9753  >>> xv = FPVal(+1.5, s)
9754  >>> print(xv)
9755  1.5
9756  >>> slvr = Solver()
9757  >>> slvr.add(fpEQ(x, xv))
9758  >>> slvr.check()
9759  unsat
9760  """
9761  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9762  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9763  ctx = _get_ctx(ctx)
9764  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9765  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9766 
9767 def fpToFP(a1, a2=None, a3=None, ctx=None):
9768  """Create a Z3 floating-point conversion expression from other term sorts
9769  to floating-point.
9770 
9771  From a bit-vector term in IEEE 754-2008 format:
9772  >>> x = FPVal(1.0, Float32())
9773  >>> x_bv = fpToIEEEBV(x)
9774  >>> simplify(fpToFP(x_bv, Float32()))
9775  1
9776 
9777  From a floating-point term with different precision:
9778  >>> x = FPVal(1.0, Float32())
9779  >>> x_db = fpToFP(RNE(), x, Float64())
9780  >>> x_db.sort()
9781  FPSort(11, 53)
9782 
9783  From a real term:
9784  >>> x_r = RealVal(1.5)
9785  >>> simplify(fpToFP(RNE(), x_r, Float32()))
9786  1.5
9787 
9788  From a signed bit-vector term:
9789  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9790  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9791  -1.25*(2**2)
9792  """
9793  ctx = _get_ctx(ctx)
9794  if is_bv(a1) and is_fp_sort(a2):
9795  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9796  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9797  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9798  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9799  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9800  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9801  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9802  else:
9803  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9804 
9805 def fpBVToFP(v, sort, ctx=None):
9806  """Create a Z3 floating-point conversion expression that represents the
9807  conversion from a bit-vector term to a floating-point term.
9808 
9809  >>> x_bv = BitVecVal(0x3F800000, 32)
9810  >>> x_fp = fpBVToFP(x_bv, Float32())
9811  >>> x_fp
9812  fpToFP(1065353216)
9813  >>> simplify(x_fp)
9814  1
9815  """
9816  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
9817  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9818  ctx = _get_ctx(ctx)
9819  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9820 
9821 def fpFPToFP(rm, v, sort, ctx=None):
9822  """Create a Z3 floating-point conversion expression that represents the
9823  conversion from a floating-point term to a floating-point term of different precision.
9824 
9825  >>> x_sgl = FPVal(1.0, Float32())
9826  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9827  >>> x_dbl
9828  fpToFP(RNE(), 1)
9829  >>> simplify(x_dbl)
9830  1
9831  >>> x_dbl.sort()
9832  FPSort(11, 53)
9833  """
9834  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9835  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9836  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9837  ctx = _get_ctx(ctx)
9838  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9839 
9840 def fpRealToFP(rm, v, sort, ctx=None):
9841  """Create a Z3 floating-point conversion expression that represents the
9842  conversion from a real term to a floating-point term.
9843 
9844  >>> x_r = RealVal(1.5)
9845  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9846  >>> x_fp
9847  fpToFP(RNE(), 3/2)
9848  >>> simplify(x_fp)
9849  1.5
9850  """
9851  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9852  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9853  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9854  ctx = _get_ctx(ctx)
9855  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9856 
9857 def fpSignedToFP(rm, v, sort, ctx=None):
9858  """Create a Z3 floating-point conversion expression that represents the
9859  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
9860 
9861  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9862  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
9863  >>> x_fp
9864  fpToFP(RNE(), 4294967291)
9865  >>> simplify(x_fp)
9866  -1.25*(2**2)
9867  """
9868  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9869  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9870  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9871  ctx = _get_ctx(ctx)
9872  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9873 
9874 def fpUnsignedToFP(rm, v, sort, ctx=None):
9875  """Create a Z3 floating-point conversion expression that represents the
9876  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9877 
9878  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9879  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9880  >>> x_fp
9881  fpToFPUnsigned(RNE(), 4294967291)
9882  >>> simplify(x_fp)
9883  1*(2**32)
9884  """
9885  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9886  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9887  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9888  ctx = _get_ctx(ctx)
9889  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9890 
9891 def fpToFPUnsigned(rm, x, s, ctx=None):
9892  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
9893  if z3_debug():
9894  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9895  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
9896  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9897  ctx = _get_ctx(ctx)
9898  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9899 
9900 def fpToSBV(rm, x, s, ctx=None):
9901  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
9902 
9903  >>> x = FP('x', FPSort(8, 24))
9904  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
9905  >>> print(is_fp(x))
9906  True
9907  >>> print(is_bv(y))
9908  True
9909  >>> print(is_fp(y))
9910  False
9911  >>> print(is_bv(x))
9912  False
9913  """
9914  if z3_debug():
9915  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9916  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9917  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9918  ctx = _get_ctx(ctx)
9919  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9920 
9921 def fpToUBV(rm, x, s, ctx=None):
9922  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9923 
9924  >>> x = FP('x', FPSort(8, 24))
9925  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9926  >>> print(is_fp(x))
9927  True
9928  >>> print(is_bv(y))
9929  True
9930  >>> print(is_fp(y))
9931  False
9932  >>> print(is_bv(x))
9933  False
9934  """
9935  if z3_debug():
9936  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9937  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9938  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9939  ctx = _get_ctx(ctx)
9940  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9941 
9942 def fpToReal(x, ctx=None):
9943  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9944 
9945  >>> x = FP('x', FPSort(8, 24))
9946  >>> y = fpToReal(x)
9947  >>> print(is_fp(x))
9948  True
9949  >>> print(is_real(y))
9950  True
9951  >>> print(is_fp(y))
9952  False
9953  >>> print(is_real(x))
9954  False
9955  """
9956  if z3_debug():
9957  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9958  ctx = _get_ctx(ctx)
9959  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9960 
9961 def fpToIEEEBV(x, ctx=None):
9962  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9963 
9964  The size of the resulting bit-vector is automatically determined.
9965 
9966  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9967  knows only one NaN and it will always produce the same bit-vector representation of
9968  that NaN.
9969 
9970  >>> x = FP('x', FPSort(8, 24))
9971  >>> y = fpToIEEEBV(x)
9972  >>> print(is_fp(x))
9973  True
9974  >>> print(is_bv(y))
9975  True
9976  >>> print(is_fp(y))
9977  False
9978  >>> print(is_bv(x))
9979  False
9980  """
9981  if z3_debug():
9982  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9983  ctx = _get_ctx(ctx)
9984  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
9985 
9986 
9987 
9988 
9993 
9995  """Sequence sort."""
9996 
9997  def is_string(self):
9998  """Determine if sort is a string
9999  >>> s = StringSort()
10000  >>> s.is_string()
10001  True
10002  >>> s = SeqSort(IntSort())
10003  >>> s.is_string()
10004  False
10005  """
10006  return Z3_is_string_sort(self.ctx_refctx_ref(), self.astast)
10007 
10008  def basis(self):
10009  return _to_sort_ref(Z3_get_seq_sort_basis(self.ctx_refctx_ref(), self.astast), self.ctxctx)
10010 
10011 
10012 def StringSort(ctx=None):
10013  """Create a string sort
10014  >>> s = StringSort()
10015  >>> print(s)
10016  String
10017  """
10018  ctx = _get_ctx(ctx)
10019  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10020 
10021 
10022 def SeqSort(s):
10023  """Create a sequence sort over elements provided in the argument
10024  >>> s = SeqSort(IntSort())
10025  >>> s == Unit(IntVal(1)).sort()
10026  True
10027  """
10028  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10029 
10031  """Sequence expression."""
10032 
10033  def sort(self):
10034  return SeqSortRef(Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()), self.ctxctx)
10035 
10036  def __add__(self, other):
10037  return Concat(self, other)
10038 
10039  def __radd__(self, other):
10040  return Concat(other, self)
10041 
10042  def __getitem__(self, i):
10043  if _is_int(i):
10044  i = IntVal(i, self.ctxctx)
10045  return _to_expr_ref(Z3_mk_seq_nth(self.ctx_refctx_ref(), self.as_astas_astas_ast(), i.as_ast()), self.ctxctx)
10046 
10047  def at(self, i):
10048  if _is_int(i):
10049  i = IntVal(i, self.ctxctx)
10050  return SeqRef(Z3_mk_seq_at(self.ctx_refctx_ref(), self.as_astas_astas_ast(), i.as_ast()), self.ctxctx)
10051 
10052  def is_string(self):
10053  return Z3_is_string_sort(self.ctx_refctx_ref(), Z3_get_sort(self.ctx_refctx_ref(), self.as_astas_astas_ast()))
10054 
10055  def is_string_value(self):
10056  return Z3_is_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
10057 
10058 
10059  def as_string(self):
10060  """Return a string representation of sequence expression."""
10061  if self.is_string_valueis_string_value():
10062  string_length = ctypes.c_uint()
10063  chars = Z3_get_lstring(self.ctx_refctx_ref(), self.as_astas_astas_ast(), byref(string_length))
10064  return string_at(chars, size=string_length.value).decode('latin-1')
10065  return Z3_ast_to_string(self.ctx_refctx_ref(), self.as_astas_astas_ast())
10066 
10067  def __le__(self, other):
10068  return SeqRef(Z3_mk_str_le(self.ctx_refctx_ref(), self.as_astas_astas_ast(), other.as_ast()), self.ctxctx)
10069 
10070  def __lt__(self, other):
10071  return SeqRef(Z3_mk_str_lt(self.ctx_refctx_ref(), self.as_astas_astas_ast(), other.as_ast()), self.ctxctx)
10072 
10073  def __ge__(self, other):
10074  return SeqRef(Z3_mk_str_le(self.ctx_refctx_ref(), other.as_ast(), self.as_astas_astas_ast()), self.ctxctx)
10075 
10076  def __gt__(self, other):
10077  return SeqRef(Z3_mk_str_lt(self.ctx_refctx_ref(), other.as_ast(), self.as_astas_astas_ast()), self.ctxctx)
10078 
10079 
10080 def _coerce_seq(s, ctx=None):
10081  if isinstance(s, str):
10082  ctx = _get_ctx(ctx)
10083  s = StringVal(s, ctx)
10084  if not is_expr(s):
10085  raise Z3Exception("Non-expression passed as a sequence")
10086  if not is_seq(s):
10087  raise Z3Exception("Non-sequence passed as a sequence")
10088  return s
10089 
10090 def _get_ctx2(a, b, ctx=None):
10091  if is_expr(a):
10092  return a.ctx
10093  if is_expr(b):
10094  return b.ctx
10095  if ctx is None:
10096  ctx = main_ctx()
10097  return ctx
10098 
10099 def is_seq(a):
10100  """Return `True` if `a` is a Z3 sequence expression.
10101  >>> print (is_seq(Unit(IntVal(0))))
10102  True
10103  >>> print (is_seq(StringVal("abc")))
10104  True
10105  """
10106  return isinstance(a, SeqRef)
10107 
10108 def is_string(a):
10109  """Return `True` if `a` is a Z3 string expression.
10110  >>> print (is_string(StringVal("ab")))
10111  True
10112  """
10113  return isinstance(a, SeqRef) and a.is_string()
10114 
10116  """return 'True' if 'a' is a Z3 string constant expression.
10117  >>> print (is_string_value(StringVal("a")))
10118  True
10119  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10120  False
10121  """
10122  return isinstance(a, SeqRef) and a.is_string_value()
10123 
10124 
10125 def StringVal(s, ctx=None):
10126  """create a string expression"""
10127  ctx = _get_ctx(ctx)
10128  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10129 
10130 def String(name, ctx=None):
10131  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10132 
10133  >>> x = String('x')
10134  """
10135  ctx = _get_ctx(ctx)
10136  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10137 
10138 def Strings(names, ctx=None):
10139  """Return string constants"""
10140  ctx = _get_ctx(ctx)
10141  if isinstance(names, str):
10142  names = names.split(" ")
10143  return [String(name, ctx) for name in names]
10144 
10145 def SubString(s, offset, length):
10146  """Extract substring or subsequence starting at offset"""
10147  return Extract(s, offset, length)
10148 
10149 def SubSeq(s, offset, length):
10150  """Extract substring or subsequence starting at offset"""
10151  return Extract(s, offset, length)
10152 
10153 def Strings(names, ctx=None):
10154  """Return a tuple of String constants. """
10155  ctx = _get_ctx(ctx)
10156  if isinstance(names, str):
10157  names = names.split(" ")
10158  return [String(name, ctx) for name in names]
10159 
10160 def Empty(s):
10161  """Create the empty sequence of the given sort
10162  >>> e = Empty(StringSort())
10163  >>> e2 = StringVal("")
10164  >>> print(e.eq(e2))
10165  True
10166  >>> e3 = Empty(SeqSort(IntSort()))
10167  >>> print(e3)
10168  Empty(Seq(Int))
10169  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10170  >>> print(e4)
10171  Empty(ReSort(Seq(Int)))
10172  """
10173  if isinstance(s, SeqSortRef):
10174  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10175  if isinstance(s, ReSortRef):
10176  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10177  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10178 
10179 def Full(s):
10180  """Create the regular expression that accepts the universal language
10181  >>> e = Full(ReSort(SeqSort(IntSort())))
10182  >>> print(e)
10183  Full(ReSort(Seq(Int)))
10184  >>> e1 = Full(ReSort(StringSort()))
10185  >>> print(e1)
10186  Full(ReSort(String))
10187  """
10188  if isinstance(s, ReSortRef):
10189  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10190  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10191 
10192 
10193 def Unit(a):
10194  """Create a singleton sequence"""
10195  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10196 
10197 def PrefixOf(a, b):
10198  """Check if 'a' is a prefix of 'b'
10199  >>> s1 = PrefixOf("ab", "abc")
10200  >>> simplify(s1)
10201  True
10202  >>> s2 = PrefixOf("bc", "abc")
10203  >>> simplify(s2)
10204  False
10205  """
10206  ctx = _get_ctx2(a, b)
10207  a = _coerce_seq(a, ctx)
10208  b = _coerce_seq(b, ctx)
10209  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10210 
10211 def SuffixOf(a, b):
10212  """Check if 'a' is a suffix of 'b'
10213  >>> s1 = SuffixOf("ab", "abc")
10214  >>> simplify(s1)
10215  False
10216  >>> s2 = SuffixOf("bc", "abc")
10217  >>> simplify(s2)
10218  True
10219  """
10220  ctx = _get_ctx2(a, b)
10221  a = _coerce_seq(a, ctx)
10222  b = _coerce_seq(b, ctx)
10223  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10224 
10225 def Contains(a, b):
10226  """Check if 'a' contains 'b'
10227  >>> s1 = Contains("abc", "ab")
10228  >>> simplify(s1)
10229  True
10230  >>> s2 = Contains("abc", "bc")
10231  >>> simplify(s2)
10232  True
10233  >>> x, y, z = Strings('x y z')
10234  >>> s3 = Contains(Concat(x,y,z), y)
10235  >>> simplify(s3)
10236  True
10237  """
10238  ctx = _get_ctx2(a, b)
10239  a = _coerce_seq(a, ctx)
10240  b = _coerce_seq(b, ctx)
10241  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10242 
10243 
10244 def Replace(s, src, dst):
10245  """Replace the first occurrence of 'src' by 'dst' in 's'
10246  >>> r = Replace("aaa", "a", "b")
10247  >>> simplify(r)
10248  "baa"
10249  """
10250  ctx = _get_ctx2(dst, s)
10251  if ctx is None and is_expr(src):
10252  ctx = src.ctx
10253  src = _coerce_seq(src, ctx)
10254  dst = _coerce_seq(dst, ctx)
10255  s = _coerce_seq(s, ctx)
10256  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10257 
10258 def IndexOf(s, substr):
10259  return IndexOf(s, substr, IntVal(0))
10260 
10261 def IndexOf(s, substr, offset):
10262  """Retrieve the index of substring within a string starting at a specified offset.
10263  >>> simplify(IndexOf("abcabc", "bc", 0))
10264  1
10265  >>> simplify(IndexOf("abcabc", "bc", 2))
10266  4
10267  """
10268  ctx = None
10269  if is_expr(offset):
10270  ctx = offset.ctx
10271  ctx = _get_ctx2(s, substr, ctx)
10272  s = _coerce_seq(s, ctx)
10273  substr = _coerce_seq(substr, ctx)
10274  if _is_int(offset):
10275  offset = IntVal(offset, ctx)
10276  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10277 
10278 def LastIndexOf(s, substr):
10279  """Retrieve the last index of substring within a string"""
10280  ctx = None
10281  ctx = _get_ctx2(s, substr, ctx)
10282  s = _coerce_seq(s, ctx)
10283  substr = _coerce_seq(substr, ctx)
10284  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10285 
10286 
10287 def Length(s):
10288  """Obtain the length of a sequence 's'
10289  >>> l = Length(StringVal("abc"))
10290  >>> simplify(l)
10291  3
10292  """
10293  s = _coerce_seq(s)
10294  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10295 
10296 def StrToInt(s):
10297  """Convert string expression to integer
10298  >>> a = StrToInt("1")
10299  >>> simplify(1 == a)
10300  True
10301  >>> b = StrToInt("2")
10302  >>> simplify(1 == b)
10303  False
10304  >>> c = StrToInt(IntToStr(2))
10305  >>> simplify(1 == c)
10306  False
10307  """
10308  s = _coerce_seq(s)
10309  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10310 
10311 
10312 def IntToStr(s):
10313  """Convert integer expression to string"""
10314  if not is_expr(s):
10315  s = _py2expr(s)
10316  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10317 
10318 
10319 def Re(s, ctx=None):
10320  """The regular expression that accepts sequence 's'
10321  >>> s1 = Re("ab")
10322  >>> s2 = Re(StringVal("ab"))
10323  >>> s3 = Re(Unit(BoolVal(True)))
10324  """
10325  s = _coerce_seq(s, ctx)
10326  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10327 
10328 
10329 
10330 
10331 
10332 
10334  """Regular expression sort."""
10335 
10336  def basis(self):
10337  return _to_sort_ref(Z3_get_re_sort_basis(self.ctx_refctx_ref(), self.astast), self.ctxctx)
10338 
10339 def ReSort(s):
10340  if is_ast(s):
10341  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10342  if s is None or isinstance(s, Context):
10343  ctx = _get_ctx(s)
10344  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10345  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10346 
10347 
10349  """Regular expressions."""
10350 
10351  def __add__(self, other):
10352  return Union(self, other)
10353 
10354 def is_re(s):
10355  return isinstance(s, ReRef)
10356 
10357 
10358 def InRe(s, re):
10359  """Create regular expression membership test
10360  >>> re = Union(Re("a"),Re("b"))
10361  >>> print (simplify(InRe("a", re)))
10362  True
10363  >>> print (simplify(InRe("b", re)))
10364  True
10365  >>> print (simplify(InRe("c", re)))
10366  False
10367  """
10368  s = _coerce_seq(s, re.ctx)
10369  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10370 
10371 def Union(*args):
10372  """Create union of regular expressions.
10373  >>> re = Union(Re("a"), Re("b"), Re("c"))
10374  >>> print (simplify(InRe("d", re)))
10375  False
10376  """
10377  args = _get_args(args)
10378  sz = len(args)
10379  if z3_debug():
10380  _z3_assert(sz > 0, "At least one argument expected.")
10381  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10382  if sz == 1:
10383  return args[0]
10384  ctx = args[0].ctx
10385  v = (Ast * sz)()
10386  for i in range(sz):
10387  v[i] = args[i].as_ast()
10388  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10389 
10390 def Intersect(*args):
10391  """Create intersection of regular expressions.
10392  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10393  """
10394  args = _get_args(args)
10395  sz = len(args)
10396  if z3_debug():
10397  _z3_assert(sz > 0, "At least one argument expected.")
10398  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10399  if sz == 1:
10400  return args[0]
10401  ctx = args[0].ctx
10402  v = (Ast * sz)()
10403  for i in range(sz):
10404  v[i] = args[i].as_ast()
10405  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10406 
10407 def Plus(re):
10408  """Create the regular expression accepting one or more repetitions of argument.
10409  >>> re = Plus(Re("a"))
10410  >>> print(simplify(InRe("aa", re)))
10411  True
10412  >>> print(simplify(InRe("ab", re)))
10413  False
10414  >>> print(simplify(InRe("", re)))
10415  False
10416  """
10417  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
10418 
10419 def Option(re):
10420  """Create the regular expression that optionally accepts the argument.
10421  >>> re = Option(Re("a"))
10422  >>> print(simplify(InRe("a", re)))
10423  True
10424  >>> print(simplify(InRe("", re)))
10425  True
10426  >>> print(simplify(InRe("aa", re)))
10427  False
10428  """
10429  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10430 
10431 def Complement(re):
10432  """Create the complement regular expression."""
10433  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10434 
10435 def Star(re):
10436  """Create the regular expression accepting zero or more repetitions of argument.
10437  >>> re = Star(Re("a"))
10438  >>> print(simplify(InRe("aa", re)))
10439  True
10440  >>> print(simplify(InRe("ab", re)))
10441  False
10442  >>> print(simplify(InRe("", re)))
10443  True
10444  """
10445  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10446 
10447 def Loop(re, lo, hi=0):
10448  """Create the regular expression accepting between a lower and upper bound repetitions
10449  >>> re = Loop(Re("a"), 1, 3)
10450  >>> print(simplify(InRe("aa", re)))
10451  True
10452  >>> print(simplify(InRe("aaaa", re)))
10453  False
10454  >>> print(simplify(InRe("", re)))
10455  False
10456  """
10457  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10458 
10459 def Range(lo, hi, ctx = None):
10460  """Create the range regular expression over two sequences of length 1
10461  >>> range = Range("a","z")
10462  >>> print(simplify(InRe("b", range)))
10463  True
10464  >>> print(simplify(InRe("bb", range)))
10465  False
10466  """
10467  lo = _coerce_seq(lo, ctx)
10468  hi = _coerce_seq(hi, ctx)
10469  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10470 
10471 # Special Relations
10472 
10473 def PartialOrder(a, index):
10474  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10475 
10476 def LinearOrder(a, index):
10477  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10478 
10479 def TreeOrder(a, index):
10480  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10481 
10482 def PiecewiseLinearOrder(a, index):
10483  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10484 
10486  """Given a binary relation R, such that the two arguments have the same sort
10487  create the transitive closure relation R+.
10488  The transitive closure R+ is a new relation.
10489  """
10490  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
10491 
10492 
10494  def __init__(self):
10495  self.basesbases = {}
10496  self.locklock = None
10497 
10499  if self.locklock is None:
10500  import threading
10501  self.locklock = threading.thread.Lock()
10502 
10503  def get(self, ctx):
10504  if self.locklock: self.locklock.acquire()
10505  r = self.basesbases[ctx]
10506  if self.locklock: self.locklock.release()
10507  return r
10508 
10509  def set(self, ctx, r):
10510  if self.locklock: self.locklock.acquire()
10511  self.basesbases[ctx] = r
10512  if self.locklock: self.locklock.release()
10513 
10514  def insert(self, r):
10515  if self.locklock: self.locklock.acquire()
10516  id = len(self.basesbases) + 3
10517  self.basesbases[id] = r
10518  if self.locklock: self.locklock.release()
10519  return id
10520 
10521 _prop_closures = None
10522 
10524  global _prop_closures
10525  if _prop_closures is None:
10526  _prop_closures = PropClosures()
10527 
10529  _prop_closures.get(ctx).push();
10530 
10531 def user_prop_pop(ctx, num_scopes):
10532  _prop_closures.get(ctx).pop(num_scopes)
10533 
10534 def user_prop_fresh(id, ctx):
10535  prop = _prop_closures.get(id)
10536  _prop_closures.set_threaded()
10537  new_prop = UsePropagateBase(None, ctx)
10538  _prop_closures.set(new_prop.id, new_prop.fresh())
10539  return ctypes.c_void_p(new_prop.id)
10540 
10541 def user_prop_fixed(ctx, cb, id, value):
10542  prop = _prop_closures.get(ctx)
10543  prop.cb = cb
10544  prop.fixed(id, _to_expr_ref(ctypes.c_void_p(value), prop.ctx()))
10545  prop.cb = None
10546 
10547 def user_prop_final(ctx, cb):
10548  prop = _prop_closures.get(ctx)
10549  prop.cb = cb
10550  prop.final()
10551  prop.cb = None
10552 
10553 def user_prop_eq(ctx, cb, x, y):
10554  prop = _prop_closures.get(ctx)
10555  prop.cb = cb
10556  prop.eq(x, y)
10557  prop.cb = None
10558 
10559 def user_prop_diseq(ctx, cb, x, y):
10560  prop = _prop_closures.get(ctx)
10561  prop.cb = cb
10562  prop.diseq(x, y)
10563  prop.cb = None
10564 
10565 _user_prop_push = push_eh_type(user_prop_push)
10566 _user_prop_pop = pop_eh_type(user_prop_pop)
10567 _user_prop_fresh = fresh_eh_type(user_prop_fresh)
10568 _user_prop_fixed = fixed_eh_type(user_prop_fixed)
10569 _user_prop_final = final_eh_type(user_prop_final)
10570 _user_prop_eq = eq_eh_type(user_prop_eq)
10571 _user_prop_diseq = eq_eh_type(user_prop_diseq)
10572 
10574 
10575  #
10576  # Either solver is set or ctx is set.
10577  # Propagators that are created throuh callbacks
10578  # to "fresh" inherit the context of that is supplied
10579  # as argument to the callback.
10580  # This context should not be deleted. It is owned by the solver.
10581  #
10582  def __init__(self, s, ctx = None):
10583  assert s is None or ctx is None
10585  self.solversolver = s
10586  self._ctx_ctx = None
10587  self.cbcb = None
10588  self.idid = _prop_closures.insert(self)
10589  self.fixedfixed = None
10590  self.finalfinal = None
10591  self.eqeq = None
10592  self.diseqdiseq = None
10593  if ctx:
10594  self._ctx_ctx = Context()
10595  Z3_del_context(self._ctx_ctx.ctx)
10596  self._ctx_ctx.ctx = ctx
10597  self._ctx_ctx.eh = Z3_set_error_handler(ctx, z3_error_handler)
10598  Z3_set_ast_print_mode(ctx, Z3_PRINT_SMTLIB2_COMPLIANT)
10599  if s:
10600  Z3_solver_propagate_init(self.ctx_refctx_ref(),
10601  s.solver,
10602  ctypes.c_void_p(self.idid),
10603  _user_prop_push,
10604  _user_prop_pop,
10605  _user_prop_fresh)
10606 
10607  def __del__(self):
10608  if self._ctx_ctx:
10609  self._ctx_ctx.ctx = None
10610 
10611  def ctx(self):
10612  if self._ctx_ctx:
10613  return self._ctx_ctx
10614  else:
10615  return self.solversolver.ctx
10616 
10617  def ctx_ref(self):
10618  return self.ctxctx().ref()
10619 
10620  def add_fixed(self, fixed):
10621  assert not self.fixedfixed
10622  assert not self._ctx_ctx
10623  Z3_solver_propagate_fixed(self.ctx_refctx_ref(), self.solversolver.solver, _user_prop_fixed)
10624  self.fixedfixed = fixed
10625 
10626  def add_final(self, final):
10627  assert not self.finalfinal
10628  assert not self._ctx_ctx
10629  Z3_solver_propagate_final(self.ctx_refctx_ref(), self.solversolver.solver, _user_prop_final)
10630  self.finalfinal = final
10631 
10632  def add_eq(self, eq):
10633  assert not self.eqeq
10634  assert not self._ctx_ctx
10635  Z3_solver_propagate_eq(self.ctx_refctx_ref(), self.solversolver.solver, _user_prop_eq)
10636  self.eqeq = eq
10637 
10638  def add_diseq(self, diseq):
10639  assert not self.diseqdiseq
10640  assert not self._ctx_ctx
10641  Z3_solver_propagate_diseq(self.ctx_refctx_ref(), self.solversolver.solver, _user_prop_diseq)
10642  self.diseqdiseq = diseq
10643 
10644  def push(self):
10645  raise Z3Exception("push needs to be overwritten")
10646 
10647  def pop(self, num_scopes):
10648  raise Z3Exception("pop needs to be overwritten")
10649 
10650  def fresh(self):
10651  raise Z3Exception("fresh needs to be overwritten")
10652 
10653  def add(self, e):
10654  assert self.solversolver
10655  assert not self._ctx_ctx
10656  return Z3_solver_propagate_register(self.ctx_refctx_ref(), self.solversolver.solver, e.ast)
10657 
10658  #
10659  # Propagation can only be invoked as during a fixed or final callback.
10660  #
10661  def propagate(self, e, ids, eqs = []):
10662  num_fixed = len(ids)
10663  _ids = (ctypes.c_uint * num_fixed)()
10664  for i in range(num_fixed):
10665  _ids[i] = ids[i]
10666  num_eqs = len(eqs)
10667  _lhs = (ctypes.c_uint * num_eqs)()
10668  _rhs = (ctypes.c_uint * num_eqs)()
10669  for i in range(num_eqs):
10670  _lhs[i] = eqs[i][0]
10671  _rhs[i] = eqs[i][1]
10672  Z3_solver_propagate_consequence(e.ctx.ref(), ctypes.c_void_p(self.cbcb), num_fixed, _ids, num_eqs, _lhs, _rhs, e.ast)
10673 
10674  def conflict(self, ids):
10675  self.propagatepropagate(BoolVal(False, self.ctxctx()), ids, eqs=[])
def poly(self)
Definition: z3py.py:2924
def as_decimal(self, prec)
Definition: z3py.py:2913
def index(self)
Definition: z3py.py:2927
def approx(self, precision=10)
Definition: z3py.py:2902
def __del__(self)
Definition: z3py.py:7604
def __getitem__(self, idx)
Definition: z3py.py:7627
def __init__(self, result, ctx)
Definition: z3py.py:7596
def __len__(self)
Definition: z3py.py:7608
def as_expr(self)
Definition: z3py.py:7652
def __repr__(self)
Definition: z3py.py:7644
def sexpr(self)
Definition: z3py.py:7647
def __deepcopy__(self, memo={})
Definition: z3py.py:7601
def is_real(self)
Definition: z3py.py:2241
def __pos__(self)
Definition: z3py.py:2437
def sort(self)
Definition: z3py.py:2217
def __radd__(self, other)
Definition: z3py.py:2265
def __pow__(self, other)
Definition: z3py.py:2323
def __add__(self, other)
Definition: z3py.py:2252
def __lt__(self, other)
Definition: z3py.py:2459
def __neg__(self)
Definition: z3py.py:2426
def __rmul__(self, other)
Definition: z3py.py:2290
def __le__(self, other)
Definition: z3py.py:2446
def __mul__(self, other)
Definition: z3py.py:2275
def __mod__(self, other)
Definition: z3py.py:2399
def __rsub__(self, other)
Definition: z3py.py:2313
def __rtruediv__(self, other)
Definition: z3py.py:2395
def __rdiv__(self, other)
Definition: z3py.py:2378
def __ge__(self, other)
Definition: z3py.py:2485
def is_int(self)
Definition: z3py.py:2227
def __truediv__(self, other)
Definition: z3py.py:2374
def __gt__(self, other)
Definition: z3py.py:2472
def __sub__(self, other)
Definition: z3py.py:2300
def __rpow__(self, other)
Definition: z3py.py:2337
def __rmod__(self, other)
Definition: z3py.py:2414
def __div__(self, other)
Definition: z3py.py:2351
Arithmetic.
Definition: z3py.py:2128
def is_real(self)
Definition: z3py.py:2131
def subsort(self, other)
Definition: z3py.py:2159
def cast(self, val)
Definition: z3py.py:2163
def is_int(self)
Definition: z3py.py:2145
def sort(self)
Definition: z3py.py:4288
def default(self)
Definition: z3py.py:4328
def __getitem__(self, arg)
Definition: z3py.py:4315
def domain(self)
Definition: z3py.py:4297
def range(self)
Definition: z3py.py:4306
def domain(self)
Definition: z3py.py:4267
def range(self)
Definition: z3py.py:4276
def erase(self, k)
Definition: z3py.py:5726
def __del__(self)
Definition: z3py.py:5666
def reset(self)
Definition: z3py.py:5740
def __init__(self, m=None, ctx=None)
Definition: z3py.py:5652
def __len__(self)
Definition: z3py.py:5670
def keys(self)
Definition: z3py.py:5755
def __repr__(self)
Definition: z3py.py:5723
def __getitem__(self, key)
Definition: z3py.py:5696
def __deepcopy__(self, memo={})
Definition: z3py.py:5663
def __setitem__(self, k, v)
Definition: z3py.py:5707
def __contains__(self, key)
Definition: z3py.py:5683
def ctx_ref(self)
Definition: z3py.py:362
def __str__(self)
Definition: z3py.py:320
def __hash__(self)
Definition: z3py.py:329
def __nonzero__(self)
Definition: z3py.py:332
def __bool__(self)
Definition: z3py.py:335
def __del__(self)
Definition: z3py.py:312
def hash(self)
Definition: z3py.py:402
def get_id(self)
Definition: z3py.py:358
def as_ast(self)
Definition: z3py.py:354
def __repr__(self)
Definition: z3py.py:323
def __init__(self, ast, ctx=None)
Definition: z3py.py:307
def sexpr(self)
Definition: z3py.py:345
def translate(self, target)
Definition: z3py.py:383
def __deepcopy__(self, memo={})
Definition: z3py.py:317
def __copy__(self)
Definition: z3py.py:399
def __eq__(self, other)
Definition: z3py.py:326
def eq(self, other)
Definition: z3py.py:366
def __contains__(self, item)
Definition: z3py.py:5595
def resize(self, sz)
Definition: z3py.py:5582
def __del__(self)
Definition: z3py.py:5513
def __init__(self, v=None, ctx=None)
Definition: z3py.py:5499
def __setitem__(self, i, v)
Definition: z3py.py:5554
def push(self, v)
Definition: z3py.py:5570
def __len__(self)
Definition: z3py.py:5517
def translate(self, other_ctx)
Definition: z3py.py:5618
def __repr__(self)
Definition: z3py.py:5637
def sexpr(self)
Definition: z3py.py:5640
def __deepcopy__(self, memo={})
Definition: z3py.py:5510
def __copy__(self)
Definition: z3py.py:5631
def __getitem__(self, i)
Definition: z3py.py:5530
def as_signed_long(self)
Definition: z3py.py:3695
def as_long(self)
Definition: z3py.py:3684
def as_binary_string(self)
Definition: z3py.py:3720
def as_string(self)
Definition: z3py.py:3717
def __rlshift__(self, other)
Definition: z3py.py:3667
def __pos__(self)
Definition: z3py.py:3432
def sort(self)
Definition: z3py.py:3272
def __radd__(self, other)
Definition: z3py.py:3307
def __rxor__(self, other)
Definition: z3py.py:3422
def __xor__(self, other)
Definition: z3py.py:3409
def __ror__(self, other)
Definition: z3py.py:3376
def __add__(self, other)
Definition: z3py.py:3294
def __rshift__(self, other)
Definition: z3py.py:3609
def __lt__(self, other)
Definition: z3py.py:3561
def __or__(self, other)
Definition: z3py.py:3363
def size(self)
Definition: z3py.py:3283
def __neg__(self)
Definition: z3py.py:3441
def __rand__(self, other)
Definition: z3py.py:3399
def __rmul__(self, other)
Definition: z3py.py:3330
def __le__(self, other)
Definition: z3py.py:3545
def __mul__(self, other)
Definition: z3py.py:3317
def __mod__(self, other)
Definition: z3py.py:3506
def __rsub__(self, other)
Definition: z3py.py:3353
def __invert__(self)
Definition: z3py.py:3452
def __rtruediv__(self, other)
Definition: z3py.py:3502
def __rdiv__(self, other)
Definition: z3py.py:3486
def __lshift__(self, other)
Definition: z3py.py:3639
def __ge__(self, other)
Definition: z3py.py:3593
def __and__(self, other)
Definition: z3py.py:3386
def __rrshift__(self, other)
Definition: z3py.py:3653
def __truediv__(self, other)
Definition: z3py.py:3482
def __gt__(self, other)
Definition: z3py.py:3577
def __sub__(self, other)
Definition: z3py.py:3340
def __rmod__(self, other)
Definition: z3py.py:3527
def __div__(self, other)
Definition: z3py.py:3463
Bit-Vectors.
Definition: z3py.py:3227
def subsort(self, other)
Definition: z3py.py:3239
def size(self)
Definition: z3py.py:3230
def cast(self, val)
Definition: z3py.py:3242
def sort(self)
Definition: z3py.py:1426
def __rmul__(self, other)
Definition: z3py.py:1429
def __mul__(self, other)
Definition: z3py.py:1432
Booleans.
Definition: z3py.py:1390
def subsort(self, other)
Definition: z3py.py:1414
def cast(self, val)
Definition: z3py.py:1392
def is_int(self)
Definition: z3py.py:1417
def is_bool(self)
Definition: z3py.py:1420
def __repr__(self)
Definition: z3py.py:6450
def __ne__(self, other)
Definition: z3py.py:6447
def __init__(self, r)
Definition: z3py.py:6438
def __deepcopy__(self, memo={})
Definition: z3py.py:6441
def __eq__(self, other)
Definition: z3py.py:6444
def interrupt(self)
Definition: z3py.py:200
def __init__(self, *args, **kws)
Definition: z3py.py:172
def __del__(self)
Definition: z3py.py:191
def ref(self)
Definition: z3py.py:196
def create(self)
Definition: z3py.py:4789
def __init__(self, name, ctx=None)
Definition: z3py.py:4749
def declare(self, name, *args)
Definition: z3py.py:4766
def declare_core(self, name, rec_name, *args)
Definition: z3py.py:4759
def __repr__(self)
Definition: z3py.py:4786
def __deepcopy__(self, memo={})
Definition: z3py.py:4754
def sort(self)
Definition: z3py.py:5008
def recognizer(self, idx)
Definition: z3py.py:4949
def num_constructors(self)
Definition: z3py.py:4917
def constructor(self, idx)
Definition: z3py.py:4930
def accessor(self, i, j)
Definition: z3py.py:4977
Expressions.
Definition: z3py.py:893
def params(self)
Definition: z3py.py:971
def sort(self)
Definition: z3py.py:909
def __hash__(self)
Definition: z3py.py:949
def get_id(self)
Definition: z3py.py:906
def children(self)
Definition: z3py.py:1026
def as_ast(self)
Definition: z3py.py:903
def decl(self)
Definition: z3py.py:974
def __ne__(self, other)
Definition: z3py.py:953
def num_args(self)
Definition: z3py.py:989
def arg(self, idx)
Definition: z3py.py:1005
def sort_kind(self)
Definition: z3py.py:921
def __eq__(self, other)
Definition: z3py.py:932
FP Numerals.
Definition: z3py.py:9080
def isNormal(self)
Definition: z3py.py:9172
def exponent(self, biased=True)
Definition: z3py.py:9137
def significand(self)
Definition: z3py.py:9109
def sign_as_bv(self)
Definition: z3py.py:9100
def isNegative(self)
Definition: z3py.py:9184
def significand_as_bv(self)
Definition: z3py.py:9128
def exponent_as_long(self, biased=True)
Definition: z3py.py:9146
def isInf(self)
Definition: z3py.py:9164
def isNaN(self)
Definition: z3py.py:9160
def sign(self)
Definition: z3py.py:9090
def isZero(self)
Definition: z3py.py:9168
def significand_as_long(self)
Definition: z3py.py:9118
def isSubnormal(self)
Definition: z3py.py:9176
def isPositive(self)
Definition: z3py.py:9180
def exponent_as_bv(self, biased=True)
Definition: z3py.py:9156
def as_string(self)
Definition: z3py.py:9194
def as_string(self)
Definition: z3py.py:9017
FP Expressions.
Definition: z3py.py:8837
def __pos__(self)
Definition: z3py.py:8957
def sort(self)
Definition: z3py.py:8840
def __radd__(self, other)
Definition: z3py.py:8896
def __add__(self, other)
Definition: z3py.py:8883
def sbits(self)
Definition: z3py.py:8859
def __lt__(self, other)
Definition: z3py.py:8874
def __neg__(self)
Definition: z3py.py:8961
def ebits(self)
Definition: z3py.py:8851
def __rmul__(self, other)
Definition: z3py.py:8944
def __le__(self, other)
Definition: z3py.py:8871
def __mul__(self, other)
Definition: z3py.py:8929
def __mod__(self, other)
Definition: z3py.py:9006
def __rsub__(self, other)
Definition: z3py.py:8919
def __rtruediv__(self, other)
Definition: z3py.py:9002
def __rdiv__(self, other)
Definition: z3py.py:8985
def __ge__(self, other)
Definition: z3py.py:8877
def __truediv__(self, other)
Definition: z3py.py:8998
def __gt__(self, other)
Definition: z3py.py:8880
def __sub__(self, other)
Definition: z3py.py:8906
def as_string(self)
Definition: z3py.py:8867
def __rmod__(self, other)
Definition: z3py.py:9010
def __div__(self, other)
Definition: z3py.py:8970
FP Sorts.
Definition: z3py.py:8736
def sbits(self)
Definition: z3py.py:8747
def ebits(self)
Definition: z3py.py:8739
def cast(self, val)
Definition: z3py.py:8755
def as_long(self)
Definition: z3py.py:7308
def as_string(self)
Definition: z3py.py:7320
def sort(self)
Definition: z3py.py:7284
def as_string(self)
Definition: z3py.py:7288
Fixedpoint.
Definition: z3py.py:6991
def insert(self, *args)
Definition: z3py.py:7052
def abstract(self, fml, is_forall=True)
Definition: z3py.py:7237
def fact(self, head, name=None)
Definition: z3py.py:7083
def reason_unknown(self)
Definition: z3py.py:7223
def rule(self, head, body=None, name=None)
Definition: z3py.py:7079
def to_string(self, queries)
Definition: z3py.py:7210
def add_cover(self, level, predicate, property)
Definition: z3py.py:7165
def add(self, *args)
Definition: z3py.py:7040
def __del__(self)
Definition: z3py.py:7008
def add_rule(self, head, body=None, name=None)
Definition: z3py.py:7056
def param_descrs(self)
Definition: z3py.py:7022
def assert_exprs(self, *args)
Definition: z3py.py:7026
def get_answer(self)
Definition: z3py.py:7134
def statistics(self)
Definition: z3py.py:7218
def update_rule(self, head, body, name)
Definition: z3py.py:7125
def query_from_lvl(self, lvl, *query)
Definition: z3py.py:7109
def append(self, *args)
Definition: z3py.py:7048
def query(self, *query)
Definition: z3py.py:7087
def parse_string(self, s)
Definition: z3py.py:7185
def help(self)
Definition: z3py.py:7018
def get_rules_along_trace(self)
Definition: z3py.py:7144
def get_ground_sat_answer(self)
Definition: z3py.py:7139
def __repr__(self)
Definition: z3py.py:7201
def get_rules(self)
Definition: z3py.py:7193
def set_predicate_representation(self, f, *representations)
Definition: z3py.py:7175
def sexpr(self)
Definition: z3py.py:7205
def get_assertions(self)
Definition: z3py.py:7197
def get_cover_delta(self, level, predicate)
Definition: z3py.py:7160
def __deepcopy__(self, memo={})
Definition: z3py.py:7005
def get_num_levels(self, predicate)
Definition: z3py.py:7156
def declare_var(self, *vars)
Definition: z3py.py:7228
def parse_file(self, f)
Definition: z3py.py:7189
def set(self, *args, **keys)
Definition: z3py.py:7012
def __init__(self, fixedpoint=None, ctx=None)
Definition: z3py.py:6994
def register_relation(self, *relations)
Definition: z3py.py:7169
def get_rule_names_along_trace(self)
Definition: z3py.py:7148
def __iadd__(self, fml)
Definition: z3py.py:7044
Function Declarations.
Definition: z3py.py:661
def params(self)
Definition: z3py.py:731
def get_id(self)
Definition: z3py.py:671
def name(self)
Definition: z3py.py:677
def __call__(self, *args)
Definition: z3py.py:755
def arity(self)
Definition: z3py.py:688
def kind(self)
Definition: z3py.py:719
def as_ast(self)
Definition: z3py.py:668
def as_func_decl(self)
Definition: z3py.py:674
def domain(self, i)
Definition: z3py.py:697
def range(self)
Definition: z3py.py:710
Definition: z3py.py:5773
def __del__(self)
Definition: z3py.py:5784
ctx
Definition: z3py.py:5778
def value(self)
Definition: z3py.py:5837
def __init__(self, entry, ctx)
Definition: z3py.py:5776
def arg_value(self, idx)
Definition: z3py.py:5806
entry
Definition: z3py.py:5777
def __repr__(self)
Definition: z3py.py:5878
def num_args(self)
Definition: z3py.py:5788
def __deepcopy__(self, memo={})
Definition: z3py.py:5781
def as_list(self)
Definition: z3py.py:5859
def __del__(self)
Definition: z3py.py:5893
def arity(self)
Definition: z3py.py:5936
def __init__(self, f, ctx)
Definition: z3py.py:5884
def translate(self, other_ctx)
Definition: z3py.py:5970
def __repr__(self)
Definition: z3py.py:5998
def num_entries(self)
Definition: z3py.py:5920
def __deepcopy__(self, memo={})
Definition: z3py.py:5890
def else_value(self)
Definition: z3py.py:5897
def __copy__(self)
Definition: z3py.py:5975
def as_list(self)
Definition: z3py.py:5981
def entry(self, idx)
Definition: z3py.py:5950
def insert(self, *args)
Definition: z3py.py:5358
def dimacs(self, include_names=True)
Definition: z3py.py:5416
def get(self, i)
Definition: z3py.py:5304
def depth(self)
Definition: z3py.py:5213
def convert_model(self, model)
Definition: z3py.py:5380
def add(self, *args)
Definition: z3py.py:5369
def __del__(self)
Definition: z3py.py:5209
def assert_exprs(self, *args)
Definition: z3py.py:5332
def __getitem__(self, arg)
Definition: z3py.py:5317
def __init__(self, models=True, unsat_cores=False, proofs=False, ctx=None, goal=None)
Definition: z3py.py:5197
def size(self)
Definition: z3py.py:5278
def append(self, *args)
Definition: z3py.py:5347
def __len__(self)
Definition: z3py.py:5291
def as_expr(self)
Definition: z3py.py:5469
def __repr__(self)
Definition: z3py.py:5409
def sexpr(self)
Definition: z3py.py:5412
def precision(self)
Definition: z3py.py:5269
def translate(self, target)
Definition: z3py.py:5420
def __deepcopy__(self, memo={})
Definition: z3py.py:5206
def simplify(self, *arguments, **keywords)
Definition: z3py.py:5449
def __copy__(self)
Definition: z3py.py:5443
def inconsistent(self)
Definition: z3py.py:5230
def prec(self)
Definition: z3py.py:5248
def as_long(self)
Definition: z3py.py:2774
def as_binary_string(self)
Definition: z3py.py:2795
def as_string(self)
Definition: z3py.py:2787
def decls(self)
Definition: z3py.py:6244
def get_universe(self, s)
Definition: z3py.py:6180
def __del__(self)
Definition: z3py.py:6010
def eval(self, t, model_completion=False)
Definition: z3py.py:6021
def __init__(self, m, ctx)
Definition: z3py.py:6004
def sorts(self)
Definition: z3py.py:6163
def __getitem__(self, idx)
Definition: z3py.py:6200
def __len__(self)
Definition: z3py.py:6076
def num_sorts(self)
Definition: z3py.py:6125
def __repr__(self)
Definition: z3py.py:6014
def sexpr(self)
Definition: z3py.py:6017
def translate(self, target)
Definition: z3py.py:6263
def evaluate(self, t, model_completion=False)
Definition: z3py.py:6050
def __deepcopy__(self, memo={})
Definition: z3py.py:6274
def __copy__(self)
Definition: z3py.py:6271
def get_interp(self, decl)
Definition: z3py.py:6091
def get_sort(self, idx)
Definition: z3py.py:6140
def add_soft(self, arg, weight="1", id=None)
Definition: z3py.py:7477
def reason_unknown(self)
Definition: z3py.py:7521
def objectives(self)
Definition: z3py.py:7567
def pop(self)
Definition: z3py.py:7508
def maximize(self, arg)
Definition: z3py.py:7496
def unsat_core(self)
Definition: z3py.py:7532
def from_string(self, s)
Definition: z3py.py:7559
def add(self, *args)
Definition: z3py.py:7440
def __del__(self)
Definition: z3py.py:7410
def param_descrs(self)
Definition: z3py.py:7424
def assert_exprs(self, *args)
Definition: z3py.py:7428
def model(self)
Definition: z3py.py:7525
def statistics(self)
Definition: z3py.py:7580
def help(self)
Definition: z3py.py:7420
def upper_values(self, obj)
Definition: z3py.py:7550
def __repr__(self)
Definition: z3py.py:7571
def from_file(self, filename)
Definition: z3py.py:7555
def sexpr(self)
Definition: z3py.py:7575
def check(self, *assumptions)
Definition: z3py.py:7512
def push(self)
Definition: z3py.py:7504
def __deepcopy__(self, memo={})
Definition: z3py.py:7407
def minimize(self, arg)
Definition: z3py.py:7500
def lower(self, obj)
Definition: z3py.py:7535
def assert_and_track(self, a, p)
Definition: z3py.py:7448
def set(self, *args, **keys)
Definition: z3py.py:7414
def upper(self, obj)
Definition: z3py.py:7540
def lower_values(self, obj)
Definition: z3py.py:7545
def __init__(self, ctx=None)
Definition: z3py.py:7402
def assertions(self)
Definition: z3py.py:7563
def __iadd__(self, fml)
Definition: z3py.py:7444
def __str__(self)
Definition: z3py.py:7395
def upper(self)
Definition: z3py.py:7377
def value(self)
Definition: z3py.py:7389
def lower_values(self)
Definition: z3py.py:7381
def __init__(self, opt, value, is_max)
Definition: z3py.py:7368
def lower(self)
Definition: z3py.py:7373
def upper_values(self)
Definition: z3py.py:7385
def get_name(self, i)
Definition: z3py.py:5159
def get_kind(self, n)
Definition: z3py.py:5164
def __del__(self)
Definition: z3py.py:5145
def __getitem__(self, arg)
Definition: z3py.py:5174
def size(self)
Definition: z3py.py:5149
def __init__(self, descr, ctx=None)
Definition: z3py.py:5136
def __len__(self)
Definition: z3py.py:5154
def __repr__(self)
Definition: z3py.py:5180
def get_documentation(self, n)
Definition: z3py.py:5169
def __deepcopy__(self, memo={})
Definition: z3py.py:5142
Parameter Sets.
Definition: z3py.py:5067
def validate(self, ds)
Definition: z3py.py:5107
def __del__(self)
Definition: z3py.py:5083
def __init__(self, ctx=None, params=None)
Definition: z3py.py:5072
def __repr__(self)
Definition: z3py.py:5104
def __deepcopy__(self, memo={})
Definition: z3py.py:5080
def set(self, name, val)
Definition: z3py.py:5087
Patterns.
Definition: z3py.py:1770
def get_id(self)
Definition: z3py.py:1777
def as_ast(self)
Definition: z3py.py:1774
def __del__(self)
Definition: z3py.py:7993
def __call__(self, goal)
Definition: z3py.py:8076
def __lt__(self, other)
Definition: z3py.py:7997
def __le__(self, other)
Definition: z3py.py:8023
def __init__(self, probe, ctx=None)
Definition: z3py.py:7967
def __ne__(self, other)
Definition: z3py.py:8062
def __ge__(self, other)
Definition: z3py.py:8036
def __deepcopy__(self, memo={})
Definition: z3py.py:7990
def __eq__(self, other)
Definition: z3py.py:8049
def __gt__(self, other)
Definition: z3py.py:8010
def set_threaded()
Definition: z3py.py:10498
def set(self, ctx, r)
Definition: z3py.py:10509
def insert(self, r)
Definition: z3py.py:10514
def get(self, ctx)
Definition: z3py.py:10503
def __init__(self)
Definition: z3py.py:10494
Quantifiers.
Definition: z3py.py:1832
def pattern(self, idx)
Definition: z3py.py:1924
def sort(self)
Definition: z3py.py:1841
def var_name(self, idx)
Definition: z3py.py:1975
def no_pattern(self, idx)
Definition: z3py.py:1946
def is_forall(self)
Definition: z3py.py:1847
def num_no_patterns(self)
Definition: z3py.py:1942
def body(self)
Definition: z3py.py:1952
def num_vars(self)
Definition: z3py.py:1963
def get_id(self)
Definition: z3py.py:1838
def __getitem__(self, arg)
Definition: z3py.py:1889
def children(self)
Definition: z3py.py:2007
def weight(self)
Definition: z3py.py:1898
def is_lambda(self)
Definition: z3py.py:1875
def as_ast(self)
Definition: z3py.py:1835
def var_sort(self, idx)
Definition: z3py.py:1991
def num_patterns(self)
Definition: z3py.py:1912
def is_exists(self)
Definition: z3py.py:1861
def is_real(self)
Definition: z3py.py:2859
def as_decimal(self, prec)
Definition: z3py.py:2869
def as_fraction(self)
Definition: z3py.py:2890
def is_int_value(self)
Definition: z3py.py:2862
def numerator_as_long(self)
Definition: z3py.py:2832
def as_long(self)
Definition: z3py.py:2865
def denominator(self)
Definition: z3py.py:2821
def denominator_as_long(self)
Definition: z3py.py:2845
def is_int(self)
Definition: z3py.py:2856
def numerator(self)
Definition: z3py.py:2806
def as_string(self)
Definition: z3py.py:2881
def __add__(self, other)
Definition: z3py.py:10351
Regular expressions.
Definition: z3py.py:10333
def basis(self)
Definition: z3py.py:10336
def __del__(self)
Definition: z3py.py:4810
def __init__(self, c, ctx)
Definition: z3py.py:4807
def __init__(self, c, ctx)
Definition: z3py.py:4816
def sort(self)
Definition: z3py.py:10033
def __radd__(self, other)
Definition: z3py.py:10039
def at(self, i)
Definition: z3py.py:10047
def __add__(self, other)
Definition: z3py.py:10036
def __lt__(self, other)
Definition: z3py.py:10070
def is_string_value(self)
Definition: z3py.py:10055
def __le__(self, other)
Definition: z3py.py:10067
def __ge__(self, other)
Definition: z3py.py:10073
def __gt__(self, other)
Definition: z3py.py:10076
def is_string(self)
Definition: z3py.py:10052
def as_string(self)
Definition: z3py.py:10059
def __getitem__(self, i)
Definition: z3py.py:10042
Strings, Sequences and Regular expressions.
Definition: z3py.py:9994
def basis(self)
Definition: z3py.py:10008
def is_string(self)
Definition: z3py.py:9997
def insert(self, *args)
Definition: z3py.py:6630
def dimacs(self, include_names=True)
Definition: z3py.py:6933
def non_units(self)
Definition: z3py.py:6842
def reason_unknown(self)
Definition: z3py.py:6878
backtrack_level
Definition: z3py.py:6483
def num_scopes(self)
Definition: z3py.py:6553
def unsat_core(self)
Definition: z3py.py:6723
def trail_levels(self)
Definition: z3py.py:6847
def trail(self)
Definition: z3py.py:6855
def from_string(self, s)
Definition: z3py.py:6787
def add(self, *args)
Definition: z3py.py:6604
def __del__(self)
Definition: z3py.py:6493
def import_model_converter(self, other)
Definition: z3py.py:6719
def param_descrs(self)
Definition: z3py.py:6895
def __init__(self, solver=None, ctx=None, logFile=None)
Definition: z3py.py:6480
def reset(self)
Definition: z3py.py:6571
def assert_exprs(self, *args)
Definition: z3py.py:6585
def pop(self, num=1)
Definition: z3py.py:6531
def units(self)
Definition: z3py.py:6837
def cube(self, vars=None)
Definition: z3py.py:6791
def cube_vars(self)
Definition: z3py.py:6812
def model(self)
Definition: z3py.py:6700
def statistics(self)
Definition: z3py.py:6860
def append(self, *args)
Definition: z3py.py:6619
def to_smt2(self)
Definition: z3py.py:6937
def help(self)
Definition: z3py.py:6891
def __repr__(self)
Definition: z3py.py:6899
def from_file(self, filename)
Definition: z3py.py:6783
def proof(self)
Definition: z3py.py:6819
def sexpr(self)
Definition: z3py.py:6922
def check(self, *assumptions)
Definition: z3py.py:6671
def translate(self, target)
Definition: z3py.py:6903
def push(self)
Definition: z3py.py:6509
def __deepcopy__(self, memo={})
Definition: z3py.py:6919
def consequences(self, assumptions, variables)
Definition: z3py.py:6755
def assert_and_track(self, a, p)
Definition: z3py.py:6641
def set(self, *args, **keys)
Definition: z3py.py:6497
def __copy__(self)
Definition: z3py.py:6916
def assertions(self)
Definition: z3py.py:6823
def __iadd__(self, fml)
Definition: z3py.py:6615
def __hash__(self)
Definition: z3py.py:592
def subsort(self, other)
Definition: z3py.py:535
def get_id(self)
Definition: z3py.py:516
def name(self)
Definition: z3py.py:558
def kind(self)
Definition: z3py.py:519
def as_ast(self)
Definition: z3py.py:513
def __ne__(self, other)
Definition: z3py.py:581
def cast(self, val)
Definition: z3py.py:543
def __eq__(self, other)
Definition: z3py.py:568
Statistics.
Definition: z3py.py:6296
def __getattr__(self, name)
Definition: z3py.py:6399
def __del__(self)
Definition: z3py.py:6307
def __getitem__(self, idx)
Definition: z3py.py:6343
def __len__(self)
Definition: z3py.py:6329
def keys(self)
Definition: z3py.py:6367
def __init__(self, stats, ctx)
Definition: z3py.py:6299
def __repr__(self)
Definition: z3py.py:6311
def get_key_value(self, key)
Definition: z3py.py:6379
def __deepcopy__(self, memo={})
Definition: z3py.py:6304
def __call__(self, goal, *arguments, **keywords)
Definition: z3py.py:7743
def __del__(self)
Definition: z3py.py:7705
def param_descrs(self)
Definition: z3py.py:7757
def solver(self, logFile=None)
Definition: z3py.py:7709
def __init__(self, tactic, ctx=None)
Definition: z3py.py:7688
def help(self)
Definition: z3py.py:7753
def __deepcopy__(self, memo={})
Definition: z3py.py:7702
def apply(self, goal, *arguments, **keywords)
Definition: z3py.py:7726
def ctx_ref(self)
Definition: z3py.py:10617
def add_fixed(self, fixed)
Definition: z3py.py:10620
def __del__(self)
Definition: z3py.py:10607
def add_diseq(self, diseq)
Definition: z3py.py:10638
def pop(self, num_scopes)
Definition: z3py.py:10647
def add_eq(self, eq)
Definition: z3py.py:10632
def add(self, e)
Definition: z3py.py:10653
def __init__(self, s, ctx=None)
Definition: z3py.py:10582
def propagate(self, e, ids, eqs=[])
Definition: z3py.py:10661
def conflict(self, ids)
Definition: z3py.py:10674
def add_final(self, final)
Definition: z3py.py:10626
ASTs base class.
Definition: z3py.py:292
def use_pp(self)
Definition: z3py.py:294
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3515
def fpIsNegative(a, ctx=None)
Definition: z3py.py:9659
def fpAbs(a, ctx=None)
Definition: z3py.py:9427
def is_pattern(a)
Definition: z3py.py:1780
def StrToInt(s)
Definition: z3py.py:10296
def FreshInt(prefix='x', ctx=None)
Definition: z3py.py:3081
def fpFP(sgn, exp, sig, ctx=None)
Definition: z3py.py:9739
def RNE(ctx=None)
Definition: z3py.py:9026
def fpToFP(a1, a2=None, a3=None, ctx=None)
Definition: z3py.py:9767
def AtLeast(*args)
Definition: z3py.py:8370
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:10482
def BVRedOr(a)
Definition: z3py.py:4200
def is_lt(a)
Definition: z3py.py:2699
def Empty(s)
Definition: z3py.py:10160
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9840
def fpUnsignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9874
def SRem(a, b)
Definition: z3py.py:4034
def OrElse(*ts, **ks)
Definition: z3py.py:7820
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9509
def RealVarVector(n, ctx=None)
Definition: z3py.py:1373
def z3_debug()
Definition: z3py.py:56
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:9022
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9618
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4243
def parse_smt2_string(s, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8625
def PbGe(args, k)
Definition: z3py.py:8422
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4231
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8668
def is_mod(a)
Definition: z3py.py:2677
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9821
def IntSort(ctx=None)
Definition: z3py.py:2942
def Float16(ctx=None)
Definition: z3py.py:8771
def reset_params()
Definition: z3py.py:263
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8224
def ParThen(t1, t2, ctx=None)
Definition: z3py.py:7858
def substitute_vars(t, *m)
Definition: z3py.py:8282
def is_var(a)
Definition: z3py.py:1200
def SetAdd(s, e)
Definition: z3py.py:4653
def is_gt(a)
Definition: z3py.py:2721
def is_fp_sort(s)
Definition: z3py.py:8815
def fpToReal(x, ctx=None)
Definition: z3py.py:9942
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1614
def IsSubset(a, b)
Definition: z3py.py:4702
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3811
def Repeat(t, max=4294967295, ctx=None)
Definition: z3py.py:7902
def EmptySet(s)
Definition: z3py.py:4613
def is_rational_value(a)
Definition: z3py.py:2583
def BitVecs(names, bv, ctx=None)
Definition: z3py.py:3834
def DeclareSort(name, ctx=None)
Definition: z3py.py:637
def Float64(ctx=None)
Definition: z3py.py:8791
def user_prop_push(ctx)
Definition: z3py.py:10528
def With(t, *args, **keys)
Definition: z3py.py:7876
def args2params(arguments, keywords, ctx=None)
Definition: z3py.py:5111
def PbEq(args, k, ctx=None)
Definition: z3py.py:8432
def ToReal(a)
Definition: z3py.py:3147
def PrefixOf(a, b)
Definition: z3py.py:10197
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9613
def Reals(names, ctx=None)
Definition: z3py.py:3106
def is_and(a)
Definition: z3py.py:1489
def fpGEQ(a, b, ctx=None)
Definition: z3py.py:9706
def Xor(a, b, ctx=None)
Definition: z3py.py:1654
def Unit(a)
Definition: z3py.py:10193
def is_fprm_sort(s)
Definition: z3py.py:8825
def ULE(a, b)
Definition: z3py.py:3926
def Star(re)
Definition: z3py.py:10435
def Lambda(vs, body)
Definition: z3py.py:2102
def IndexOf(s, substr)
Definition: z3py.py:10258
def is_bv(a)
Definition: z3py.py:3724
def SetDifference(a, b)
Definition: z3py.py:4682
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7331
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8682
def is_array(a)
Definition: z3py.py:4335
def z3_error_handler(c, e)
Definition: z3py.py:156
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7921
def simplify_param_descrs()
Definition: z3py.py:8252
def Length(s)
Definition: z3py.py:10287
def ensure_prop_closures()
Definition: z3py.py:10523
def help_simplify()
Definition: z3py.py:8248
def fpIsPositive(a, ctx=None)
Definition: z3py.py:9664
def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2065
def Re(s, ctx=None)
Definition: z3py.py:10319
def Sqrt(a, ctx=None)
Definition: z3py.py:3197
def set_option(*args, **kws)
Definition: z3py.py:268
def is_as_array(n)
Definition: z3py.py:6281
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9717
def UGE(a, b)
Definition: z3py.py:3960
def Extract(high, low, a)
Definition: z3py.py:3899
def fpNaN(s)
Definition: z3py.py:9283
def Q(a, b, ctx=None)
Definition: z3py.py:3033
def is_bv_sort(s)
Definition: z3py.py:3259
def append_log(s)
Definition: z3py.py:105
def is_string_value(a)
Definition: z3py.py:10115
def SetIntersect(*args)
Definition: z3py.py:4641
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4212
def Select(a, i)
Definition: z3py.py:4505
def SeqSort(s)
Definition: z3py.py:10022
def is_const_array(a)
Definition: z3py.py:4348
def get_default_fp_sort(ctx=None)
Definition: z3py.py:8695
def is_array_sort(a)
Definition: z3py.py:4331
def Product(*args)
Definition: z3py.py:8328
def Consts(names, sort)
Definition: z3py.py:1332
def fpIsZero(a, ctx=None)
Definition: z3py.py:9644
def Ext(a, b)
Definition: z3py.py:4563
def Range(lo, hi, ctx=None)
Definition: z3py.py:10459
def get_var_index(a)
Definition: z3py.py:1224
def set_param(*args, **kws)
Definition: z3py.py:240
def Bools(names, ctx=None)
Definition: z3py.py:1599
def fpToFPUnsigned(rm, x, s, ctx=None)
Definition: z3py.py:9891
def fpZero(s, negative)
Definition: z3py.py:9336
def FloatQuadruple(ctx=None)
Definition: z3py.py:8806
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9921
def RTZ(ctx=None)
Definition: z3py.py:9058
def BVRedAnd(a)
Definition: z3py.py:4194
def Const(name, sort)
Definition: z3py.py:1321
def RealSort(ctx=None)
Definition: z3py.py:2958
def ZeroExt(n, a)
Definition: z3py.py:4144
def fpMax(a, b, ctx=None)
Definition: z3py.py:9594
def SetSort(s)
Sets.
Definition: z3py.py:4609
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9342
def get_ctx(ctx)
Definition: z3py.py:237
def fpMinusInfinity(s)
Definition: z3py.py:9315
def is_int_value(a)
Definition: z3py.py:2560
def mk_not(a)
Definition: z3py.py:1687
def is_distinct(a)
Definition: z3py.py:1542
def solve_using(s, *args, **keywords)
Definition: z3py.py:8471
def FloatDouble(ctx=None)
Definition: z3py.py:8796
def LinearOrder(a, index)
Definition: z3py.py:10476
def RTN(ctx=None)
Definition: z3py.py:9050
def probe_description(name, ctx=None)
Definition: z3py.py:8130
def get_param(name)
Definition: z3py.py:273
def is_fprm(a)
Definition: z3py.py:9062
def is_store(a)
Definition: z3py.py:4591
def RotateLeft(a, b)
Definition: z3py.py:4085
def Function(name, *sig)
Definition: z3py.py:799
def user_prop_fixed(ctx, cb, id, value)
Definition: z3py.py:10541
def UDiv(a, b)
Definition: z3py.py:3994
def SimpleSolver(ctx=None, logFile=None)
Definition: z3py.py:6973
def is_K(a)
Definition: z3py.py:4360
def K(dom, v)
Definition: z3py.py:4542
def Replace(s, src, dst)
Definition: z3py.py:10244
def ArraySort(*sig)
Definition: z3py.py:4412
def SolverFor(logic, ctx=None, logFile=None)
Definition: z3py.py:6953
def LShR(a, b)
Definition: z3py.py:4054
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4206
def SignExt(n, a)
Definition: z3py.py:4115
def SubString(s, offset, length)
Definition: z3py.py:10145
def FullSet(s)
Definition: z3py.py:4621
def Not(a, ctx=None)
Definition: z3py.py:1669
def RecAddDefinition(f, args, body)
Definition: z3py.py:860
def fpRem(a, b, ctx=None)
Definition: z3py.py:9567
def is_expr(a)
Definition: z3py.py:1135
def FreshFunction(*sig)
Definition: z3py.py:821
def Var(idx, s)
Definition: z3py.py:1351
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3795
def Intersect(*args)
Definition: z3py.py:10390
def Loop(re, lo, hi=0)
Definition: z3py.py:10447
def If(a, b, c, ctx=None)
Definition: z3py.py:1268
def WithParams(t, p)
Definition: z3py.py:7889
def is_ge(a)
Definition: z3py.py:2710
def Concat(*args)
Definition: z3py.py:3854
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9857
def BV2Int(a, is_signed=False)
Definition: z3py.py:3751
def Cond(p, t1, t2, ctx=None)
Definition: z3py.py:8208
def is_idiv(a)
Definition: z3py.py:2666
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1628
def FailIf(p, ctx=None)
Definition: z3py.py:8171
def is_fp(a)
Definition: z3py.py:9198
def When(p, t, ctx=None)
Definition: z3py.py:8190
def Default(a)
Definition: z3py.py:4478
def PartialOrder(a, index)
Definition: z3py.py:10473
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:9030
def IntVector(prefix, sz, ctx=None)
Definition: z3py.py:3069
def get_full_version()
Definition: z3py.py:89
def FPs(names, fpsort, ctx=None)
Definition: z3py.py:9409
def BVSubNoOverflow(a, b)
Definition: z3py.py:4218
def is_add(a)
Definition: z3py.py:2617
def FreshReal(prefix='b', ctx=None)
Definition: z3py.py:3134
def is_to_int(a)
Definition: z3py.py:2757
def TransitiveClosure(f)
Definition: z3py.py:10485
def solve(*args, **keywords)
Definition: z3py.py:8443
def FloatSingle(ctx=None)
Definition: z3py.py:8786
def user_prop_pop(ctx, num_scopes)
Definition: z3py.py:10531
def RTP(ctx=None)
Definition: z3py.py:9042
def is_is_int(a)
Definition: z3py.py:2732
def get_version_string()
Definition: z3py.py:73
def prove(claim, **keywords)
Definition: z3py.py:8500
def AndThen(*ts, **ks)
Definition: z3py.py:7789
def open_log(fname)
Definition: z3py.py:101
def fpIsNaN(a, ctx=None)
Definition: z3py.py:9623
def PbLe(args, k)
Definition: z3py.py:8412
def Float32(ctx=None)
Definition: z3py.py:8781
def is_to_real(a)
Definition: z3py.py:2743
def user_prop_fresh(id, ctx)
Definition: z3py.py:10534
def AtMost(*args)
Definition: z3py.py:8353
def is_func_decl(a)
Definition: z3py.py:787
def RealVar(idx, ctx=None)
Definition: z3py.py:1363
def is_false(a)
Definition: z3py.py:1476
def describe_probes()
Definition: z3py.py:8138
def SubSeq(s, offset, length)
Definition: z3py.py:10149
def StringSort(ctx=None)
Definition: z3py.py:10012
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9728
def Ints(names, ctx=None)
Definition: z3py.py:3057
def SetHasSize(a, k)
Definition: z3py.py:4574
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9649
def BoolSort(ctx=None)
Definition: z3py.py:1553
def SetComplement(s)
Definition: z3py.py:4673
def is_sub(a)
Definition: z3py.py:2639
def RatVal(a, b, ctx=None)
Definition: z3py.py:3018
def Then(*ts, **ks)
Definition: z3py.py:7808
def fpMin(a, b, ctx=None)
Definition: z3py.py:9580
def is_mul(a)
Definition: z3py.py:2628
def SuffixOf(a, b)
Definition: z3py.py:10211
def probes(ctx=None)
Definition: z3py.py:8120
def fpPlusZero(s)
Definition: z3py.py:9326
def fpLT(a, b, ctx=None)
Definition: z3py.py:9673
def is_fprm_value(a)
Definition: z3py.py:9074
def EnumSort(name, values, ctx=None)
Definition: z3py.py:5035
def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2082
def RotateRight(a, b)
Definition: z3py.py:4100
def fpSub(rm, a, b, ctx=None)
Definition: z3py.py:9525
def Cbrt(a, ctx=None)
Definition: z3py.py:3209
def IsInt(a)
Definition: z3py.py:3181
def Union(*args)
Definition: z3py.py:10371
def is_finite_domain_sort(s)
Definition: z3py.py:7270
def LastIndexOf(s, substr)
Definition: z3py.py:10278
def parse_smt2_file(f, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8645
def IntToStr(s)
Definition: z3py.py:10312
def ReSort(s)
Definition: z3py.py:10339
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3120
def FloatHalf(ctx=None)
Definition: z3py.py:8776
def Strings(names, ctx=None)
Definition: z3py.py:10138
def is_finite_domain_value(a)
Definition: z3py.py:7345
def is_bool(a)
Definition: z3py.py:1442
def Distinct(*args)
Definition: z3py.py:1290
def is_int(a)
Definition: z3py.py:2518
def UGT(a, b)
Definition: z3py.py:3977
def fpToIEEEBV(x, ctx=None)
Definition: z3py.py:9961
def is_map(a)
Definition: z3py.py:4372
def fpMinusZero(s)
Definition: z3py.py:9331
def Map(f, *args)
Definition: z3py.py:4520
def is_bv_value(a)
Definition: z3py.py:3737
def is_const(a)
Definition: z3py.py:1182
def is_app_of(a, k)
Definition: z3py.py:1256
def is_sort(s)
Definition: z3py.py:596
def fpPlusInfinity(s)
Definition: z3py.py:9299
def ULT(a, b)
Definition: z3py.py:3943
def TreeOrder(a, index)
Definition: z3py.py:10479
def Implies(a, b, ctx=None)
Definition: z3py.py:1641
def BVSNegNoOverflow(a)
Definition: z3py.py:4237
def get_as_array_func(n)
Definition: z3py.py:6285
def is_quantifier(a)
Definition: z3py.py:2018
def RNA(ctx=None)
Definition: z3py.py:9034
def RoundTowardZero(ctx=None)
Definition: z3py.py:9054
def is_seq(a)
Definition: z3py.py:10099
def Float128(ctx=None)
Definition: z3py.py:8801
def RealVal(val, ctx=None)
Definition: z3py.py:3000
def Int(name, ctx=None)
Definition: z3py.py:3045
def Or(*args)
Definition: z3py.py:1732
def is_probe(p)
Definition: z3py.py:8104
def is_algebraic_value(a)
Definition: z3py.py:2604
def RepeatBitVec(n, a)
Definition: z3py.py:4171
def Option(re)
Definition: z3py.py:10419
def String(name, ctx=None)
Definition: z3py.py:10130
def tactics(ctx=None)
Definition: z3py.py:7929
def Int2BV(a, num_bits)
Definition: z3py.py:3773
def user_prop_final(ctx, cb)
Definition: z3py.py:10547
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9684
def is_finite_domain(a)
Definition: z3py.py:7292
def is_string(a)
Definition: z3py.py:10108
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7263
def fpDiv(rm, a, b, ctx=None)
Definition: z3py.py:9553
def user_prop_eq(ctx, cb, x, y)
Definition: z3py.py:10553
def ToInt(a)
Definition: z3py.py:3164
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9386
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4225
def RecFunction(name, *sig)
Definition: z3py.py:843
def user_prop_diseq(ctx, cb, x, y)
Definition: z3py.py:10559
def Bool(name, ctx=None)
Definition: z3py.py:1588
def Plus(re)
Definition: z3py.py:10407
def is_eq(a)
Definition: z3py.py:1533
def ParOr(*ts, **ks)
Definition: z3py.py:7840
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9805
def RoundTowardNegative(ctx=None)
Definition: z3py.py:9046
def Update(a, i, v)
Definition: z3py.py:4457
def is_ast(a)
Definition: z3py.py:412
def fpGT(a, b, ctx=None)
Definition: z3py.py:9695
def MultiPattern(*args)
Definition: z3py.py:1797
def is_not(a)
Definition: z3py.py:1522
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9225
def eq(a, b)
Definition: z3py.py:432
def Complement(re)
Definition: z3py.py:10431
def disable_trace(msg)
Definition: z3py.py:70
def is_le(a)
Definition: z3py.py:2688
def is_real(a)
Definition: z3py.py:2536
def tactic_description(name, ctx=None)
Definition: z3py.py:7939
def is_app(a)
Definition: z3py.py:1157
def FreshConst(sort, prefix='c')
Definition: z3py.py:1346
def Contains(a, b)
Definition: z3py.py:10225
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4250
def IsMember(e, s)
Definition: z3py.py:4692
def get_version()
Definition: z3py.py:81
def CreateDatatypes(*ds)
Definition: z3py.py:4823
def TupleSort(name, sorts, ctx=None)
Definition: z3py.py:5012
def get_map_func(a)
Definition: z3py.py:4395
def SetDel(s, e)
Definition: z3py.py:4663
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9539
def is_default(a)
Definition: z3py.py:4387
def StringVal(s, ctx=None)
Definition: z3py.py:10125
def Full(s)
Definition: z3py.py:10179
def Sum(*args)
Definition: z3py.py:8302
def InRe(s, re)
Definition: z3py.py:10358
def enable_trace(msg)
Definition: z3py.py:67
def to_symbol(s, ctx=None)
Definition: z3py.py:109
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7872
def is_arith_sort(s)
Definition: z3py.py:2199
def RoundTowardPositive(ctx=None)
Definition: z3py.py:9038
def is_true(a)
Definition: z3py.py:1459
def substitute(t, *m)
Definition: z3py.py:8256
def BoolVal(val, ctx=None)
Definition: z3py.py:1570
def URem(a, b)
Definition: z3py.py:4014
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9608
def Store(a, i, v)
Definition: z3py.py:4489
def main_ctx()
Definition: z3py.py:211
def describe_tactics()
Definition: z3py.py:7947
def is_implies(a)
Definition: z3py.py:1511
def is_fp_value(a)
Definition: z3py.py:9211
def Real(name, ctx=None)
Definition: z3py.py:3094
def is_div(a)
Definition: z3py.py:2650
def is_select(a)
Definition: z3py.py:4579
def fpIsInf(a, ctx=None)
Definition: z3py.py:9634
def And(*args)
Definition: z3py.py:1700
def Array(name, dom, rng)
Definition: z3py.py:4444
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8698
def is_arith(a)
Definition: z3py.py:2498
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9654
def is_or(a)
Definition: z3py.py:1500
def fpNeg(a, ctx=None)
Definition: z3py.py:9449
def SetUnion(*args)
Definition: z3py.py:4629
def DisjointSum(name, sorts, ctx=None)
Definition: z3py.py:5023
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9900
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3781
def Model(ctx=None)
Definition: z3py.py:6277
def fpInfinity(s, negative)
Definition: z3py.py:9320
def is_re(s)
Definition: z3py.py:10354
def IntVal(val, ctx=None)
Definition: z3py.py:2989
Z3_ast_vector Z3_API Z3_algebraic_get_poly(Z3_context c, Z3_ast a)
Return the coefficients of the defining polynomial.
unsigned Z3_API Z3_algebraic_get_i(Z3_context c, Z3_ast a)
Return which root of the polynomial the algebraic number represents.
Z3_ast Z3_API Z3_mk_pbeq(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
Z3_ast Z3_API Z3_model_get_const_interp(Z3_context c, Z3_model m, Z3_func_decl a)
Return the interpretation (i.e., assignment) of constant a in the model m. Return NULL,...
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
Z3_probe Z3_API Z3_probe_lt(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is less than the value returned...
Z3_sort Z3_API Z3_mk_array_sort_n(Z3_context c, unsigned n, Z3_sort const *domain, Z3_sort range)
Create an array type with N arguments.
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.
Z3_parameter_kind Z3_API Z3_get_decl_parameter_kind(Z3_context c, Z3_func_decl d, unsigned idx)
Return the parameter type associated with a declaration.
Z3_ast Z3_API Z3_get_denominator(Z3_context c, Z3_ast a)
Return the denominator (as a numeral AST) of a numeral AST of sort Real.
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
Z3_decl_kind Z3_API Z3_get_decl_kind(Z3_context c, Z3_func_decl d)
Return declaration kind corresponding to declaration.
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.
Z3_ast Z3_API Z3_func_interp_get_else(Z3_context c, Z3_func_interp f)
Return the 'else' value of the given function interpretation.
void Z3_API Z3_solver_propagate_diseq(Z3_context c, Z3_solver s, Z3_eq_eh eq_eh)
register a callback on expression dis-equalities.
Z3_ast Z3_API Z3_mk_bvsge(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than or equal to.
Z3_tactic Z3_API Z3_tactic_using_params(Z3_context c, Z3_tactic t, Z3_params p)
Return a tactic that applies t using the given set of parameters.
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
Z3_probe Z3_API Z3_probe_eq(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is equal to the value returned ...
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
Z3_ast Z3_API Z3_mk_bvsle(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than or equal to.
Z3_func_decl Z3_API Z3_get_app_decl(Z3_context c, Z3_app a)
Return the declaration of a constant or function application.
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
Z3_ast Z3_API Z3_substitute(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const from[], Z3_ast const to[])
Substitute every occurrence of from[i] in a with to[i], for i smaller than num_exprs....
Z3_ast Z3_API Z3_mk_mul(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] * ... * args[num_args-1].
Z3_func_decl Z3_API Z3_get_decl_func_decl_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.
Z3_string Z3_API Z3_param_descrs_to_string(Z3_context c, Z3_param_descrs p)
Convert a parameter description set into a string. This function is mainly used for printing the cont...
Z3_ast Z3_API Z3_mk_zero_ext(Z3_context c, unsigned i, Z3_ast t1)
Extend the given bit-vector with zeros to the (unsigned) equivalent bit-vector of size m+i,...
void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p)
Set the given solver using the given parameters.
Z3_ast Z3_API Z3_mk_set_intersect(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the intersection of a list of sets.
Z3_ast Z3_API Z3_mk_str_le(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if s1 is equal or lexicographically strictly less than s2.
Z3_params Z3_API Z3_mk_params(Z3_context c)
Create a Z3 (empty) parameter set. Starting at Z3 4.0, parameter sets are used to configure many comp...
unsigned Z3_API Z3_get_decl_num_parameters(Z3_context c, Z3_func_decl d)
Return the number of parameters associated with a declaration.
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_lbool Z3_API Z3_solver_get_consequences(Z3_context c, Z3_solver s, Z3_ast_vector assumptions, Z3_ast_vector variables, Z3_ast_vector consequences)
retrieve consequences from solver that determine values of the supplied function symbols.
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
Z3_param_kind Z3_API Z3_param_descrs_get_kind(Z3_context c, Z3_param_descrs p, Z3_symbol n)
Return the kind associated with the given parameter name n.
unsigned Z3_API Z3_solver_propagate_register(Z3_context c, Z3_solver s, Z3_ast e)
register an expression to propagate on with the solver. Only expressions of type Bool and type Bit-Ve...
void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body)
Define the body of a recursive function.
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.
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
Z3_ast Z3_API Z3_mk_set_union(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the union of a list of sets.
void Z3_API Z3_apply_result_inc_ref(Z3_context c, Z3_apply_result r)
Increment the reference counter of the given Z3_apply_result object.
Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed division of t1 and t2 does not overflow.
unsigned Z3_API Z3_get_arity(Z3_context c, Z3_func_decl d)
Alias for Z3_get_domain_size.
Z3_ast Z3_API Z3_mk_bvxor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise exclusive-or.
Z3_string Z3_API Z3_stats_to_string(Z3_context c, Z3_stats s)
Convert a statistics into a string.
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
Z3_ast Z3_API Z3_mk_le(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than or equal to.
bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g)
Return true if the given goal contains the formula false.
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c, unsigned num_bound, Z3_app const bound[], Z3_ast body)
Create a lambda expression using a list of constants that form the set of bound variables.
Z3_tactic Z3_API Z3_tactic_par_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal and then t2 to every subgoal produced by t1....
void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s)
Decrement the reference counter of the given solver.
Z3_ast Z3_API Z3_mk_bvslt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than.
Z3_func_decl Z3_API Z3_model_get_func_decl(Z3_context c, Z3_model m, unsigned i)
Return the declaration of the i-th function in the given model.
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
unsigned Z3_API Z3_func_entry_get_num_args(Z3_context c, Z3_func_entry e)
Return the number of arguments in a Z3_func_entry object.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
Z3_symbol Z3_API Z3_get_decl_symbol_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the double value associated with an double parameter.
Z3_sort Z3_API Z3_get_seq_sort_basis(Z3_context c, Z3_sort s)
Retrieve basis sort for sequence sort.
Z3_ast Z3_API Z3_get_numerator(Z3_context c, Z3_ast a)
Return the numerator (as a numeral AST) of a numeral AST of sort Real.
Z3_ast Z3_API Z3_mk_unary_minus(Z3_context c, Z3_ast arg)
Create an AST node representing - arg.
Z3_probe Z3_API Z3_probe_ge(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is greater than or equal to the...
Z3_ast Z3_API Z3_mk_and(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] and ... and args[num_args-1].
void Z3_API Z3_interrupt(Z3_context c)
Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers,...
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
void Z3_API Z3_goal_assert(Z3_context c, Z3_goal g, Z3_ast a)
Add a new formula a to the given goal. The formula is split according to the following procedure that...
Z3_symbol Z3_API Z3_param_descrs_get_name(Z3_context c, Z3_param_descrs p, unsigned i)
Return the name of the parameter at given index i.
Z3_ast Z3_API Z3_func_entry_get_value(Z3_context c, Z3_func_entry e)
Return the value of this point.
bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a)
Determine if ast is an existential quantifier.
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
Z3_ast Z3_API Z3_mk_bvmul(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement multiplication.
Z3_ast Z3_API Z3_mk_seq_at(Z3_context c, Z3_ast s, Z3_ast index)
Retrieve from s the unit sequence positioned at position index. The sequence is empty if the index is...
Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m)
Convert a model of the formulas of a goal to a model of an original goal. The model may be null,...
void Z3_API Z3_del_constructor(Z3_context c, Z3_constructor constr)
Reclaim memory allocated to constructor.
Z3_ast Z3_API Z3_mk_bvsgt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than.
Z3_string Z3_API Z3_ast_to_string(Z3_context c, Z3_ast a)
Convert the given AST node into a string.
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
Z3_context Z3_API Z3_mk_context_rc(Z3_config c)
Create a context using the given configuration. This function is similar to Z3_mk_context....
Z3_ast_vector Z3_API Z3_solver_get_assertions(Z3_context c, Z3_solver s)
Return the set of asserted formulas on the solver.
Z3_string Z3_API Z3_get_full_version(void)
Return a string that fully describes the version of Z3 in use.
void Z3_API Z3_enable_trace(Z3_string tag)
Enable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.
Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t)
Create a new solver that is implemented using the given tactic. The solver supports the commands Z3_s...
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
unsigned Z3_API Z3_get_quantifier_num_patterns(Z3_context c, Z3_ast a)
Return number of patterns used in quantifier.
Z3_symbol Z3_API Z3_get_quantifier_bound_name(Z3_context c, Z3_ast a, unsigned i)
Return symbol of the i'th bound variable.
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx)
Return true if the given statistical data is a unsigned integer.
unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m)
Return the number of constants assigned by the given model.
Z3_char_ptr Z3_API Z3_get_lstring(Z3_context c, Z3_ast s, unsigned *length)
Retrieve the unescaped string constant stored in s.
Z3_ast Z3_API Z3_mk_extract(Z3_context c, unsigned high, unsigned low, Z3_ast t1)
Extract the bits high down to low from a bit-vector of size m to yield a new bit-vector of size n,...
Z3_ast Z3_API Z3_mk_mod(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 mod arg2.
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
Z3_ast Z3_API Z3_mk_ge(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than or equal to.
Z3_ast Z3_API Z3_mk_bvadd_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed addition of t1 and t2 does not underflow.
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise addition of t1 and t2 does not overflow.
void Z3_API Z3_set_ast_print_mode(Z3_context c, Z3_ast_print_mode mode)
Select mode for the format used for pretty-printing AST nodes.
Z3_ast Z3_API Z3_mk_array_default(Z3_context c, Z3_ast array)
Access the array default value. Produces the default range value, for arrays that can be represented ...
unsigned Z3_API Z3_model_get_num_sorts(Z3_context c, Z3_model m)
Return the number of uninterpreted sorts that m assigns an interpretation to.
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort_opt const sorts[], unsigned sort_refs[])
Create a constructor.
Z3_param_descrs Z3_API Z3_tactic_get_param_descrs(Z3_context c, Z3_tactic t)
Return the parameter description set for the given tactic object.
void Z3_API Z3_func_entry_inc_ref(Z3_context c, Z3_func_entry e)
Increment the reference counter of the given Z3_func_entry object.
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
Z3_ast Z3_API Z3_mk_bvsub_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed subtraction of t1 and t2 does not overflow.
void Z3_API Z3_solver_push(Z3_context c, Z3_solver s)
Create a backtracking point.
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise subtraction of t1 and t2 does not underflow.
Z3_goal Z3_API Z3_goal_translate(Z3_context source, Z3_goal g, Z3_context target)
Copy a goal g from the context source to the context target.
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.
Z3_ast_vector Z3_API Z3_solver_get_trail(Z3_context c, Z3_solver s)
Return the trail modulo model conversion, in order of decision level The decision level can be retrie...
Z3_ast Z3_API Z3_mk_bvshl(Z3_context c, Z3_ast t1, Z3_ast t2)
Shift left.
Z3_func_decl Z3_API Z3_mk_tree_order(Z3_context c, Z3_sort a, unsigned id)
create a tree ordering relation over signature a identified using index id.
bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a)
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a)
The (_ as-array f) AST node is a construct for assigning interpretations for arrays in Z3....
Z3_func_decl Z3_API Z3_mk_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a constant or function.
Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic)
Create a new solver customized for the given logic. It behaves like Z3_mk_solver if the logic is unkn...
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, bool v)
Add a Boolean parameter k with value v to the parameter set p.
unsigned Z3_API Z3_apply_result_get_num_subgoals(Z3_context c, Z3_apply_result r)
Return the number of subgoals in the Z3_apply_result object returned by Z3_tactic_apply.
Z3_ast Z3_API Z3_mk_ite(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_ast t3)
Create an AST node representing an if-then-else: ite(t1, t2, t3).
Z3_ast Z3_API Z3_mk_select(Z3_context c, Z3_ast a, Z3_ast i)
Array read. The argument a is the array and i is the index of the array that gets read.
Z3_ast Z3_API Z3_mk_sign_ext(Z3_context c, unsigned i, Z3_ast t1)
Sign-extend of the given bit-vector to the (signed) equivalent bit-vector of size m+i,...
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
Z3_ast_vector Z3_API Z3_solver_cube(Z3_context c, Z3_solver s, Z3_ast_vector vars, unsigned backtrack_level)
extract a next cube for a solver. The last cube is the constant true or false. The number of (non-con...
unsigned Z3_API Z3_goal_size(Z3_context c, Z3_goal g)
Return the number of formulas in the given goal.
void Z3_API Z3_stats_inc_ref(Z3_context c, Z3_stats s)
Increment the reference counter of the given statistics object.
bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s)
Check if s is a string sort.
Z3_ast Z3_API Z3_mk_div(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 div arg2.
Z3_ast Z3_API Z3_mk_pbge(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
Z3_ast Z3_API Z3_mk_pble(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
void Z3_API Z3_model_dec_ref(Z3_context c, Z3_model m)
Decrement the reference counter of the given model.
void Z3_API Z3_func_interp_inc_ref(Z3_context c, Z3_func_interp f)
Increment the reference counter of the given Z3_func_interp object.
Z3_func_decl Z3_API Z3_mk_piecewise_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a piecewise linear ordering relation over signature a and index id.
void Z3_API Z3_params_set_double(Z3_context c, Z3_params p, Z3_symbol k, double v)
Add a double parameter k with value v to the parameter set p.
Z3_string Z3_API Z3_param_descrs_get_documentation(Z3_context c, Z3_param_descrs p, Z3_symbol s)
Retrieve documentation string corresponding to parameter name s.
Z3_solver Z3_API Z3_mk_solver(Z3_context c)
Create a new solver. This solver is a "combined solver" (see combined_solver module) that internally ...
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.
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a)
Return the function declaration f associated with a (_ as_array f) node.
Z3_ast Z3_API Z3_mk_ext_rotate_left(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the left t2 times.
void Z3_API Z3_goal_inc_ref(Z3_context c, Z3_goal g)
Increment the reference counter of the given goal.
Z3_tactic Z3_API Z3_tactic_par_or(Z3_context c, unsigned num, Z3_tactic const ts[])
Return a tactic that applies the given tactics in parallel.
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
unsigned Z3_API Z3_get_datatype_sort_num_constructors(Z3_context c, Z3_sort t)
Return number of constructors for datatype.
void Z3_API Z3_params_set_uint(Z3_context c, Z3_params p, Z3_symbol k, unsigned v)
Add a unsigned parameter k with value v to the parameter set p.
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.
Z3_sort Z3_API Z3_model_get_sort(Z3_context c, Z3_model m, unsigned i)
Return a uninterpreted sort that m assigns an interpretation.
Z3_ast Z3_API Z3_mk_bvashr(Z3_context c, Z3_ast t1, Z3_ast t2)
Arithmetic shift right.
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast t1, bool is_signed)
Create an integer from the bit-vector argument t1. If is_signed is false, then the bit-vector t1 is t...
void Z3_API Z3_solver_import_model_converter(Z3_context ctx, Z3_solver src, Z3_solver dst)
Ad-hoc method for importing model conversion from solver.
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise multiplication of t1 and t2 does not overflow.
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.
Z3_ast Z3_API Z3_mk_bvor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise or.
int Z3_API Z3_get_decl_int_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the integer value associated with an integer parameter.
unsigned Z3_API Z3_get_quantifier_num_no_patterns(Z3_context c, Z3_ast a)
Return number of no_patterns used in quantifier.
Z3_func_decl Z3_API Z3_get_datatype_sort_constructor(Z3_context c, Z3_sort t, unsigned idx)
Return idx'th constructor.
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
Z3_probe Z3_API Z3_mk_probe(Z3_context c, Z3_string name)
Return a probe associated with the given name. The complete list of probes may be obtained using the ...
Z3_ast Z3_API Z3_mk_quantifier_const_ex(Z3_context c, bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, unsigned num_bound, Z3_app const bound[], unsigned num_patterns, Z3_pattern const patterns[], unsigned num_no_patterns, Z3_ast const no_patterns[], Z3_ast body)
Create a universal or existential quantifier using a list of constants that will form the set of boun...
Z3_tactic Z3_API Z3_tactic_when(Z3_context c, Z3_probe p, Z3_tactic t)
Return a tactic that applies t to a given goal is the probe p evaluates to true. If p evaluates to fa...
Z3_ast Z3_API Z3_mk_seq_suffix(Z3_context c, Z3_ast suffix, Z3_ast s)
Check if suffix is a suffix of s.
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.
Z3_symbol_kind Z3_API Z3_get_symbol_kind(Z3_context c, Z3_symbol s)
Return Z3_INT_SYMBOL if the symbol was constructed using Z3_mk_int_symbol, and Z3_STRING_SYMBOL if th...
Z3_sort Z3_API Z3_get_re_sort_basis(Z3_context c, Z3_sort s)
Retrieve basis sort for regex sort.
bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a)
Determine if ast is a lambda expression.
Z3_solver Z3_API Z3_solver_translate(Z3_context source, Z3_solver s, Z3_context target)
Copy a solver s from the context source to the context target.
Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s)
Return a string describing all solver available parameters.
unsigned Z3_API Z3_stats_get_uint_value(Z3_context c, Z3_stats s, unsigned idx)
Return the unsigned value of the given statistical data.
void Z3_API Z3_probe_inc_ref(Z3_context c, Z3_probe p)
Increment the reference counter of the given probe.
Z3_sort Z3_API Z3_get_array_sort_domain(Z3_context c, Z3_sort t)
Return the domain of the given array sort. In the case of a multi-dimensional array,...
Z3_ast Z3_API Z3_mk_bvmul_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed multiplication of t1 and t2 does not underflo...
Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned i)
Return the name of the i probe.
Z3_ast Z3_API Z3_func_decl_to_ast(Z3_context c, Z3_func_decl f)
Convert a Z3_func_decl into Z3_ast. This is just type casting.
Z3_ast Z3_API Z3_mk_bvadd(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement addition.
void Z3_API Z3_params_dec_ref(Z3_context c, Z3_params p)
Decrement the reference counter of the given parameter set.
Z3_ast Z3_API Z3_get_app_arg(Z3_context c, Z3_app a, unsigned i)
Return the i-th argument of the given application.
Z3_ast Z3_API Z3_mk_str_lt(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if s1 is lexicographically strictly less than s2.
Z3_string Z3_API Z3_model_to_string(Z3_context c, Z3_model m)
Convert the given model into a string.
Z3_string Z3_API Z3_tactic_get_help(Z3_context c, Z3_tactic t)
Return a string containing a description of parameters accepted by the given tactic.
Z3_func_decl Z3_API Z3_mk_fresh_func_decl(Z3_context c, Z3_string prefix, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a fresh constant or function.
void Z3_API Z3_solver_propagate_final(Z3_context c, Z3_solver s, Z3_final_eh final_eh)
register a callback on final check. This provides freedom to the propagator to delay actions or imple...
unsigned Z3_API Z3_param_descrs_size(Z3_context c, Z3_param_descrs p)
Return the number of parameters in the given parameter description set.
Z3_ast_vector Z3_API Z3_parse_smtlib2_string(Z3_context c, Z3_string str, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Parse the given string using the SMT-LIB2 parser.
Z3_string Z3_API Z3_goal_to_dimacs_string(Z3_context c, Z3_goal g, bool include_names)
Convert a goal into a DIMACS formatted string. The goal must be in CNF. You can convert a goal to CNF...
Z3_ast Z3_API Z3_mk_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than.
Z3_ast Z3_API Z3_get_quantifier_no_pattern_ast(Z3_context c, Z3_ast a, unsigned i)
Return i'th no_pattern.
double Z3_API Z3_stats_get_double_value(Z3_context c, Z3_stats s, unsigned idx)
Return the double value of the given statistical data.
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g)
Return the depth of the given goal. It tracks how many transformations were applied to it.
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.
Z3_ast Z3_API Z3_pattern_to_ast(Z3_context c, Z3_pattern p)
Convert a Z3_pattern into Z3_ast. This is just type casting.
Z3_ast Z3_API Z3_mk_bvnot(Z3_context c, Z3_ast t1)
Bitwise negation.
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
void Z3_API Z3_mk_datatypes(Z3_context c, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort sorts[], Z3_constructor_list constructor_lists[])
Create mutually recursive datatypes.
unsigned Z3_API Z3_func_interp_get_arity(Z3_context c, Z3_func_interp f)
Return the arity (number of arguments) of the given function interpretation.
Z3_ast_vector Z3_API Z3_solver_get_non_units(Z3_context c, Z3_solver s)
Return the set of non units in the solver state.
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement subtraction.
Z3_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of first occurrence of substr in s starting from offset offset. If s does not contain su...
Z3_ast Z3_API Z3_get_algebraic_number_upper(Z3_context c, Z3_ast a, unsigned precision)
Return a upper bound for the given real algebraic number. The interval isolating the number is smalle...
Z3_ast Z3_API Z3_mk_power(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 ^ arg2.
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, Z3_symbol name, unsigned n, Z3_symbol const enum_names[], Z3_func_decl enum_consts[], Z3_func_decl enum_testers[])
Create a enumeration sort.
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.
unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t)
Return the size of the given bit-vector sort.
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p)
Return a tactic that fails if the probe p evaluates to false.
void Z3_API Z3_func_interp_dec_ref(Z3_context c, Z3_func_interp f)
Decrement the reference counter of the given Z3_func_interp object.
void Z3_API Z3_probe_dec_ref(Z3_context c, Z3_probe p)
Decrement the reference counter of the given probe.
void Z3_API Z3_params_inc_ref(Z3_context c, Z3_params p)
Increment the reference counter of the given parameter set.
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.
Z3_ast Z3_API Z3_mk_distinct(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing distinct(args[0], ..., args[num_args-1]).
Z3_ast Z3_API Z3_mk_seq_prefix(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if prefix is a prefix of s.
Z3_config Z3_API Z3_mk_config(void)
Create a configuration object for the Z3 context object.
void Z3_API Z3_set_param_value(Z3_config c, Z3_string param_id, Z3_string param_value)
Set a configuration parameter.
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
Z3_string Z3_API Z3_params_to_string(Z3_context c, Z3_params p)
Convert a parameter set into a string. This function is mainly used for printing the contents of a pa...
void Z3_API Z3_solver_propagate_init(Z3_context c, Z3_solver s, void *user_context, Z3_push_eh push_eh, Z3_pop_eh pop_eh, Z3_fresh_eh fresh_eh)
register a user-properator with the solver.
Z3_func_decl Z3_API Z3_model_get_const_decl(Z3_context c, Z3_model m, unsigned i)
Return the i-th constant in the given model.
void Z3_API Z3_tactic_dec_ref(Z3_context c, Z3_tactic g)
Decrement the reference counter of the given tactic.
Z3_ast Z3_API Z3_translate(Z3_context source, Z3_ast a, Z3_context target)
Translate/Copy the AST a from context source to context target. AST a must have been created using co...
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
Z3_sort Z3_API Z3_get_range(Z3_context c, Z3_func_decl d)
Return the range of the given declaration.
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.
Z3_ast_vector Z3_API Z3_model_get_sort_universe(Z3_context c, Z3_model m, Z3_sort s)
Return the finite set of distinct values that represent the interpretation for sort s.
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.
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
void Z3_API Z3_func_entry_dec_ref(Z3_context c, Z3_func_entry e)
Decrement the reference counter of the given Z3_func_entry object.
unsigned Z3_API Z3_stats_size(Z3_context c, Z3_stats s)
Return the number of statistical data in s.
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.
Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a)
Return body of quantifier.
void Z3_API Z3_param_descrs_dec_ref(Z3_context c, Z3_param_descrs p)
Decrement the reference counter of the given parameter description set.
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
Z3_symbol Z3_API Z3_get_decl_name(Z3_context c, Z3_func_decl d)
Return the constant declaration name as a symbol.
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector.
Z3_string Z3_API Z3_stats_get_key(Z3_context c, Z3_stats s, unsigned idx)
Return the key (a string) for a particular statistical data.
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a string.
Z3_ast Z3_API Z3_mk_bvand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise and.
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
Z3_sort Z3_API Z3_mk_finite_domain_sort(Z3_context c, Z3_symbol name, uint64_t size)
Create a named finite domain sort.
Z3_ast Z3_API Z3_mk_add(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] + ... + args[num_args-1].
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.
Z3_ast_vector Z3_API Z3_parse_smtlib2_file(Z3_context c, Z3_string file_name, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Similar to Z3_parse_smtlib2_string, but reads the benchmark from a file.
Z3_ast Z3_API Z3_mk_bvsmod(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows divisor).
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context dst)
translate model from context c to context dst.
void Z3_API Z3_solver_get_levels(Z3_context c, Z3_solver s, Z3_ast_vector literals, unsigned sz, unsigned levels[])
retrieve the decision depth of Boolean literals (variables or their negations). Assumes a check-sat c...
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.
Z3_apply_result Z3_API Z3_tactic_apply_ex(Z3_context c, Z3_tactic t, Z3_goal g, Z3_params p)
Apply tactic t to the goal g using the parameter set p.
Z3_ast Z3_API Z3_mk_int2bv(Z3_context c, unsigned n, Z3_ast t1)
Create an n bit bit-vector from the integer argument t1.
void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a)
Assert a constraint into the solver.
Z3_tactic Z3_API Z3_mk_tactic(Z3_context c, Z3_string name)
Return a tactic associated with the given name. The complete list of tactics may be obtained using th...
unsigned Z3_API Z3_get_quantifier_weight(Z3_context c, Z3_ast a)
Obtain weight of quantifier.
void Z3_API Z3_solver_propagate_consequence(Z3_context c, Z3_solver_callback, unsigned num_fixed, unsigned const *fixed_ids, unsigned num_eqs, unsigned const *eq_lhs, unsigned const *eq_rhs, Z3_ast conseq)
propagate a consequence based on fixed values. This is a callback a client may invoke during the fixe...
unsigned Z3_API Z3_solver_get_num_scopes(Z3_context c, Z3_solver s)
Return the number of backtracking points.
Z3_sort Z3_API Z3_get_array_sort_range(Z3_context c, Z3_sort t)
Return the range of the given array sort.
void Z3_API Z3_del_constructor_list(Z3_context c, Z3_constructor_list clist)
Reclaim memory allocated for constructor list.
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a bound variable.
unsigned Z3_API Z3_get_app_num_args(Z3_context c, Z3_app a)
Return the number of argument of an application. If t is an constant, then the number of arguments is...
Z3_ast Z3_API Z3_func_entry_get_arg(Z3_context c, Z3_func_entry e, unsigned i)
Return an argument of a Z3_func_entry object.
Z3_ast Z3_API Z3_mk_eq(Z3_context c, Z3_ast l, Z3_ast r)
Create an AST node representing l = r.
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m)
Return the number of function interpretations in the given model.
void Z3_API Z3_dec_ref(Z3_context c, Z3_ast a)
Decrement the reference counter of the given AST. The context c should have been created using Z3_mk_...
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...
Z3_func_decl Z3_API Z3_mk_partial_order(Z3_context c, Z3_sort a, unsigned id)
create a partial ordering relation over signature a and index id.
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
Z3_ast Z3_API Z3_mk_set_has_size(Z3_context c, Z3_ast set, Z3_ast k)
Create predicate that holds if Boolean array set has k elements set to true.
Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned i)
Return the name of the idx tactic.
bool Z3_API Z3_is_string(Z3_context c, Z3_ast s)
Determine if s is a string constant.
Z3_ast Z3_API Z3_mk_re_loop(Z3_context c, Z3_ast r, unsigned lo, unsigned hi)
Create a regular expression loop. The supplied regular expression r is repeated between lo and hi tim...
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.
Z3_string Z3_API Z3_tactic_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the tactic with the given name.
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
Z3_goal_prec Z3_API Z3_goal_precision(Z3_context c, Z3_goal g)
Return the "precision" of the given goal. Goals can be transformed using over and under approximation...
void Z3_API Z3_solver_pop(Z3_context c, Z3_solver s, unsigned n)
Backtrack n backtracking points.
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.
Z3_goal Z3_API Z3_mk_goal(Z3_context c, bool models, bool unsat_cores, bool proofs)
Create a goal (aka problem). A goal is essentially a set of formulas, that can be solved and/or trans...
double Z3_API Z3_get_decl_double_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the double value associated with an double parameter.
unsigned Z3_API Z3_get_ast_hash(Z3_context c, Z3_ast a)
Return a hash code for the given AST. The hash code is structural. You can use Z3_get_ast_id intercha...
Z3_symbol Z3_API Z3_get_sort_name(Z3_context c, Z3_sort d)
Return the sort name as a symbol.
void Z3_API Z3_params_validate(Z3_context c, Z3_params p, Z3_param_descrs d)
Validate the parameter set p against the parameter description set d.
Z3_func_decl Z3_API Z3_get_datatype_sort_recognizer(Z3_context c, Z3_sort t, unsigned idx)
Return idx'th recognizer.
void Z3_API Z3_global_param_reset_all(void)
Restore the value of all global (and module) parameters. This command will not affect already created...
Z3_ast Z3_API Z3_mk_gt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than.
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
Z3_probe Z3_API Z3_probe_gt(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is greater than the value retur...
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.
Z3_string Z3_API Z3_get_decl_rational_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the rational value, as a string, associated with a rational parameter.
bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast t1, Z3_ast t2)
Compare terms.
bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a)
Determine if an ast is a universal quantifier.
void Z3_API Z3_tactic_inc_ref(Z3_context c, Z3_tactic t)
Increment the reference counter of the given tactic.
void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a file.
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
void Z3_API Z3_solver_propagate_eq(Z3_context c, Z3_solver s, Z3_eq_eh eq_eh)
register a callback on expression equalities.
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
Z3_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms)
Return a tactic that applies t to a given goal for ms milliseconds. If t does not terminate in ms mil...
void Z3_API Z3_apply_result_dec_ref(Z3_context c, Z3_apply_result r)
Decrement the reference counter of the given Z3_apply_result object.
Z3_ast Z3_API Z3_mk_map(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast const *args)
Map f on the argument arrays.
Z3_sort Z3_API Z3_mk_seq_sort(Z3_context c, Z3_sort s)
Create a sequence sort out of the sort for the elements.
Z3_ast_vector Z3_API Z3_solver_get_units(Z3_context c, Z3_solver s)
Return the set of units modulo model conversion.
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_ast Z3_API Z3_mk_seq_last_index(Z3_context c, Z3_ast, Z3_ast substr)
Return the last occurrence of substr in s. If s does not contain substr, then the value is -1,...
Z3_string Z3_API Z3_probe_get_descr(Z3_context c, Z3_string name)
Return a string containing a description of the probe with the given name.
void Z3_API Z3_param_descrs_inc_ref(Z3_context c, Z3_param_descrs p)
Increment the reference counter of the given parameter description set.
Z3_goal Z3_API Z3_apply_result_get_subgoal(Z3_context c, Z3_apply_result r, unsigned i)
Return one of the subgoals in the Z3_apply_result object returned by Z3_tactic_apply.
Z3_probe Z3_API Z3_probe_le(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is less than or equal to the va...
void Z3_API Z3_stats_dec_ref(Z3_context c, Z3_stats s)
Decrement the reference counter of the given statistics object.
Z3_ast Z3_API Z3_mk_array_ext(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create array extensionality index given two arrays with the same sort. The meaning is given by the ax...
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
Z3_ast Z3_API Z3_sort_to_ast(Z3_context c, Z3_sort s)
Convert a Z3_sort into Z3_ast. This is just type casting.
Z3_func_entry Z3_API Z3_func_interp_get_entry(Z3_context c, Z3_func_interp f, unsigned i)
Return a "point" of the given function interpretation. It represents the value of f in a particular p...
Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a recursive function.
unsigned Z3_API Z3_get_ast_id(Z3_context c, Z3_ast t)
Return a unique identifier for t. The identifier is unique up to structural equality....
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
unsigned Z3_API Z3_get_quantifier_num_bound(Z3_context c, Z3_ast a)
Return number of bound variables of quantifier.
Z3_sort Z3_API Z3_get_decl_sort_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the sort value associated with a sort parameter.
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
Z3_apply_result Z3_API Z3_tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g)
Apply tactic t to the goal g.
Z3_bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, uint64_t *r)
Store the size of the sort in r. Return false if the call failed. That is, Z3_get_sort_kind(s) == Z3_...
Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const args[])
Create a constant or function application.
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).
Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s)
Return statistics for the given solver.
Z3_ast Z3_API Z3_mk_bvneg(Z3_context c, Z3_ast t1)
Standard two's complement unary minus.
Z3_func_decl Z3_API Z3_mk_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a linear ordering relation over signature a. The relation is identified by the index id.
Z3_sort Z3_API Z3_get_domain(Z3_context c, Z3_func_decl d, unsigned i)
Return the sort of the i-th parameter of the given function declaration.
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
void Z3_API Z3_params_set_symbol(Z3_context c, Z3_params p, Z3_symbol k, Z3_symbol v)
Add a symbol parameter k with value v to the parameter set p.
Z3_string Z3_API Z3_solver_to_dimacs_string(Z3_context c, Z3_solver s, bool include_names)
Convert a solver into a DIMACS formatted string.
Z3_func_decl Z3_API Z3_to_func_decl(Z3_context c, Z3_ast a)
Convert an AST into a FUNC_DECL_AST. This is just type casting.
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
Z3_ast Z3_API Z3_mk_lstring(Z3_context c, unsigned len, Z3_string s)
Create a string constant out of the string that is passed in It takes the length of the string as wel...
Z3_ast Z3_API Z3_mk_bvsdiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed division.
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
Z3_ast Z3_API Z3_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.
Z3_pattern Z3_API Z3_get_quantifier_pattern_ast(Z3_context c, Z3_ast a, unsigned i)
Return i'th pattern.
double Z3_API Z3_probe_apply(Z3_context c, Z3_probe p, Z3_goal g)
Execute the probe over the goal. The probe always produce a double value. "Boolean" probes return 0....
void Z3_API Z3_goal_dec_ref(Z3_context c, Z3_goal g)
Decrement the reference counter of the given goal.
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the free variables in a with the expressions in to. For every i smaller than num_exprs,...
Z3_ast Z3_API Z3_mk_or(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] or ... or args[num_args-1].
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
Z3_tactic Z3_API Z3_tactic_or_else(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that first applies t1 to a given goal, if it fails then returns the result of t2 appl...
void Z3_API Z3_model_inc_ref(Z3_context c, Z3_model m)
Increment the reference counter of the given model.
Z3_ast Z3_API Z3_mk_seq_extract(Z3_context c, Z3_ast s, Z3_ast offset, Z3_ast length)
Extract subsequence starting at offset of length.
Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, bool model_completion, Z3_ast *v)
Evaluate the AST node t in the given model. Return true if succeeded, and store the result in v.
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
Z3_string Z3_API Z3_get_numeral_string(Z3_context c, Z3_ast a)
Return numeral value, as a decimal string of a numeric constant term.
void Z3_API Z3_solver_propagate_fixed(Z3_context c, Z3_solver s, Z3_fixed_eh fixed_eh)
register a callback for when an expression is bound to a fixed value. The supported expression types ...
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
Z3_string Z3_API Z3_apply_result_to_string(Z3_context c, Z3_apply_result r)
Convert the Z3_apply_result object returned by Z3_tactic_apply into a string.
Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s)
Convert a solver into a string.
Z3_string Z3_API Z3_solver_get_reason_unknown(Z3_context c, Z3_solver s)
Return a brief justification for an "unknown" result (i.e., Z3_L_UNDEF) for the commands Z3_solver_ch...
Z3_string Z3_API Z3_get_numeral_binary_string(Z3_context c, Z3_ast a)
Return numeral value, as a binary string of a numeric constant term.
Z3_sort Z3_API Z3_get_quantifier_bound_sort(Z3_context c, Z3_ast a, unsigned i)
Return sort of the i'th bound variable.
void Z3_API Z3_disable_trace(Z3_string tag)
Disable tracing messages tagged as tag when Z3 is compiled in debug mode. It is a NOOP otherwise.
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max)
Return a tactic that keeps applying t until the goal is not modified anymore or the maximum number of...
Z3_ast Z3_API Z3_goal_formula(Z3_context c, Z3_goal g, unsigned idx)
Return a formula from the given goal.
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
unsigned Z3_API Z3_func_interp_get_num_entries(Z3_context c, Z3_func_interp f)
Return the number of entries in the given function interpretation.
Z3_probe Z3_API Z3_probe_const(Z3_context x, double val)
Return a probe that always evaluates to val.
Z3_string Z3_API Z3_goal_to_string(Z3_context c, Z3_goal g)
Convert a goal into a string.
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2)
compare sorts.
void Z3_API Z3_del_config(Z3_config c)
Delete the given configuration object.
void Z3_API Z3_inc_ref(Z3_context c, Z3_ast a)
Increment the reference counter of the given AST. The context c should have been created using Z3_mk_...
Z3_tactic Z3_API Z3_tactic_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal and t2 to every subgoal produced by t1.
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.
Z3_func_interp Z3_API Z3_model_get_func_interp(Z3_context c, Z3_model m, Z3_func_decl f)
Return the interpretation of the function f in the model m. Return NULL, if the model does not assign...
void Z3_API Z3_solver_inc_ref(Z3_context c, Z3_solver s)
Increment the reference counter of the given solver.
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for 8 bit strings.
Z3_ast Z3_API Z3_mk_ext_rotate_right(Z3_context c, Z3_ast t1, Z3_ast t2)
Rotate bits of t1 to the right t2 times.
Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision)
Return numeral as a string in decimal notation. The result has at most precision decimal places.
Z3_bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.
Z3_func_decl Z3_API Z3_get_datatype_sort_constructor_accessor(Z3_context c, Z3_sort t, unsigned idx_c, unsigned idx_a)
Return idx_a'th accessor for the idx_c'th constructor.
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
Z3_ast Z3_API Z3_mk_seq_nth(Z3_context c, Z3_ast s, Z3_ast index)
Retrieve from s the element positioned at position index. The function is under-specified if the inde...
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s)
Remove all assertions from the solver.
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a)
Return true if the given AST is a real algebraic number.
void Z3_API Z3_ast_map_inc_ref(Z3_context c, Z3_ast_map m)
Increment the reference counter of the given AST map.
Z3_ast Z3_API Z3_ast_map_find(Z3_context c, Z3_ast_map m, Z3_ast k)
Return the value associated with the key k.
Z3_string Z3_API Z3_ast_map_to_string(Z3_context c, Z3_ast_map m)
Convert the given map into a string.
void Z3_API Z3_ast_vector_set(Z3_context c, Z3_ast_vector v, unsigned i, Z3_ast a)
Update position i of the AST vector v with the AST a.
bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k)
Return true if the map m contains the AST key k.
Z3_ast_vector Z3_API Z3_ast_map_keys(Z3_context c, Z3_ast_map m)
Return the keys stored in the given map.
Z3_ast_vector Z3_API Z3_ast_vector_translate(Z3_context s, Z3_ast_vector v, Z3_context t)
Translate the AST vector v from context s into an AST vector in context t.
Z3_string Z3_API Z3_ast_vector_to_string(Z3_context c, Z3_ast_vector v)
Convert AST vector into a string.
void Z3_API Z3_ast_vector_resize(Z3_context c, Z3_ast_vector v, unsigned n)
Resize the AST vector v.
unsigned Z3_API Z3_ast_map_size(Z3_context c, Z3_ast_map m)
Return the size of the given map.
void Z3_API Z3_ast_vector_dec_ref(Z3_context c, Z3_ast_vector v)
Decrement the reference counter of the given AST vector.
void Z3_API Z3_ast_map_dec_ref(Z3_context c, Z3_ast_map m)
Decrement the reference counter of the given AST map.
unsigned Z3_API Z3_ast_vector_size(Z3_context c, Z3_ast_vector v)
Return the size of the given AST vector.
void Z3_API Z3_ast_vector_inc_ref(Z3_context c, Z3_ast_vector v)
Increment the reference counter of the given AST vector.
Z3_ast_vector Z3_API Z3_mk_ast_vector(Z3_context c)
Return an empty AST vector.
void Z3_API Z3_ast_map_erase(Z3_context c, Z3_ast_map m, Z3_ast k)
Erase a key from the map.
void Z3_API Z3_ast_vector_push(Z3_context c, Z3_ast_vector v, Z3_ast a)
Add the AST a in the end of the AST vector v. The size of v is increased by one.
Z3_ast_map Z3_API Z3_mk_ast_map(Z3_context c)
Return an empty mapping from AST to AST.
Z3_ast Z3_API Z3_ast_vector_get(Z3_context c, Z3_ast_vector v, unsigned i)
Return the AST at position i in the AST vector v.
void Z3_API Z3_ast_map_insert(Z3_context c, Z3_ast_map m, Z3_ast k, Z3_ast v)
Store/Replace a new key, value pair in the given map.
void Z3_API Z3_ast_map_reset(Z3_context c, Z3_ast_map m)
Remove all keys from the given map.
void Z3_API Z3_fixedpoint_inc_ref(Z3_context c, Z3_fixedpoint d)
Increment the reference counter of the given fixedpoint context.
void Z3_API Z3_fixedpoint_add_rule(Z3_context c, Z3_fixedpoint d, Z3_ast rule, Z3_symbol name)
Add a universal Horn clause as a named rule. The horn_rule should be of the form:
void Z3_API Z3_fixedpoint_set_predicate_representation(Z3_context c, Z3_fixedpoint d, Z3_func_decl f, unsigned num_relations, Z3_symbol const relation_kinds[])
Configure the predicate representation.
Z3_ast_vector Z3_API Z3_fixedpoint_from_file(Z3_context c, Z3_fixedpoint f, Z3_string s)
Parse an SMT-LIB2 file with fixedpoint rules. Add the rules to the current fixedpoint context....
Z3_param_descrs Z3_API Z3_fixedpoint_get_param_descrs(Z3_context c, Z3_fixedpoint f)
Return the parameter description set for the given fixedpoint object.
void Z3_API Z3_fixedpoint_update_rule(Z3_context c, Z3_fixedpoint d, Z3_ast a, Z3_symbol name)
Update a named rule. A rule with the same name must have been previously created.
Z3_ast_vector Z3_API Z3_fixedpoint_from_string(Z3_context c, Z3_fixedpoint f, Z3_string s)
Parse an SMT-LIB2 string with fixedpoint rules. Add the rules to the current fixedpoint context....
Z3_ast_vector Z3_API Z3_fixedpoint_get_assertions(Z3_context c, Z3_fixedpoint f)
Retrieve set of background assertions from fixedpoint context.
void Z3_API Z3_fixedpoint_dec_ref(Z3_context c, Z3_fixedpoint d)
Decrement the reference counter of the given fixedpoint context.
Z3_lbool Z3_API Z3_fixedpoint_query(Z3_context c, Z3_fixedpoint d, Z3_ast query)
Pose a query against the asserted rules.
Z3_ast_vector Z3_API Z3_fixedpoint_get_rules(Z3_context c, Z3_fixedpoint f)
Retrieve set of rules from fixedpoint context.
Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c)
Create a new fixedpoint context.
unsigned Z3_API Z3_fixedpoint_get_num_levels(Z3_context c, Z3_fixedpoint d, Z3_func_decl pred)
Query the PDR engine for the maximal levels properties are known about predicate.
Z3_string Z3_API Z3_fixedpoint_to_string(Z3_context c, Z3_fixedpoint f, unsigned num_queries, Z3_ast queries[])
Print the current rules and background axioms as a string.
Z3_ast Z3_API Z3_fixedpoint_get_cover_delta(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred)
Z3_stats Z3_API Z3_fixedpoint_get_statistics(Z3_context c, Z3_fixedpoint d)
Retrieve statistics information from the last call to Z3_fixedpoint_query.
Z3_string Z3_API Z3_fixedpoint_get_reason_unknown(Z3_context c, Z3_fixedpoint d)
Retrieve a string that describes the last status returned by Z3_fixedpoint_query.
Z3_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint f)
Return a string describing all fixedpoint available parameters.
void Z3_API Z3_fixedpoint_assert(Z3_context c, Z3_fixedpoint d, Z3_ast axiom)
Assert a constraint to the fixedpoint context.
void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint f, Z3_params p)
Set parameters on fixedpoint context.
Z3_ast Z3_API Z3_fixedpoint_get_answer(Z3_context c, Z3_fixedpoint d)
Retrieve a formula that encodes satisfying answers to the query.
void Z3_API Z3_fixedpoint_register_relation(Z3_context c, Z3_fixedpoint d, Z3_func_decl f)
Register relation as Fixedpoint defined. Fixedpoint defined relations have least-fixedpoint semantics...
void Z3_API Z3_fixedpoint_add_cover(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred, Z3_ast property)
Add property about the predicate pred. Add a property of predicate pred at level. It gets pushed forw...
Z3_lbool Z3_API Z3_fixedpoint_query_relations(Z3_context c, Z3_fixedpoint d, unsigned num_relations, Z3_func_decl const relations[])
Pose multiple queries against the asserted rules.
Z3_ast Z3_API Z3_mk_fpa_to_fp_bv(Z3_context c, Z3_ast bv, Z3_sort s)
Conversion of a single IEEE 754-2008 bit-vector into a floating-point number.
Z3_ast Z3_API Z3_mk_fpa_to_ieee_bv(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
Z3_ast Z3_API Z3_mk_fpa_to_fp_signed(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_to_sbv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.
bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int *sgn)
Retrieves the sign of a floating-point literal.
Z3_ast Z3_API Z3_mk_fpa_to_ubv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
unsigned Z3_API Z3_fpa_get_ebits(Z3_context c, Z3_sort s)
Retrieves the number of bits reserved for the exponent in a FloatingPoint sort.
bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is positive.
bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t *n, bool biased)
Return the exponent value of a floating-point numeral as a signed 64-bit integer.
bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is a NaN.
unsigned Z3_API Z3_fpa_get_sbits(Z3_context c, Z3_sort s)
Retrieves the number of bits reserved for the significand in a FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_round_toward_negative(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardNegative rounding mode.
Z3_ast Z3_API Z3_mk_fpa_to_fp_real(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a term of real sort into a term of FloatingPoint sort.
bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t *n)
Return the significand value of a floating-point numeral as a uint64.
Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, bool biased)
Return the exponent value of a floating-point numeral as a string.
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is subnormal.
Z3_ast Z3_API Z3_mk_fpa_round_toward_positive(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardPositive rounding mode.
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is negative.
Z3_ast Z3_API Z3_fpa_get_numeral_significand_bv(Z3_context c, Z3_ast t)
Retrieves the significand of a floating-point literal as a bit-vector expression.
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_away(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
Z3_ast Z3_API Z3_mk_fpa_to_real(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a real-numbered term.
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
Z3_ast Z3_API Z3_mk_fpa_fp(Z3_context c, Z3_ast sgn, Z3_ast exp, Z3_ast sig)
Create an expression of FloatingPoint sort from three bit-vector expressions.
Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, bool biased)
Retrieves the exponent of a floating-point literal as a bit-vector expression.
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_to_fp_float(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a FloatingPoint term into another term of different FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_round_nearest_ties_to_even(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
Z3_string Z3_API Z3_fpa_get_numeral_significand_string(Z3_context c, Z3_ast t)
Return the significand value of a floating-point numeral as a string.
Z3_ast Z3_API Z3_fpa_get_numeral_sign_bv(Z3_context c, Z3_ast t)
Retrieves the sign of a floating-point literal as a bit-vector expression.
bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is normal.
Z3_ast Z3_API Z3_mk_fpa_round_toward_zero(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardZero rounding mode.
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is a +oo or -oo.
bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is +zero or -zero.
Z3_ast_vector Z3_API Z3_optimize_get_assertions(Z3_context c, Z3_optimize o)
Return the set of asserted formulas on the optimization context.
Z3_ast_vector Z3_API Z3_optimize_get_unsat_core(Z3_context c, Z3_optimize o)
Retrieve the unsat core for the last Z3_optimize_check The unsat core is a subset of the assumptions ...
Z3_ast_vector Z3_API Z3_optimize_get_upper_as_vector(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve upper bound value or approximation for the i'th optimization objective.
Z3_ast Z3_API Z3_optimize_get_lower(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve lower bound value or approximation for the i'th optimization objective.
Z3_model Z3_API Z3_optimize_get_model(Z3_context c, Z3_optimize o)
Retrieve the model for the last Z3_optimize_check.
void Z3_API Z3_optimize_from_file(Z3_context c, Z3_optimize o, Z3_string s)
Parse an SMT-LIB2 file with assertions, soft constraints and optimization objectives....
void Z3_API Z3_optimize_pop(Z3_context c, Z3_optimize d)
Backtrack one level.
Z3_ast_vector Z3_API Z3_optimize_get_lower_as_vector(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve lower bound value or approximation for the i'th optimization objective. The returned vector ...
void Z3_API Z3_optimize_assert_and_track(Z3_context c, Z3_optimize o, Z3_ast a, Z3_ast t)
Assert tracked hard constraint to the optimization context.
unsigned Z3_API Z3_optimize_assert_soft(Z3_context c, Z3_optimize o, Z3_ast a, Z3_string weight, Z3_symbol id)
Assert soft constraint to the optimization context.
Z3_param_descrs Z3_API Z3_optimize_get_param_descrs(Z3_context c, Z3_optimize o)
Return the parameter description set for the given optimize object.
void Z3_API Z3_optimize_inc_ref(Z3_context c, Z3_optimize d)
Increment the reference counter of the given optimize context.
Z3_ast Z3_API Z3_optimize_get_upper(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve upper bound value or approximation for the i'th optimization objective.
void Z3_API Z3_optimize_set_params(Z3_context c, Z3_optimize o, Z3_params p)
Set parameters on optimization context.
void Z3_API Z3_optimize_push(Z3_context c, Z3_optimize d)
Create a backtracking point.
Z3_ast_vector Z3_API Z3_optimize_get_objectives(Z3_context c, Z3_optimize o)
Return objectives on the optimization context. If the objective function is a max-sat objective it is...
void Z3_API Z3_optimize_assert(Z3_context c, Z3_optimize o, Z3_ast a)
Assert hard constraint to the optimization context.
Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o)
Print the current context as a string.
Z3_optimize Z3_API Z3_mk_optimize(Z3_context c)
Create a new optimize context.
void Z3_API Z3_optimize_dec_ref(Z3_context c, Z3_optimize d)
Decrement the reference counter of the given optimize context.
Z3_string Z3_API Z3_optimize_get_help(Z3_context c, Z3_optimize t)
Return a string containing a description of parameters accepted by optimize.
Z3_stats Z3_API Z3_optimize_get_statistics(Z3_context c, Z3_optimize d)
Retrieve statistics information from the last call to Z3_optimize_check.
unsigned Z3_API Z3_optimize_minimize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a minimization constraint.
unsigned Z3_API Z3_optimize_maximize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a maximization constraint.
Z3_string Z3_API Z3_optimize_get_reason_unknown(Z3_context c, Z3_optimize d)
Retrieve a string that describes the last status returned by Z3_optimize_check.
void Z3_API Z3_optimize_from_string(Z3_context c, Z3_optimize o, Z3_string s)
Parse an SMT-LIB2 string with assertions, soft constraints and optimization objectives....
Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o, unsigned num_assumptions, Z3_ast const assumptions[])
Check consistency and produce optimal values.