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.ctx = Z3_mk_context_rc(conf)
187  self.eh = Z3_set_error_handler(self.ctx, z3_error_handler)
188  Z3_set_ast_print_mode(self.ctx, Z3_PRINT_SMTLIB2_COMPLIANT)
189  Z3_del_config(conf)
190 
191  def __del__(self):
192  Z3_del_context(self.ctx)
193  self.ctx = None
194  self.eh = None
195 
196  def ref(self):
197  """Return a reference to the actual C pointer to the Z3 context."""
198  return self.ctx
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.ref())
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.ast = ast
309  self.ctx = _get_ctx(ctx)
310  Z3_inc_ref(self.ctx.ref(), self.as_ast())
311 
312  def __del__(self):
313  if self.ctx.ref() is not None and self.ast is not None:
314  Z3_dec_ref(self.ctx.ref(), self.as_ast())
315  self.ast = None
316 
317  def __deepcopy__(self, memo={}):
318  return _to_ast_ref(self.ast, self.ctx)
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.eq(other)
328 
329  def __hash__(self):
330  return self.hash()
331 
332  def __nonzero__(self):
333  return self.__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_ref(), self.as_ast())
353 
354  def as_ast(self):
355  """Return a pointer to the corresponding C Z3_ast object."""
356  return self.ast
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_ref(), self.as_ast())
361 
362  def ctx_ref(self):
363  """Return a reference to the C context where this AST node is stored."""
364  return self.ctx.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_ref(), self.as_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.ctx.ref(), self.as_ast(), target.ref()), target)
398 
399  def __copy__(self):
400  return self.translate(self.ctx)
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_ref(), self.as_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_ref(), self.ast)
515 
516  def get_id(self):
517  return Z3_get_ast_id(self.ctx_ref(), self.as_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.ctx, self.ast)
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.eq(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.ctx, Z3_get_sort_name(self.ctx_ref(), self.ast))
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_ref(), self.ast, 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_ref(), self.ast, 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_ref(), self.ast)
670 
671  def get_id(self):
672  return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
673 
674  def as_func_decl(self):
675  return self.ast
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.ctx, Z3_get_decl_name(self.ctx_ref(), self.ast))
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_ref(), self.ast))
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.arity(), "Index out of bounds")
708  return _to_sort_ref(Z3_get_domain(self.ctx_ref(), self.ast, i), self.ctx)
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_ref(), self.ast), self.ctx)
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_ref(), self.ast)
730 
731  def params(self):
732  ctx = self.ctx
733  n = Z3_get_decl_num_parameters(self.ctx_ref(), self.ast)
734  result = [ None for i in range(n) ]
735  for i in range(n):
736  k = Z3_get_decl_parameter_kind(self.ctx_ref(), self.ast, i)
737  if k == Z3_PARAMETER_INT:
738  result[i] = Z3_get_decl_int_parameter(self.ctx_ref(), self.ast, i)
739  elif k == Z3_PARAMETER_DOUBLE:
740  result[i] = Z3_get_decl_double_parameter(self.ctx_ref(), self.ast, i)
741  elif k == Z3_PARAMETER_RATIONAL:
742  result[i] = Z3_get_decl_rational_parameter(self.ctx_ref(), self.ast, i)
743  elif k == Z3_PARAMETER_SYMBOL:
744  result[i] = Z3_get_decl_symbol_parameter(self.ctx_ref(), self.ast, i)
745  elif k == Z3_PARAMETER_SORT:
746  result[i] = SortRef(Z3_get_decl_sort_parameter(self.ctx_ref(), self.ast, i), ctx)
747  elif k == Z3_PARAMETER_AST:
748  result[i] = ExprRef(Z3_get_decl_ast_parameter(self.ctx_ref(), self.ast, i), ctx)
749  elif k == Z3_PARAMETER_FUNC_DECL:
750  result[i] = FuncDeclRef(Z3_get_decl_func_decl_parameter(self.ctx_ref(), self.ast, 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.arity(), "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.domain(i).cast(args[i])
783  saved.append(tmp)
784  _args[i] = tmp.as_ast()
785  return _to_expr_ref(Z3_mk_app(self.ctx_ref(), self.ast, len(args), _args), self.ctx)
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.ast
905 
906  def get_id(self):
907  return Z3_get_ast_id(self.ctx_ref(), self.as_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.ctx, self.as_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.sort().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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), 2, _args), self.ctx)
970 
971  def params(self):
972  return self.decl().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_ref(), self.as_ast()), self.ctx)
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_ref(), self.as_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_args(), "Invalid argument index")
1024  return _to_expr_ref(Z3_get_app_arg(self.ctx_ref(), self.as_ast(), idx), self.ctx)
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.arg(i) for i in range(self.num_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.ctx)
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.eq(val.sort()):
1411  _z3_assert(self.eq(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_ref(), self.as_ast()), self.ctx)
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_ref(), self.ast)
1776 
1777  def get_id(self):
1778  return Z3_get_ast_id(self.ctx_ref(), self.as_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.ast
1837 
1838  def get_id(self):
1839  return Z3_get_ast_id(self.ctx_ref(), self.as_ast())
1840 
1841  def sort(self):
1842  """Return the Boolean sort or sort of Lambda."""
1843  if self.is_lambda():
1844  return _sort(self.ctx, self.as_ast())
1845  return BoolSort(self.ctx)
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_ref(), self.ast)
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_ref(), self.ast)
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_ref(), self.ast)
1888 
1889  def __getitem__(self, arg):
1890  """Return the Z3 expression `self[arg]`.
1891  """
1892  if z3_debug():
1893  _z3_assert(self.is_lambda(), "quantifier should be a lambda expression")
1894  arg = self.sort().domain().cast(arg)
1895  return _to_expr_ref(Z3_mk_select(self.ctx_ref(), self.as_ast(), arg.as_ast()), self.ctx)
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_ref(), self.ast))
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_ref(), self.ast))
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_patterns(), "Invalid pattern idx")
1940  return PatternRef(Z3_get_quantifier_pattern_ast(self.ctx_ref(), self.ast, idx), self.ctx)
1941 
1942  def num_no_patterns(self):
1943  """Return the number of no-patterns."""
1944  return Z3_get_quantifier_num_no_patterns(self.ctx_ref(), self.ast)
1945 
1946  def no_pattern(self, idx):
1947  """Return a no-pattern."""
1948  if z3_debug():
1949  _z3_assert(idx < self.num_no_patterns(), "Invalid no-pattern idx")
1950  return _to_expr_ref(Z3_get_quantifier_no_pattern_ast(self.ctx_ref(), self.ast, idx), self.ctx)
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_ref(), self.ast), self.ctx)
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_ref(), self.ast))
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_vars(), "Invalid variable idx")
1989  return _symbol2py(self.ctx, Z3_get_quantifier_bound_name(self.ctx_ref(), self.ast, 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_vars(), "Invalid variable idx")
2005  return _to_sort_ref(Z3_get_quantifier_bound_sort(self.ctx_ref(), self.ast, idx), self.ctx)
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.body() ]
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.kind() == 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.kind() == Z3_INT_SORT
2158 
2159  def subsort(self, other):
2160  """Return `True` if `self` is a subsort of `other`."""
2161  return self.is_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.ctx == val.ctx, "Context mismatch")
2180  val_s = val.sort()
2181  if self.eq(val_s):
2182  return val
2183  if val_s.is_int() and self.is_real():
2184  return ToReal(val)
2185  if val_s.is_bool() and self.is_int():
2186  return If(val, 1, 0)
2187  if val_s.is_bool() and self.is_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_int():
2193  return IntVal(val, self.ctx)
2194  if self.is_real():
2195  return RealVal(val, self.ctx)
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_ref(), self.as_ast()), self.ctx)
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.sort().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.sort().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.ctx)
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.ctx)
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.ctx)
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.ctx)
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.ctx)
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.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
2373 
2374  def __truediv__(self, other):
2375  """Create the Z3 expression `other/self`."""
2376  return self.__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_ref(), b.as_ast(), a.as_ast()), self.ctx)
2394 
2395  def __rtruediv__(self, other):
2396  """Create the Z3 expression `other/self`."""
2397  return self.__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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), self.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_int(), "Integer value expected")
2785  return int(self.as_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_ref(), self.as_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_ref(), self.as_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_ref(), self.as_ast()), self.ctx)
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_ref(), self.as_ast()), self.ctx)
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.numerator().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.denominator().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.denominator().is_int() and self.denominator_as_long() == 1
2864 
2865  def as_long(self):
2866  _z3_assert(self.is_int_value(), "Expected integer fraction")
2867  return self.numerator_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_ref(), self.as_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_ref(), self.as_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_long(), self.denominator_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_ref(), self.as_ast(), precision), self.ctx)
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_ref(), self.as_ast(), prec)
2923 
2924  def poly(self):
2925  return AstVector(Z3_algebraic_get_poly(self.ctx_ref(), self.as_ast()), self.ctx)
2926 
2927  def index(self):
2928  return Z3_algebraic_get_i(self.ctx_ref(), self.as_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_ref(), self.ast))
3238 
3239  def subsort(self, other):
3240  return is_bv_sort(other) and self.size() < 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.ctx == 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_ref(), self.as_ast()), self.ctx)
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.sort().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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), self.as_ast()), self.ctx)
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_ref(), self.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
3481 
3482  def __truediv__(self, other):
3483  """Create the Z3 expression (signed) division `self / other`."""
3484  return self.__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_ref(), b.as_ast(), a.as_ast()), self.ctx)
3501 
3502  def __rtruediv__(self, other):
3503  """Create the Z3 expression (signed) division `other / self`."""
3504  return self.__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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), a.as_ast(), b.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_ref(), b.as_ast(), a.as_ast()), self.ctx)
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_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.size()
3710  val = self.as_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_ref(), self.as_ast())
3719 
3720  def as_binary_string(self):
3721  return Z3_get_numeral_binary_string(self.ctx_ref(), self.as_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_ref(), self.ast), self.ctx)
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_ref(), self.ast), self.ctx)
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_ref(), self.as_ast()), self.ctx)
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.sort().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.sort().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.domain().cast(arg)
4326  return _to_expr_ref(Z3_mk_select(self.ctx_ref(), self.as_ast(), arg.as_ast()), self.ctx)
4327 
4328  def default(self):
4329  return _to_expr_ref(Z3_mk_array_default(self.ctx_ref(), self.as_ast()), self.ctx)
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.ctx = _get_ctx(ctx)
4751  self.name = name
4752  self.constructors = []
4753 
4754  def __deepcopy__(self, memo={}):
4755  r = Datatype(self.name, self.ctx)
4756  r.constructors = copy.deepcopy(self.constructors)
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.constructors.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_core(name, "is-" + name, *args)
4785 
4786  def __repr__(self):
4787  return "Datatype(%s, %s)" % (self.name, self.constructors)
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.c = c
4809  self.ctx = ctx
4810  def __del__(self):
4811  if self.ctx.ref() is not None:
4812  Z3_del_constructor(self.ctx.ref(), self.c)
4813 
4815  """Auxiliary object used to create Z3 datatypes."""
4816  def __init__(self, c, ctx):
4817  self.c = c
4818  self.ctx = ctx
4819  def __del__(self):
4820  if self.ctx.ref() is not None:
4821  Z3_del_constructor_list(self.ctx.ref(), self.c)
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_ref(), self.ast))
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_constructors(), "Invalid constructor index")
4947  return FuncDeclRef(Z3_get_datatype_sort_constructor(self.ctx_ref(), self.ast, idx), self.ctx)
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_constructors(), "Invalid recognizer index")
4975  return FuncDeclRef(Z3_get_datatype_sort_recognizer(self.ctx_ref(), self.ast, idx), self.ctx)
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_constructors(), "Invalid constructor index")
5003  _z3_assert(j < self.constructor(i).arity(), "Invalid accessor index")
5004  return FuncDeclRef(Z3_get_datatype_sort_constructor_accessor(self.ctx_ref(), self.ast, i, j), self.ctx)
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_ref(), self.as_ast()), self.ctx)
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.ctx = _get_ctx(ctx)
5074  if params is None:
5075  self.params = Z3_mk_params(self.ctx.ref())
5076  else:
5077  self.params = params
5078  Z3_params_inc_ref(self.ctx.ref(), self.params)
5079 
5080  def __deepcopy__(self, memo={}):
5081  return ParamsRef(self.ctx, self.params)
5082 
5083  def __del__(self):
5084  if self.ctx.ref() is not None:
5085  Z3_params_dec_ref(self.ctx.ref(), self.params)
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.ctx)
5092  if isinstance(val, bool):
5093  Z3_params_set_bool(self.ctx.ref(), self.params, name_sym, val)
5094  elif _is_int(val):
5095  Z3_params_set_uint(self.ctx.ref(), self.params, name_sym, val)
5096  elif isinstance(val, float):
5097  Z3_params_set_double(self.ctx.ref(), self.params, name_sym, val)
5098  elif isinstance(val, str):
5099  Z3_params_set_symbol(self.ctx.ref(), self.params, name_sym, to_symbol(val, self.ctx))
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.ctx.ref(), self.params)
5106 
5107  def validate(self, ds):
5108  _z3_assert(isinstance(ds, ParamDescrsRef), "parameter description set expected")
5109  Z3_params_validate(self.ctx.ref(), self.params, 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.ctx = _get_ctx(ctx)
5139  self.descr = descr
5140  Z3_param_descrs_inc_ref(self.ctx.ref(), self.descr)
5141 
5142  def __deepcopy__(self, memo={}):
5143  return ParamsDescrsRef(self.descr, self.ctx)
5144 
5145  def __del__(self):
5146  if self.ctx.ref() is not None:
5147  Z3_param_descrs_dec_ref(self.ctx.ref(), self.descr)
5148 
5149  def size(self):
5150  """Return the size of in the parameter description `self`.
5151  """
5152  return int(Z3_param_descrs_size(self.ctx.ref(), self.descr))
5153 
5154  def __len__(self):
5155  """Return the size of in the parameter description `self`.
5156  """
5157  return self.size()
5158 
5159  def get_name(self, i):
5160  """Return the i-th parameter name in the parameter description `self`.
5161  """
5162  return _symbol2py(self.ctx, Z3_param_descrs_get_name(self.ctx.ref(), self.descr, 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.ctx.ref(), self.descr, to_symbol(n, self.ctx))
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.ctx.ref(), self.descr, to_symbol(n, self.ctx))
5173 
5174  def __getitem__(self, arg):
5175  if _is_int(arg):
5176  return self.get_name(arg)
5177  else:
5178  return self.get_kind(arg)
5179 
5180  def __repr__(self):
5181  return Z3_param_descrs_to_string(self.ctx.ref(), self.descr)
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.ctx = _get_ctx(ctx)
5201  self.goal = goal
5202  if self.goal is None:
5203  self.goal = Z3_mk_goal(self.ctx.ref(), models, unsat_cores, proofs)
5204  Z3_goal_inc_ref(self.ctx.ref(), self.goal)
5205 
5206  def __deepcopy__(self, memo={}):
5207  return Goal(False, False, False, self.ctx, self.goal)
5208 
5209  def __del__(self):
5210  if self.goal is not None and self.ctx.ref() is not None:
5211  Z3_goal_dec_ref(self.ctx.ref(), self.goal)
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.ctx.ref(), self.goal))
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.ctx.ref(), self.goal)
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.ctx.ref(), self.goal)
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.prec()
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.ctx.ref(), self.goal))
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.size()
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.ctx.ref(), self.goal, i), self.ctx)
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.get(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.ctx)
5343  for arg in args:
5344  arg = s.cast(arg)
5345  Z3_goal_assert(self.ctx.ref(), self.goal, 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_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_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_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.ctx.ref(), self.goal, model.model), self.ctx)
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.ctx.ref(), self.goal)
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.ctx.ref(), self.goal, 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.ctx.ref(), self.goal, target.ref()), ctx=target)
5442 
5443  def __copy__(self):
5444  return self.translate(self.ctx)
5445 
5446  def __deepcopy__(self, memo={}):
5447  return self.translate(self.ctx)
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.ctx)
5486  elif sz == 1:
5487  return self.get(0)
5488  else:
5489  return And([ self.get(i) for i in range(len(self)) ], self.ctx)
5490 
5491 
5497  """A collection (vector) of ASTs."""
5498 
5499  def __init__(self, v=None, ctx=None):
5500  self.vector = None
5501  if v is None:
5502  self.ctx = _get_ctx(ctx)
5503  self.vector = Z3_mk_ast_vector(self.ctx.ref())
5504  else:
5505  self.vector = v
5506  assert ctx is not None
5507  self.ctx = ctx
5508  Z3_ast_vector_inc_ref(self.ctx.ref(), self.vector)
5509 
5510  def __deepcopy__(self, memo={}):
5511  return AstVector(self.vector, self.ctx)
5512 
5513  def __del__(self):
5514  if self.vector is not None and self.ctx.ref() is not None:
5515  Z3_ast_vector_dec_ref(self.ctx.ref(), self.vector)
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.ctx.ref(), self.vector))
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__()
5545 
5546  if i >= self.__len__():
5547  raise IndexError
5548  return _to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, i), self.ctx)
5549 
5550  elif isinstance(i, slice):
5551  return [_to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, ii), self.ctx) for ii in range(*i.indices(self.__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__():
5567  raise IndexError
5568  Z3_ast_vector_set(self.ctx.ref(), self.vector, 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.ctx.ref(), self.vector, 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.ctx.ref(), self.vector, 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.ctx.ref(), self.vector, other_ctx.ref()), other_ctx)
5630 
5631  def __copy__(self):
5632  return self.translate(self.ctx)
5633 
5634  def __deepcopy__(self, memo={}):
5635  return self.translate(self.ctx)
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.ctx.ref(), self.vector)
5643 
5644 
5649 class AstMap:
5650  """A mapping from ASTs to ASTs."""
5651 
5652  def __init__(self, m=None, ctx=None):
5653  self.map = None
5654  if m is None:
5655  self.ctx = _get_ctx(ctx)
5656  self.map = Z3_mk_ast_map(self.ctx.ref())
5657  else:
5658  self.map = m
5659  assert ctx is not None
5660  self.ctx = ctx
5661  Z3_ast_map_inc_ref(self.ctx.ref(), self.map)
5662 
5663  def __deepcopy__(self, memo={}):
5664  return AstMap(self.map, self.ctx)
5665 
5666  def __del__(self):
5667  if self.map is not None and self.ctx.ref() is not None:
5668  Z3_ast_map_dec_ref(self.ctx.ref(), self.map)
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.ctx.ref(), self.map))
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.ctx.ref(), self.map, 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.ctx.ref(), self.map, key.as_ast()), self.ctx)
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.ctx.ref(), self.map, k.as_ast(), v.as_ast())
5722 
5723  def __repr__(self):
5724  return Z3_ast_map_to_string(self.ctx.ref(), self.map)
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.ctx.ref(), self.map, 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.ctx.ref(), self.map)
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.ctx.ref(), self.map), self.ctx)
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.entry = entry
5778  self.ctx = ctx
5779  Z3_func_entry_inc_ref(self.ctx.ref(), self.entry)
5780 
5781  def __deepcopy__(self, memo={}):
5782  return FuncEntry(self.entry, self.ctx)
5783 
5784  def __del__(self):
5785  if self.ctx.ref() is not None:
5786  Z3_func_entry_dec_ref(self.ctx.ref(), self.entry)
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.ctx.ref(), self.entry))
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_args():
5834  raise IndexError
5835  return _to_expr_ref(Z3_func_entry_get_arg(self.ctx.ref(), self.entry, idx), self.ctx)
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.ctx.ref(), self.entry), self.ctx)
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_value(i) for i in range(self.num_args())]
5875  args.append(self.value())
5876  return args
5877 
5878  def __repr__(self):
5879  return repr(self.as_list())
5880 
5882  """Stores the interpretation of a function in a Z3 model."""
5883 
5884  def __init__(self, f, ctx):
5885  self.f = f
5886  self.ctx = ctx
5887  if self.f is not None:
5888  Z3_func_interp_inc_ref(self.ctx.ref(), self.f)
5889 
5890  def __deepcopy__(self, memo={}):
5891  return FuncInterp(self.f, self.ctx)
5892 
5893  def __del__(self):
5894  if self.f is not None and self.ctx.ref() is not None:
5895  Z3_func_interp_dec_ref(self.ctx.ref(), self.f)
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.ctx.ref(), self.f)
5915  if r:
5916  return _to_expr_ref(r, self.ctx)
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.ctx.ref(), self.f))
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.ctx.ref(), self.f))
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_entries():
5967  raise IndexError
5968  return FuncEntry(Z3_func_interp_get_entry(self.ctx.ref(), self.f, idx), self.ctx)
5969 
5970  def translate(self, other_ctx):
5971  """Copy model 'self' to context 'other_ctx'.
5972  """
5973  return ModelRef(Z3_model_translate(self.ctx.ref(), self.model, other_ctx.ref()), other_ctx)
5974 
5975  def __copy__(self):
5976  return self.translate(self.ctx)
5977 
5978  def __deepcopy__(self, memo={}):
5979  return self.translate(self.ctx)
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.entry(i).as_list() for i in range(self.num_entries())]
5995  r.append(self.else_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.model = m
6007  self.ctx = ctx
6008  Z3_model_inc_ref(self.ctx.ref(), self.model)
6009 
6010  def __del__(self):
6011  if self.ctx.ref() is not None:
6012  Z3_model_dec_ref(self.ctx.ref(), self.model)
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.ctx.ref(), self.model)
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.ctx.ref(), self.model, t.as_ast(), model_completion, r):
6047  return _to_expr_ref(r[0], self.ctx)
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.eval(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.ctx.ref(), self.model)) + int(Z3_model_get_num_funcs(self.ctx.ref(), self.model))
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.ctx.ref(), self.model, decl.ast)
6113  if _r.value is None:
6114  return None
6115  r = _to_expr_ref(_r, self.ctx)
6116  if is_as_array(r):
6117  return self.get_interp(get_as_array_func(r))
6118  else:
6119  return r
6120  else:
6121  return FuncInterp(Z3_model_get_func_interp(self.ctx.ref(), self.model, decl.ast), self.ctx)
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.ctx.ref(), self.model))
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_sorts():
6160  raise IndexError
6161  return _to_sort_ref(Z3_model_get_sort(self.ctx.ref(), self.model, idx), self.ctx)
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_sort(i) for i in range(self.num_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.ctx.ref(), self.model, s.ast), self.ctx)
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.ctx.ref(), self.model)
6230  if (idx < num_consts):
6231  return FuncDeclRef(Z3_model_get_const_decl(self.ctx.ref(), self.model, idx), self.ctx)
6232  else:
6233  return FuncDeclRef(Z3_model_get_func_decl(self.ctx.ref(), self.model, idx - num_consts), self.ctx)
6234  if isinstance(idx, FuncDeclRef):
6235  return self.get_interp(idx)
6236  if is_const(idx):
6237  return self.get_interp(idx.decl())
6238  if isinstance(idx, SortRef):
6239  return self.get_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.ctx.ref(), self.model)):
6258  r.append(FuncDeclRef(Z3_model_get_const_decl(self.ctx.ref(), self.model, i), self.ctx))
6259  for i in range(Z3_model_get_num_funcs(self.ctx.ref(), self.model)):
6260  r.append(FuncDeclRef(Z3_model_get_func_decl(self.ctx.ref(), self.model, i), self.ctx))
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.ctx.ref(), self.model, target.ref())
6269  return Model(model, target)
6270 
6271  def __copy__(self):
6272  return self.translate(self.ctx)
6273 
6274  def __deepcopy__(self, memo={}):
6275  return self.translate(self.ctx)
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.stats = stats
6301  self.ctx = ctx
6302  Z3_stats_inc_ref(self.ctx.ref(), self.stats)
6303 
6304  def __deepcopy__(self, memo={}):
6305  return Statistics(self.stats, self.ctx)
6306 
6307  def __del__(self):
6308  if self.ctx.ref() is not None:
6309  Z3_stats_dec_ref(self.ctx.ref(), self.stats)
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.ctx.ref(), self.stats)
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.ctx.ref(), self.stats))
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.ctx.ref(), self.stats, idx):
6362  val = int(Z3_stats_get_uint_value(self.ctx.ref(), self.stats, idx))
6363  else:
6364  val = Z3_stats_get_double_value(self.ctx.ref(), self.stats, idx)
6365  return (Z3_stats_get_key(self.ctx.ref(), self.stats, 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.ctx.ref(), self.stats, 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.ctx.ref(), self.stats, idx):
6393  if Z3_stats_is_uint(self.ctx.ref(), self.stats, idx):
6394  return int(Z3_stats_get_uint_value(self.ctx.ref(), self.stats, idx))
6395  else:
6396  return Z3_stats_get_double_value(self.ctx.ref(), self.stats, 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_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.r = r
6440 
6441  def __deepcopy__(self, memo={}):
6442  return CheckSatResult(self.r)
6443 
6444  def __eq__(self, other):
6445  return isinstance(other, CheckSatResult) and self.r == other.r
6446 
6447  def __ne__(self, other):
6448  return not self.__eq__(other)
6449 
6450  def __repr__(self):
6451  if in_html_mode():
6452  if self.r == Z3_L_TRUE:
6453  return "<b>sat</b>"
6454  elif self.r == Z3_L_FALSE:
6455  return "<b>unsat</b>"
6456  else:
6457  return "<b>unknown</b>"
6458  else:
6459  if self.r == Z3_L_TRUE:
6460  return "sat"
6461  elif self.r == 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.ctx = _get_ctx(ctx)
6483  self.backtrack_level = 4000000000
6484  self.solver = None
6485  if solver is None:
6486  self.solver = Z3_mk_solver(self.ctx.ref())
6487  else:
6488  self.solver = solver
6489  Z3_solver_inc_ref(self.ctx.ref(), self.solver)
6490  if logFile is not None:
6491  self.set("smtlib2_log", logFile)
6492 
6493  def __del__(self):
6494  if self.solver is not None and self.ctx.ref() is not None:
6495  Z3_solver_dec_ref(self.ctx.ref(), self.solver)
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.ctx)
6507  Z3_solver_set_params(self.ctx.ref(), self.solver, 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.ctx.ref(), self.solver)
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.ctx.ref(), self.solver, 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.ctx.ref(), self.solver)
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.ctx.ref(), self.solver)
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.ctx)
6596  for arg in args:
6597  if isinstance(arg, Goal) or isinstance(arg, AstVector):
6598  for f in arg:
6599  Z3_solver_assert(self.ctx.ref(), self.solver, f.as_ast())
6600  else:
6601  arg = s.cast(arg)
6602  Z3_solver_assert(self.ctx.ref(), self.solver, 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_exprs(*args)
6614 
6615  def __iadd__(self, fml):
6616  self.add(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_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_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.ctx)
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.ctx.ref(), self.solver, 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.ctx)
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.ctx.ref(), self.solver, 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.ctx.ref(), self.solver), self.ctx)
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.ctx.ref(), other.solver, self.solver)
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.ctx.ref(), self.solver), self.ctx)
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.ctx)
6767  for a in assumptions:
6768  _asms.push(a)
6769  assumptions = _asms
6770  if isinstance(variables, list):
6771  _vars = AstVector(None, self.ctx)
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.ctx)
6778  r = Z3_solver_get_consequences(self.ctx.ref(), self.solver, 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.ctx.ref(), self.solver, filename)
6786 
6787  def from_string(self, s):
6788  """Parse assertions from a string"""
6789  Z3_solver_from_string(self.ctx.ref(), self.solver, 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_vs = AstVector(None, self.ctx)
6799  if vars is not None:
6800  for v in vars:
6801  self.cube_vs.push(v)
6802  while True:
6803  lvl = self.backtrack_level
6804  self.backtrack_level = 4000000000
6805  r = AstVector(Z3_solver_cube(self.ctx.ref(), self.solver, self.cube_vs.vector, lvl), self.ctx)
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_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.ctx.ref(), self.solver), self.ctx)
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.ctx.ref(), self.solver), self.ctx)
6836 
6837  def units(self):
6838  """Return an AST vector containing all currently inferred units.
6839  """
6840  return AstVector(Z3_solver_get_units(self.ctx.ref(), self.solver), self.ctx)
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.ctx.ref(), self.solver), self.ctx)
6846 
6847  def trail_levels(self):
6848  """Return trail and decision levels of the solver state after a check() call.
6849  """
6850  trail = self.trail()
6851  levels = (ctypes.c_uint * len(trail))()
6852  Z3_solver_get_levels(self.ctx.ref(), self.solver, 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.ctx.ref(), self.solver), self.ctx)
6859 
6860  def value(self, e):
6861  """Return value of term in solver, if any is given.
6862  """
6863  return _to_expr_ref(Z3_solver_get_implied_value(self.ctx.ref(), self.solver, e.as_ast()), self.ctx)
6864 
6865  def lower(self, e):
6866  """Return lower bound known to solver based on the last call.
6867  """
6868  return _to_expr_ref(Z3_solver_get_implied_lower(self.ctx.ref(), self.solver, e.as_ast()), self.ctx)
6869 
6870  def upper(self, e):
6871  """Return upper bound known to solver based on the last call.
6872  """
6873  return _to_expr_ref(Z3_solver_get_implied_upper(self.ctx.ref(), self.solver, e.as_ast()), self.ctx)
6874 
6875  def statistics(self):
6876  """Return statistics for the last `check()`.
6877 
6878  >>> s = SimpleSolver()
6879  >>> x = Int('x')
6880  >>> s.add(x > 0)
6881  >>> s.check()
6882  sat
6883  >>> st = s.statistics()
6884  >>> st.get_key_value('final checks')
6885  1
6886  >>> len(st) > 0
6887  True
6888  >>> st[0] != 0
6889  True
6890  """
6891  return Statistics(Z3_solver_get_statistics(self.ctx.ref(), self.solver), self.ctx)
6892 
6893  def reason_unknown(self):
6894  """Return a string describing why the last `check()` returned `unknown`.
6895 
6896  >>> x = Int('x')
6897  >>> s = SimpleSolver()
6898  >>> s.add(2**x == 4)
6899  >>> s.check()
6900  unknown
6901  >>> s.reason_unknown()
6902  '(incomplete (theory arithmetic))'
6903  """
6904  return Z3_solver_get_reason_unknown(self.ctx.ref(), self.solver)
6905 
6906  def help(self):
6907  """Display a string describing all available options."""
6908  print(Z3_solver_get_help(self.ctx.ref(), self.solver))
6909 
6910  def param_descrs(self):
6911  """Return the parameter description set."""
6912  return ParamDescrsRef(Z3_solver_get_param_descrs(self.ctx.ref(), self.solver), self.ctx)
6913 
6914  def __repr__(self):
6915  """Return a formatted string with all added constraints."""
6916  return obj_to_string(self)
6917 
6918  def translate(self, target):
6919  """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
6920 
6921  >>> c1 = Context()
6922  >>> c2 = Context()
6923  >>> s1 = Solver(ctx=c1)
6924  >>> s2 = s1.translate(c2)
6925  """
6926  if z3_debug():
6927  _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
6928  solver = Z3_solver_translate(self.ctx.ref(), self.solver, target.ref())
6929  return Solver(solver, target)
6930 
6931  def __copy__(self):
6932  return self.translate(self.ctx)
6933 
6934  def __deepcopy__(self, memo={}):
6935  return self.translate(self.ctx)
6936 
6937  def sexpr(self):
6938  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
6939 
6940  >>> x = Int('x')
6941  >>> s = Solver()
6942  >>> s.add(x > 0)
6943  >>> s.add(x < 2)
6944  >>> r = s.sexpr()
6945  """
6946  return Z3_solver_to_string(self.ctx.ref(), self.solver)
6947 
6948  def dimacs(self, include_names=True):
6949  """Return a textual representation of the solver in DIMACS format."""
6950  return Z3_solver_to_dimacs_string(self.ctx.ref(), self.solver, include_names)
6951 
6952  def to_smt2(self):
6953  """return SMTLIB2 formatted benchmark for solver's assertions"""
6954  es = self.assertions()
6955  sz = len(es)
6956  sz1 = sz
6957  if sz1 > 0:
6958  sz1 -= 1
6959  v = (Ast * sz1)()
6960  for i in range(sz1):
6961  v[i] = es[i].as_ast()
6962  if sz > 0:
6963  e = es[sz1].as_ast()
6964  else:
6965  e = BoolVal(True, self.ctx).as_ast()
6966  return Z3_benchmark_to_smtlib_string(self.ctx.ref(), "benchmark generated from python API", "", "unknown", "", sz1, v, e)
6967 
6968 def SolverFor(logic, ctx=None, logFile=None):
6969  """Create a solver customized for the given logic.
6970 
6971  The parameter `logic` is a string. It should be contains
6972  the name of a SMT-LIB logic.
6973  See http://www.smtlib.org/ for the name of all available logics.
6974 
6975  >>> s = SolverFor("QF_LIA")
6976  >>> x = Int('x')
6977  >>> s.add(x > 0)
6978  >>> s.add(x < 2)
6979  >>> s.check()
6980  sat
6981  >>> s.model()
6982  [x = 1]
6983  """
6984  ctx = _get_ctx(ctx)
6985  logic = to_symbol(logic)
6986  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6987 
6988 def SimpleSolver(ctx=None, logFile=None):
6989  """Return a simple general purpose solver with limited amount of preprocessing.
6990 
6991  >>> s = SimpleSolver()
6992  >>> x = Int('x')
6993  >>> s.add(x > 0)
6994  >>> s.check()
6995  sat
6996  """
6997  ctx = _get_ctx(ctx)
6998  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6999 
7000 
7005 
7007  """Fixedpoint API provides methods for solving with recursive predicates"""
7008 
7009  def __init__(self, fixedpoint=None, ctx=None):
7010  assert fixedpoint is None or ctx is not None
7011  self.ctx = _get_ctx(ctx)
7012  self.fixedpoint = None
7013  if fixedpoint is None:
7014  self.fixedpoint = Z3_mk_fixedpoint(self.ctx.ref())
7015  else:
7016  self.fixedpoint = fixedpoint
7017  Z3_fixedpoint_inc_ref(self.ctx.ref(), self.fixedpoint)
7018  self.vars = []
7019 
7020  def __deepcopy__(self, memo={}):
7021  return FixedPoint(self.fixedpoint, self.ctx)
7022 
7023  def __del__(self):
7024  if self.fixedpoint is not None and self.ctx.ref() is not None:
7025  Z3_fixedpoint_dec_ref(self.ctx.ref(), self.fixedpoint)
7026 
7027  def set(self, *args, **keys):
7028  """Set a configuration option. The method `help()` return a string containing all available options.
7029  """
7030  p = args2params(args, keys, self.ctx)
7031  Z3_fixedpoint_set_params(self.ctx.ref(), self.fixedpoint, p.params)
7032 
7033  def help(self):
7034  """Display a string describing all available options."""
7035  print(Z3_fixedpoint_get_help(self.ctx.ref(), self.fixedpoint))
7036 
7037  def param_descrs(self):
7038  """Return the parameter description set."""
7039  return ParamDescrsRef(Z3_fixedpoint_get_param_descrs(self.ctx.ref(), self.fixedpoint), self.ctx)
7040 
7041  def assert_exprs(self, *args):
7042  """Assert constraints as background axioms for the fixedpoint solver."""
7043  args = _get_args(args)
7044  s = BoolSort(self.ctx)
7045  for arg in args:
7046  if isinstance(arg, Goal) or isinstance(arg, AstVector):
7047  for f in arg:
7048  f = self.abstract(f)
7049  Z3_fixedpoint_assert(self.ctx.ref(), self.fixedpoint, f.as_ast())
7050  else:
7051  arg = s.cast(arg)
7052  arg = self.abstract(arg)
7053  Z3_fixedpoint_assert(self.ctx.ref(), self.fixedpoint, arg.as_ast())
7054 
7055  def add(self, *args):
7056  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7057  self.assert_exprs(*args)
7058 
7059  def __iadd__(self, fml):
7060  self.add(fml)
7061  return self
7062 
7063  def append(self, *args):
7064  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7065  self.assert_exprs(*args)
7066 
7067  def insert(self, *args):
7068  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7069  self.assert_exprs(*args)
7070 
7071  def add_rule(self, head, body = None, name = None):
7072  """Assert rules defining recursive predicates to the fixedpoint solver.
7073  >>> a = Bool('a')
7074  >>> b = Bool('b')
7075  >>> s = Fixedpoint()
7076  >>> s.register_relation(a.decl())
7077  >>> s.register_relation(b.decl())
7078  >>> s.fact(a)
7079  >>> s.rule(b, a)
7080  >>> s.query(b)
7081  sat
7082  """
7083  if name is None:
7084  name = ""
7085  name = to_symbol(name, self.ctx)
7086  if body is None:
7087  head = self.abstract(head)
7088  Z3_fixedpoint_add_rule(self.ctx.ref(), self.fixedpoint, head.as_ast(), name)
7089  else:
7090  body = _get_args(body)
7091  f = self.abstract(Implies(And(body, self.ctx),head))
7092  Z3_fixedpoint_add_rule(self.ctx.ref(), self.fixedpoint, f.as_ast(), name)
7093 
7094  def rule(self, head, body = None, name = None):
7095  """Assert rules defining recursive predicates to the fixedpoint solver. Alias for add_rule."""
7096  self.add_rule(head, body, name)
7097 
7098  def fact(self, head, name = None):
7099  """Assert facts defining recursive predicates to the fixedpoint solver. Alias for add_rule."""
7100  self.add_rule(head, None, name)
7101 
7102  def query(self, *query):
7103  """Query the fixedpoint engine whether formula is derivable.
7104  You can also pass an tuple or list of recursive predicates.
7105  """
7106  query = _get_args(query)
7107  sz = len(query)
7108  if sz >= 1 and isinstance(query[0], FuncDeclRef):
7109  _decls = (FuncDecl * sz)()
7110  i = 0
7111  for q in query:
7112  _decls[i] = q.ast
7113  i = i + 1
7114  r = Z3_fixedpoint_query_relations(self.ctx.ref(), self.fixedpoint, sz, _decls)
7115  else:
7116  if sz == 1:
7117  query = query[0]
7118  else:
7119  query = And(query, self.ctx)
7120  query = self.abstract(query, False)
7121  r = Z3_fixedpoint_query(self.ctx.ref(), self.fixedpoint, query.as_ast())
7122  return CheckSatResult(r)
7123 
7124  def query_from_lvl (self, lvl, *query):
7125  """Query the fixedpoint engine whether formula is derivable starting at the given query level.
7126  """
7127  query = _get_args(query)
7128  sz = len(query)
7129  if sz >= 1 and isinstance(query[0], FuncDecl):
7130  _z3_assert (False, "unsupported")
7131  else:
7132  if sz == 1:
7133  query = query[0]
7134  else:
7135  query = And(query)
7136  query = self.abstract(query, False)
7137  r = Z3_fixedpoint_query_from_lvl (self.ctx.ref(), self.fixedpoint, query.as_ast(), lvl)
7138  return CheckSatResult(r)
7139 
7140  def update_rule(self, head, body, name):
7141  """update rule"""
7142  if name is None:
7143  name = ""
7144  name = to_symbol(name, self.ctx)
7145  body = _get_args(body)
7146  f = self.abstract(Implies(And(body, self.ctx),head))
7147  Z3_fixedpoint_update_rule(self.ctx.ref(), self.fixedpoint, f.as_ast(), name)
7148 
7149  def get_answer(self):
7150  """Retrieve answer from last query call."""
7151  r = Z3_fixedpoint_get_answer(self.ctx.ref(), self.fixedpoint)
7152  return _to_expr_ref(r, self.ctx)
7153 
7155  """Retrieve a ground cex from last query call."""
7156  r = Z3_fixedpoint_get_ground_sat_answer(self.ctx.ref(), self.fixedpoint)
7157  return _to_expr_ref(r, self.ctx)
7158 
7160  """retrieve rules along the counterexample trace"""
7161  return AstVector(Z3_fixedpoint_get_rules_along_trace(self.ctx.ref(), self.fixedpoint), self.ctx)
7162 
7164  """retrieve rule names along the counterexample trace"""
7165  # this is a hack as I don't know how to return a list of symbols from C++;
7166  # obtain names as a single string separated by semicolons
7167  names = _symbol2py (self.ctx, Z3_fixedpoint_get_rule_names_along_trace(self.ctx.ref(), self.fixedpoint))
7168  # split into individual names
7169  return names.split (';')
7170 
7171  def get_num_levels(self, predicate):
7172  """Retrieve number of levels used for predicate in PDR engine"""
7173  return Z3_fixedpoint_get_num_levels(self.ctx.ref(), self.fixedpoint, predicate.ast)
7174 
7175  def get_cover_delta(self, level, predicate):
7176  """Retrieve properties known about predicate for the level'th unfolding. -1 is treated as the limit (infinity)"""
7177  r = Z3_fixedpoint_get_cover_delta(self.ctx.ref(), self.fixedpoint, level, predicate.ast)
7178  return _to_expr_ref(r, self.ctx)
7179 
7180  def add_cover(self, level, predicate, property):
7181  """Add property to predicate for the level'th unfolding. -1 is treated as infinity (infinity)"""
7182  Z3_fixedpoint_add_cover(self.ctx.ref(), self.fixedpoint, level, predicate.ast, property.ast)
7183 
7184  def register_relation(self, *relations):
7185  """Register relation as recursive"""
7186  relations = _get_args(relations)
7187  for f in relations:
7188  Z3_fixedpoint_register_relation(self.ctx.ref(), self.fixedpoint, f.ast)
7189 
7190  def set_predicate_representation(self, f, *representations):
7191  """Control how relation is represented"""
7192  representations = _get_args(representations)
7193  representations = [to_symbol(s) for s in representations]
7194  sz = len(representations)
7195  args = (Symbol * sz)()
7196  for i in range(sz):
7197  args[i] = representations[i]
7198  Z3_fixedpoint_set_predicate_representation(self.ctx.ref(), self.fixedpoint, f.ast, sz, args)
7199 
7200  def parse_string(self, s):
7201  """Parse rules and queries from a string"""
7202  return AstVector(Z3_fixedpoint_from_string(self.ctx.ref(), self.fixedpoint, s), self.ctx)
7203 
7204  def parse_file(self, f):
7205  """Parse rules and queries from a file"""
7206  return AstVector(Z3_fixedpoint_from_file(self.ctx.ref(), self.fixedpoint, f), self.ctx)
7207 
7208  def get_rules(self):
7209  """retrieve rules that have been added to fixedpoint context"""
7210  return AstVector(Z3_fixedpoint_get_rules(self.ctx.ref(), self.fixedpoint), self.ctx)
7211 
7212  def get_assertions(self):
7213  """retrieve assertions that have been added to fixedpoint context"""
7214  return AstVector(Z3_fixedpoint_get_assertions(self.ctx.ref(), self.fixedpoint), self.ctx)
7215 
7216  def __repr__(self):
7217  """Return a formatted string with all added rules and constraints."""
7218  return self.sexpr()
7219 
7220  def sexpr(self):
7221  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
7222  """
7223  return Z3_fixedpoint_to_string(self.ctx.ref(), self.fixedpoint, 0, (Ast * 0)())
7224 
7225  def to_string(self, queries):
7226  """Return a formatted string (in Lisp-like format) with all added constraints.
7227  We say the string is in s-expression format.
7228  Include also queries.
7229  """
7230  args, len = _to_ast_array(queries)
7231  return Z3_fixedpoint_to_string(self.ctx.ref(), self.fixedpoint, len, args)
7232 
7233  def statistics(self):
7234  """Return statistics for the last `query()`.
7235  """
7236  return Statistics(Z3_fixedpoint_get_statistics(self.ctx.ref(), self.fixedpoint), self.ctx)
7237 
7238  def reason_unknown(self):
7239  """Return a string describing why the last `query()` returned `unknown`.
7240  """
7241  return Z3_fixedpoint_get_reason_unknown(self.ctx.ref(), self.fixedpoint)
7242 
7243  def declare_var(self, *vars):
7244  """Add variable or several variables.
7245  The added variable or variables will be bound in the rules
7246  and queries
7247  """
7248  vars = _get_args(vars)
7249  for v in vars:
7250  self.vars += [v]
7251 
7252  def abstract(self, fml, is_forall=True):
7253  if self.vars == []:
7254  return fml
7255  if is_forall:
7256  return ForAll(self.vars, fml)
7257  else:
7258  return Exists(self.vars, fml)
7259 
7260 
7261 
7266 
7268  """Finite domain sort."""
7269 
7270  def size(self):
7271  """Return the size of the finite domain sort"""
7272  r = (ctypes.c_ulonglong * 1)()
7273  if Z3_get_finite_domain_sort_size(self.ctx_ref(), self.ast, r):
7274  return r[0]
7275  else:
7276  raise Z3Exception("Failed to retrieve finite domain sort size")
7277 
7278 def FiniteDomainSort(name, sz, ctx=None):
7279  """Create a named finite domain sort of a given size sz"""
7280  if not isinstance(name, Symbol):
7281  name = to_symbol(name)
7282  ctx = _get_ctx(ctx)
7283  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7284 
7286  """Return True if `s` is a Z3 finite-domain sort.
7287 
7288  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7289  True
7290  >>> is_finite_domain_sort(IntSort())
7291  False
7292  """
7293  return isinstance(s, FiniteDomainSortRef)
7294 
7295 
7297  """Finite-domain expressions."""
7298 
7299  def sort(self):
7300  """Return the sort of the finite-domain expression `self`."""
7301  return FiniteDomainSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
7302 
7303  def as_string(self):
7304  """Return a Z3 floating point expression as a Python string."""
7305  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
7306 
7308  """Return `True` if `a` is a Z3 finite-domain expression.
7309 
7310  >>> s = FiniteDomainSort('S', 100)
7311  >>> b = Const('b', s)
7312  >>> is_finite_domain(b)
7313  True
7314  >>> is_finite_domain(Int('x'))
7315  False
7316  """
7317  return isinstance(a, FiniteDomainRef)
7318 
7319 
7321  """Integer values."""
7322 
7323  def as_long(self):
7324  """Return a Z3 finite-domain numeral as a Python long (bignum) numeral.
7325 
7326  >>> s = FiniteDomainSort('S', 100)
7327  >>> v = FiniteDomainVal(3, s)
7328  >>> v
7329  3
7330  >>> v.as_long() + 1
7331  4
7332  """
7333  return int(self.as_string())
7334 
7335  def as_string(self):
7336  """Return a Z3 finite-domain numeral as a Python string.
7337 
7338  >>> s = FiniteDomainSort('S', 100)
7339  >>> v = FiniteDomainVal(42, s)
7340  >>> v.as_string()
7341  '42'
7342  """
7343  return Z3_get_numeral_string(self.ctx_ref(), self.as_ast())
7344 
7345 
7346 def FiniteDomainVal(val, sort, ctx=None):
7347  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7348 
7349  >>> s = FiniteDomainSort('S', 256)
7350  >>> FiniteDomainVal(255, s)
7351  255
7352  >>> FiniteDomainVal('100', s)
7353  100
7354  """
7355  if z3_debug():
7356  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7357  ctx = sort.ctx
7358  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7359 
7361  """Return `True` if `a` is a Z3 finite-domain value.
7362 
7363  >>> s = FiniteDomainSort('S', 100)
7364  >>> b = Const('b', s)
7365  >>> is_finite_domain_value(b)
7366  False
7367  >>> b = FiniteDomainVal(10, s)
7368  >>> b
7369  10
7370  >>> is_finite_domain_value(b)
7371  True
7372  """
7373  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7374 
7375 
7376 
7381 
7383  def __init__(self, opt, value, is_max):
7384  self._opt = opt
7385  self._value = value
7386  self._is_max = is_max
7387 
7388  def lower(self):
7389  opt = self._opt
7390  return _to_expr_ref(Z3_optimize_get_lower(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7391 
7392  def upper(self):
7393  opt = self._opt
7394  return _to_expr_ref(Z3_optimize_get_upper(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7395 
7396  def lower_values(self):
7397  opt = self._opt
7398  return AstVector(Z3_optimize_get_lower_as_vector(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7399 
7400  def upper_values(self):
7401  opt = self._opt
7402  return AstVector(Z3_optimize_get_upper_as_vector(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7403 
7404  def value(self):
7405  if self._is_max:
7406  return self.upper()
7407  else:
7408  return self.lower()
7409 
7410  def __str__(self):
7411  return "%s:%s" % (self._value, self._is_max)
7412 
7413 
7415  """Optimize API provides methods for solving using objective functions and weighted soft constraints"""
7416 
7417  def __init__(self, ctx=None):
7418  self.ctx = _get_ctx(ctx)
7419  self.optimize = Z3_mk_optimize(self.ctx.ref())
7420  Z3_optimize_inc_ref(self.ctx.ref(), self.optimize)
7421 
7422  def __deepcopy__(self, memo={}):
7423  return Optimize(self.optimize, self.ctx)
7424 
7425  def __del__(self):
7426  if self.optimize is not None and self.ctx.ref() is not None:
7427  Z3_optimize_dec_ref(self.ctx.ref(), self.optimize)
7428 
7429  def set(self, *args, **keys):
7430  """Set a configuration option. The method `help()` return a string containing all available options.
7431  """
7432  p = args2params(args, keys, self.ctx)
7433  Z3_optimize_set_params(self.ctx.ref(), self.optimize, p.params)
7434 
7435  def help(self):
7436  """Display a string describing all available options."""
7437  print(Z3_optimize_get_help(self.ctx.ref(), self.optimize))
7438 
7439  def param_descrs(self):
7440  """Return the parameter description set."""
7441  return ParamDescrsRef(Z3_optimize_get_param_descrs(self.ctx.ref(), self.optimize), self.ctx)
7442 
7443  def assert_exprs(self, *args):
7444  """Assert constraints as background axioms for the optimize solver."""
7445  args = _get_args(args)
7446  s = BoolSort(self.ctx)
7447  for arg in args:
7448  if isinstance(arg, Goal) or isinstance(arg, AstVector):
7449  for f in arg:
7450  Z3_optimize_assert(self.ctx.ref(), self.optimize, f.as_ast())
7451  else:
7452  arg = s.cast(arg)
7453  Z3_optimize_assert(self.ctx.ref(), self.optimize, arg.as_ast())
7454 
7455  def add(self, *args):
7456  """Assert constraints as background axioms for the optimize solver. Alias for assert_expr."""
7457  self.assert_exprs(*args)
7458 
7459  def __iadd__(self, fml):
7460  self.add(fml)
7461  return self
7462 
7463  def assert_and_track(self, a, p):
7464  """Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.
7465 
7466  If `p` is a string, it will be automatically converted into a Boolean constant.
7467 
7468  >>> x = Int('x')
7469  >>> p3 = Bool('p3')
7470  >>> s = Optimize()
7471  >>> s.assert_and_track(x > 0, 'p1')
7472  >>> s.assert_and_track(x != 1, 'p2')
7473  >>> s.assert_and_track(x < 0, p3)
7474  >>> print(s.check())
7475  unsat
7476  >>> c = s.unsat_core()
7477  >>> len(c)
7478  2
7479  >>> Bool('p1') in c
7480  True
7481  >>> Bool('p2') in c
7482  False
7483  >>> p3 in c
7484  True
7485  """
7486  if isinstance(p, str):
7487  p = Bool(p, self.ctx)
7488  _z3_assert(isinstance(a, BoolRef), "Boolean expression expected")
7489  _z3_assert(isinstance(p, BoolRef) and is_const(p), "Boolean expression expected")
7490  Z3_optimize_assert_and_track(self.ctx.ref(), self.optimize, a.as_ast(), p.as_ast())
7491 
7492  def add_soft(self, arg, weight = "1", id = None):
7493  """Add soft constraint with optional weight and optional identifier.
7494  If no weight is supplied, then the penalty for violating the soft constraint
7495  is 1.
7496  Soft constraints are grouped by identifiers. Soft constraints that are
7497  added without identifiers are grouped by default.
7498  """
7499  if _is_int(weight):
7500  weight = "%d" % weight
7501  elif isinstance(weight, float):
7502  weight = "%f" % weight
7503  if not isinstance(weight, str):
7504  raise Z3Exception("weight should be a string or an integer")
7505  if id is None:
7506  id = ""
7507  id = to_symbol(id, self.ctx)
7508  v = Z3_optimize_assert_soft(self.ctx.ref(), self.optimize, arg.as_ast(), weight, id)
7509  return OptimizeObjective(self, v, False)
7510 
7511  def maximize(self, arg):
7512  """Add objective function to maximize."""
7513  return OptimizeObjective(self, Z3_optimize_maximize(self.ctx.ref(), self.optimize, arg.as_ast()), True)
7514 
7515  def minimize(self, arg):
7516  """Add objective function to minimize."""
7517  return OptimizeObjective(self, Z3_optimize_minimize(self.ctx.ref(), self.optimize, arg.as_ast()), False)
7518 
7519  def push(self):
7520  """create a backtracking point for added rules, facts and assertions"""
7521  Z3_optimize_push(self.ctx.ref(), self.optimize)
7522 
7523  def pop(self):
7524  """restore to previously created backtracking point"""
7525  Z3_optimize_pop(self.ctx.ref(), self.optimize)
7526 
7527  def check(self, *assumptions):
7528  """Check satisfiability while optimizing objective functions."""
7529  assumptions = _get_args(assumptions)
7530  num = len(assumptions)
7531  _assumptions = (Ast * num)()
7532  for i in range(num):
7533  _assumptions[i] = assumptions[i].as_ast()
7534  return CheckSatResult(Z3_optimize_check(self.ctx.ref(), self.optimize, num, _assumptions))
7535 
7536  def reason_unknown(self):
7537  """Return a string that describes why the last `check()` returned `unknown`."""
7538  return Z3_optimize_get_reason_unknown(self.ctx.ref(), self.optimize)
7539 
7540  def model(self):
7541  """Return a model for the last check()."""
7542  try:
7543  return ModelRef(Z3_optimize_get_model(self.ctx.ref(), self.optimize), self.ctx)
7544  except Z3Exception:
7545  raise Z3Exception("model is not available")
7546 
7547  def unsat_core(self):
7548  return AstVector(Z3_optimize_get_unsat_core(self.ctx.ref(), self.optimize), self.ctx)
7549 
7550  def lower(self, obj):
7551  if not isinstance(obj, OptimizeObjective):
7552  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7553  return obj.lower()
7554 
7555  def upper(self, obj):
7556  if not isinstance(obj, OptimizeObjective):
7557  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7558  return obj.upper()
7559 
7560  def lower_values(self, obj):
7561  if not isinstance(obj, OptimizeObjective):
7562  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7563  return obj.lower_values()
7564 
7565  def upper_values(self, obj):
7566  if not isinstance(obj, OptimizeObjective):
7567  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7568  return obj.upper_values()
7569 
7570  def from_file(self, filename):
7571  """Parse assertions and objectives from a file"""
7572  Z3_optimize_from_file(self.ctx.ref(), self.optimize, filename)
7573 
7574  def from_string(self, s):
7575  """Parse assertions and objectives from a string"""
7576  Z3_optimize_from_string(self.ctx.ref(), self.optimize, s)
7577 
7578  def assertions(self):
7579  """Return an AST vector containing all added constraints."""
7580  return AstVector(Z3_optimize_get_assertions(self.ctx.ref(), self.optimize), self.ctx)
7581 
7582  def objectives(self):
7583  """returns set of objective functions"""
7584  return AstVector(Z3_optimize_get_objectives(self.ctx.ref(), self.optimize), self.ctx)
7585 
7586  def __repr__(self):
7587  """Return a formatted string with all added rules and constraints."""
7588  return self.sexpr()
7589 
7590  def sexpr(self):
7591  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
7592  """
7593  return Z3_optimize_to_string(self.ctx.ref(), self.optimize)
7594 
7595  def statistics(self):
7596  """Return statistics for the last check`.
7597  """
7598  return Statistics(Z3_optimize_get_statistics(self.ctx.ref(), self.optimize), self.ctx)
7599 
7600 
7601 
7602 
7603 
7609  """An ApplyResult object contains the subgoals produced by a tactic when applied to a goal. It also contains model and proof converters."""
7610 
7611  def __init__(self, result, ctx):
7612  self.result = result
7613  self.ctx = ctx
7614  Z3_apply_result_inc_ref(self.ctx.ref(), self.result)
7615 
7616  def __deepcopy__(self, memo={}):
7617  return ApplyResult(self.result, self.ctx)
7618 
7619  def __del__(self):
7620  if self.ctx.ref() is not None:
7621  Z3_apply_result_dec_ref(self.ctx.ref(), self.result)
7622 
7623  def __len__(self):
7624  """Return the number of subgoals in `self`.
7625 
7626  >>> a, b = Ints('a b')
7627  >>> g = Goal()
7628  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
7629  >>> t = Tactic('split-clause')
7630  >>> r = t(g)
7631  >>> len(r)
7632  2
7633  >>> t = Then(Tactic('split-clause'), Tactic('split-clause'))
7634  >>> len(t(g))
7635  4
7636  >>> t = Then(Tactic('split-clause'), Tactic('split-clause'), Tactic('propagate-values'))
7637  >>> len(t(g))
7638  1
7639  """
7640  return int(Z3_apply_result_get_num_subgoals(self.ctx.ref(), self.result))
7641 
7642  def __getitem__(self, idx):
7643  """Return one of the subgoals stored in ApplyResult object `self`.
7644 
7645  >>> a, b = Ints('a b')
7646  >>> g = Goal()
7647  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
7648  >>> t = Tactic('split-clause')
7649  >>> r = t(g)
7650  >>> r[0]
7651  [a == 0, Or(b == 0, b == 1), a > b]
7652  >>> r[1]
7653  [a == 1, Or(b == 0, b == 1), a > b]
7654  """
7655  if idx >= len(self):
7656  raise IndexError
7657  return Goal(goal=Z3_apply_result_get_subgoal(self.ctx.ref(), self.result, idx), ctx=self.ctx)
7658 
7659  def __repr__(self):
7660  return obj_to_string(self)
7661 
7662  def sexpr(self):
7663  """Return a textual representation of the s-expression representing the set of subgoals in `self`."""
7664  return Z3_apply_result_to_string(self.ctx.ref(), self.result)
7665 
7666 
7667  def as_expr(self):
7668  """Return a Z3 expression consisting of all subgoals.
7669 
7670  >>> x = Int('x')
7671  >>> g = Goal()
7672  >>> g.add(x > 1)
7673  >>> g.add(Or(x == 2, x == 3))
7674  >>> r = Tactic('simplify')(g)
7675  >>> r
7676  [[Not(x <= 1), Or(x == 2, x == 3)]]
7677  >>> r.as_expr()
7678  And(Not(x <= 1), Or(x == 2, x == 3))
7679  >>> r = Tactic('split-clause')(g)
7680  >>> r
7681  [[x > 1, x == 2], [x > 1, x == 3]]
7682  >>> r.as_expr()
7683  Or(And(x > 1, x == 2), And(x > 1, x == 3))
7684  """
7685  sz = len(self)
7686  if sz == 0:
7687  return BoolVal(False, self.ctx)
7688  elif sz == 1:
7689  return self[0].as_expr()
7690  else:
7691  return Or([ self[i].as_expr() for i in range(len(self)) ])
7692 
7693 
7698 class Tactic:
7699  """Tactics transform, solver and/or simplify sets of constraints (Goal). A Tactic can be converted into a Solver using the method solver().
7700 
7701  Several combinators are available for creating new tactics using the built-in ones: Then(), OrElse(), FailIf(), Repeat(), When(), Cond().
7702  """
7703  def __init__(self, tactic, ctx=None):
7704  self.ctx = _get_ctx(ctx)
7705  self.tactic = None
7706  if isinstance(tactic, TacticObj):
7707  self.tactic = tactic
7708  else:
7709  if z3_debug():
7710  _z3_assert(isinstance(tactic, str), "tactic name expected")
7711  try:
7712  self.tactic = Z3_mk_tactic(self.ctx.ref(), str(tactic))
7713  except Z3Exception:
7714  raise Z3Exception("unknown tactic '%s'" % tactic)
7715  Z3_tactic_inc_ref(self.ctx.ref(), self.tactic)
7716 
7717  def __deepcopy__(self, memo={}):
7718  return Tactic(self.tactic, self.ctx)
7719 
7720  def __del__(self):
7721  if self.tactic is not None and self.ctx.ref() is not None:
7722  Z3_tactic_dec_ref(self.ctx.ref(), self.tactic)
7723 
7724  def solver(self, logFile=None):
7725  """Create a solver using the tactic `self`.
7726 
7727  The solver supports the methods `push()` and `pop()`, but it
7728  will always solve each `check()` from scratch.
7729 
7730  >>> t = Then('simplify', 'nlsat')
7731  >>> s = t.solver()
7732  >>> x = Real('x')
7733  >>> s.add(x**2 == 2, x > 0)
7734  >>> s.check()
7735  sat
7736  >>> s.model()
7737  [x = 1.4142135623?]
7738  """
7739  return Solver(Z3_mk_solver_from_tactic(self.ctx.ref(), self.tactic), self.ctx, logFile)
7740 
7741  def apply(self, goal, *arguments, **keywords):
7742  """Apply tactic `self` to the given goal or Z3 Boolean expression using the given options.
7743 
7744  >>> x, y = Ints('x y')
7745  >>> t = Tactic('solve-eqs')
7746  >>> t.apply(And(x == 0, y >= x + 1))
7747  [[y >= 1]]
7748  """
7749  if z3_debug():
7750  _z3_assert(isinstance(goal, Goal) or isinstance(goal, BoolRef), "Z3 Goal or Boolean expressions expected")
7751  goal = _to_goal(goal)
7752  if len(arguments) > 0 or len(keywords) > 0:
7753  p = args2params(arguments, keywords, self.ctx)
7754  return ApplyResult(Z3_tactic_apply_ex(self.ctx.ref(), self.tactic, goal.goal, p.params), self.ctx)
7755  else:
7756  return ApplyResult(Z3_tactic_apply(self.ctx.ref(), self.tactic, goal.goal), self.ctx)
7757 
7758  def __call__(self, goal, *arguments, **keywords):
7759  """Apply tactic `self` to the given goal or Z3 Boolean expression using the given options.
7760 
7761  >>> x, y = Ints('x y')
7762  >>> t = Tactic('solve-eqs')
7763  >>> t(And(x == 0, y >= x + 1))
7764  [[y >= 1]]
7765  """
7766  return self.apply(goal, *arguments, **keywords)
7767 
7768  def help(self):
7769  """Display a string containing a description of the available options for the `self` tactic."""
7770  print(Z3_tactic_get_help(self.ctx.ref(), self.tactic))
7771 
7772  def param_descrs(self):
7773  """Return the parameter description set."""
7774  return ParamDescrsRef(Z3_tactic_get_param_descrs(self.ctx.ref(), self.tactic), self.ctx)
7775 
7776 def _to_goal(a):
7777  if isinstance(a, BoolRef):
7778  goal = Goal(ctx = a.ctx)
7779  goal.add(a)
7780  return goal
7781  else:
7782  return a
7783 
7784 def _to_tactic(t, ctx=None):
7785  if isinstance(t, Tactic):
7786  return t
7787  else:
7788  return Tactic(t, ctx)
7789 
7790 def _and_then(t1, t2, ctx=None):
7791  t1 = _to_tactic(t1, ctx)
7792  t2 = _to_tactic(t2, ctx)
7793  if z3_debug():
7794  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7795  return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7796 
7797 def _or_else(t1, t2, ctx=None):
7798  t1 = _to_tactic(t1, ctx)
7799  t2 = _to_tactic(t2, ctx)
7800  if z3_debug():
7801  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7802  return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7803 
7804 def AndThen(*ts, **ks):
7805  """Return a tactic that applies the tactics in `*ts` in sequence.
7806 
7807  >>> x, y = Ints('x y')
7808  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7809  >>> t(And(x == 0, y > x + 1))
7810  [[Not(y <= 1)]]
7811  >>> t(And(x == 0, y > x + 1)).as_expr()
7812  Not(y <= 1)
7813  """
7814  if z3_debug():
7815  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7816  ctx = ks.get('ctx', None)
7817  num = len(ts)
7818  r = ts[0]
7819  for i in range(num - 1):
7820  r = _and_then(r, ts[i+1], ctx)
7821  return r
7822 
7823 def Then(*ts, **ks):
7824  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7825 
7826  >>> x, y = Ints('x y')
7827  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7828  >>> t(And(x == 0, y > x + 1))
7829  [[Not(y <= 1)]]
7830  >>> t(And(x == 0, y > x + 1)).as_expr()
7831  Not(y <= 1)
7832  """
7833  return AndThen(*ts, **ks)
7834 
7835 def OrElse(*ts, **ks):
7836  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7837 
7838  >>> x = Int('x')
7839  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7840  >>> # Tactic split-clause fails if there is no clause in the given goal.
7841  >>> t(x == 0)
7842  [[x == 0]]
7843  >>> t(Or(x == 0, x == 1))
7844  [[x == 0], [x == 1]]
7845  """
7846  if z3_debug():
7847  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7848  ctx = ks.get('ctx', None)
7849  num = len(ts)
7850  r = ts[0]
7851  for i in range(num - 1):
7852  r = _or_else(r, ts[i+1], ctx)
7853  return r
7854 
7855 def ParOr(*ts, **ks):
7856  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7857 
7858  >>> x = Int('x')
7859  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7860  >>> t(x + 1 == 2)
7861  [[x == 1]]
7862  """
7863  if z3_debug():
7864  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7865  ctx = _get_ctx(ks.get('ctx', None))
7866  ts = [ _to_tactic(t, ctx) for t in ts ]
7867  sz = len(ts)
7868  _args = (TacticObj * sz)()
7869  for i in range(sz):
7870  _args[i] = ts[i].tactic
7871  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7872 
7873 def ParThen(t1, t2, ctx=None):
7874  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7875 
7876  >>> x, y = Ints('x y')
7877  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7878  >>> t(And(Or(x == 1, x == 2), y == x + 1))
7879  [[x == 1, y == 2], [x == 2, y == 3]]
7880  """
7881  t1 = _to_tactic(t1, ctx)
7882  t2 = _to_tactic(t2, ctx)
7883  if z3_debug():
7884  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7885  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7886 
7887 def ParAndThen(t1, t2, ctx=None):
7888  """Alias for ParThen(t1, t2, ctx)."""
7889  return ParThen(t1, t2, ctx)
7890 
7891 def With(t, *args, **keys):
7892  """Return a tactic that applies tactic `t` using the given configuration options.
7893 
7894  >>> x, y = Ints('x y')
7895  >>> t = With(Tactic('simplify'), som=True)
7896  >>> t((x + 1)*(y + 2) == 0)
7897  [[2*x + y + x*y == -2]]
7898  """
7899  ctx = keys.pop('ctx', None)
7900  t = _to_tactic(t, ctx)
7901  p = args2params(args, keys, t.ctx)
7902  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7903 
7904 def WithParams(t, p):
7905  """Return a tactic that applies tactic `t` using the given configuration options.
7906 
7907  >>> x, y = Ints('x y')
7908  >>> p = ParamsRef()
7909  >>> p.set("som", True)
7910  >>> t = WithParams(Tactic('simplify'), p)
7911  >>> t((x + 1)*(y + 2) == 0)
7912  [[2*x + y + x*y == -2]]
7913  """
7914  t = _to_tactic(t, None)
7915  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7916 
7917 def Repeat(t, max=4294967295, ctx=None):
7918  """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7919 
7920  >>> x, y = Ints('x y')
7921  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7922  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7923  >>> r = t(c)
7924  >>> for subgoal in r: print(subgoal)
7925  [x == 0, y == 0, x > y]
7926  [x == 0, y == 1, x > y]
7927  [x == 1, y == 0, x > y]
7928  [x == 1, y == 1, x > y]
7929  >>> t = Then(t, Tactic('propagate-values'))
7930  >>> t(c)
7931  [[x == 1, y == 0]]
7932  """
7933  t = _to_tactic(t, ctx)
7934  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7935 
7936 def TryFor(t, ms, ctx=None):
7937  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7938 
7939  If `t` does not terminate in `ms` milliseconds, then it fails.
7940  """
7941  t = _to_tactic(t, ctx)
7942  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7943 
7944 def tactics(ctx=None):
7945  """Return a list of all available tactics in Z3.
7946 
7947  >>> l = tactics()
7948  >>> l.count('simplify') == 1
7949  True
7950  """
7951  ctx = _get_ctx(ctx)
7952  return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7953 
7954 def tactic_description(name, ctx=None):
7955  """Return a short description for the tactic named `name`.
7956 
7957  >>> d = tactic_description('simplify')
7958  """
7959  ctx = _get_ctx(ctx)
7960  return Z3_tactic_get_descr(ctx.ref(), name)
7961 
7963  """Display a (tabular) description of all available tactics in Z3."""
7964  if in_html_mode():
7965  even = True
7966  print('<table border="1" cellpadding="2" cellspacing="0">')
7967  for t in tactics():
7968  if even:
7969  print('<tr style="background-color:#CFCFCF">')
7970  even = False
7971  else:
7972  print('<tr>')
7973  even = True
7974  print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7975  print('</table>')
7976  else:
7977  for t in tactics():
7978  print('%s : %s' % (t, tactic_description(t)))
7979 
7980 class Probe:
7981  """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."""
7982  def __init__(self, probe, ctx=None):
7983  self.ctx = _get_ctx(ctx)
7984  self.probe = None
7985  if isinstance(probe, ProbeObj):
7986  self.probe = probe
7987  elif isinstance(probe, float):
7988  self.probe = Z3_probe_const(self.ctx.ref(), probe)
7989  elif _is_int(probe):
7990  self.probe = Z3_probe_const(self.ctx.ref(), float(probe))
7991  elif isinstance(probe, bool):
7992  if probe:
7993  self.probe = Z3_probe_const(self.ctx.ref(), 1.0)
7994  else:
7995  self.probe = Z3_probe_const(self.ctx.ref(), 0.0)
7996  else:
7997  if z3_debug():
7998  _z3_assert(isinstance(probe, str), "probe name expected")
7999  try:
8000  self.probe = Z3_mk_probe(self.ctx.ref(), probe)
8001  except Z3Exception:
8002  raise Z3Exception("unknown probe '%s'" % probe)
8003  Z3_probe_inc_ref(self.ctx.ref(), self.probe)
8004 
8005  def __deepcopy__(self, memo={}):
8006  return Probe(self.probe, self.ctx)
8007 
8008  def __del__(self):
8009  if self.probe is not None and self.ctx.ref() is not None:
8010  Z3_probe_dec_ref(self.ctx.ref(), self.probe)
8011 
8012  def __lt__(self, other):
8013  """Return a probe that evaluates to "true" when the value returned by `self` is less than the value returned by `other`.
8014 
8015  >>> p = Probe('size') < 10
8016  >>> x = Int('x')
8017  >>> g = Goal()
8018  >>> g.add(x > 0)
8019  >>> g.add(x < 10)
8020  >>> p(g)
8021  1.0
8022  """
8023  return Probe(Z3_probe_lt(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8024 
8025  def __gt__(self, other):
8026  """Return a probe that evaluates to "true" when the value returned by `self` is greater than the value returned by `other`.
8027 
8028  >>> p = Probe('size') > 10
8029  >>> x = Int('x')
8030  >>> g = Goal()
8031  >>> g.add(x > 0)
8032  >>> g.add(x < 10)
8033  >>> p(g)
8034  0.0
8035  """
8036  return Probe(Z3_probe_gt(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8037 
8038  def __le__(self, other):
8039  """Return a probe that evaluates to "true" when the value returned by `self` is less than or equal to the value returned by `other`.
8040 
8041  >>> p = Probe('size') <= 2
8042  >>> x = Int('x')
8043  >>> g = Goal()
8044  >>> g.add(x > 0)
8045  >>> g.add(x < 10)
8046  >>> p(g)
8047  1.0
8048  """
8049  return Probe(Z3_probe_le(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8050 
8051  def __ge__(self, other):
8052  """Return a probe that evaluates to "true" when the value returned by `self` is greater than or equal to the value returned by `other`.
8053 
8054  >>> p = Probe('size') >= 2
8055  >>> x = Int('x')
8056  >>> g = Goal()
8057  >>> g.add(x > 0)
8058  >>> g.add(x < 10)
8059  >>> p(g)
8060  1.0
8061  """
8062  return Probe(Z3_probe_ge(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8063 
8064  def __eq__(self, other):
8065  """Return a probe that evaluates to "true" when the value returned by `self` is equal to the value returned by `other`.
8066 
8067  >>> p = Probe('size') == 2
8068  >>> x = Int('x')
8069  >>> g = Goal()
8070  >>> g.add(x > 0)
8071  >>> g.add(x < 10)
8072  >>> p(g)
8073  1.0
8074  """
8075  return Probe(Z3_probe_eq(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8076 
8077  def __ne__(self, other):
8078  """Return a probe that evaluates to "true" when the value returned by `self` is not equal to the value returned by `other`.
8079 
8080  >>> p = Probe('size') != 2
8081  >>> x = Int('x')
8082  >>> g = Goal()
8083  >>> g.add(x > 0)
8084  >>> g.add(x < 10)
8085  >>> p(g)
8086  0.0
8087  """
8088  p = self.__eq__(other)
8089  return Probe(Z3_probe_not(self.ctx.ref(), p.probe), self.ctx)
8090 
8091  def __call__(self, goal):
8092  """Evaluate the probe `self` in the given goal.
8093 
8094  >>> p = Probe('size')
8095  >>> x = Int('x')
8096  >>> g = Goal()
8097  >>> g.add(x > 0)
8098  >>> g.add(x < 10)
8099  >>> p(g)
8100  2.0
8101  >>> g.add(x < 20)
8102  >>> p(g)
8103  3.0
8104  >>> p = Probe('num-consts')
8105  >>> p(g)
8106  1.0
8107  >>> p = Probe('is-propositional')
8108  >>> p(g)
8109  0.0
8110  >>> p = Probe('is-qflia')
8111  >>> p(g)
8112  1.0
8113  """
8114  if z3_debug():
8115  _z3_assert(isinstance(goal, Goal) or isinstance(goal, BoolRef), "Z3 Goal or Boolean expression expected")
8116  goal = _to_goal(goal)
8117  return Z3_probe_apply(self.ctx.ref(), self.probe, goal.goal)
8118 
8119 def is_probe(p):
8120  """Return `True` if `p` is a Z3 probe.
8121 
8122  >>> is_probe(Int('x'))
8123  False
8124  >>> is_probe(Probe('memory'))
8125  True
8126  """
8127  return isinstance(p, Probe)
8128 
8129 def _to_probe(p, ctx=None):
8130  if is_probe(p):
8131  return p
8132  else:
8133  return Probe(p, ctx)
8134 
8135 def probes(ctx=None):
8136  """Return a list of all available probes in Z3.
8137 
8138  >>> l = probes()
8139  >>> l.count('memory') == 1
8140  True
8141  """
8142  ctx = _get_ctx(ctx)
8143  return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8144 
8145 def probe_description(name, ctx=None):
8146  """Return a short description for the probe named `name`.
8147 
8148  >>> d = probe_description('memory')
8149  """
8150  ctx = _get_ctx(ctx)
8151  return Z3_probe_get_descr(ctx.ref(), name)
8152 
8154  """Display a (tabular) description of all available probes in Z3."""
8155  if in_html_mode():
8156  even = True
8157  print('<table border="1" cellpadding="2" cellspacing="0">')
8158  for p in probes():
8159  if even:
8160  print('<tr style="background-color:#CFCFCF">')
8161  even = False
8162  else:
8163  print('<tr>')
8164  even = True
8165  print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8166  print('</table>')
8167  else:
8168  for p in probes():
8169  print('%s : %s' % (p, probe_description(p)))
8170 
8171 def _probe_nary(f, args, ctx):
8172  if z3_debug():
8173  _z3_assert(len(args) > 0, "At least one argument expected")
8174  num = len(args)
8175  r = _to_probe(args[0], ctx)
8176  for i in range(num - 1):
8177  r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i+1], ctx).probe), ctx)
8178  return r
8179 
8180 def _probe_and(args, ctx):
8181  return _probe_nary(Z3_probe_and, args, ctx)
8182 
8183 def _probe_or(args, ctx):
8184  return _probe_nary(Z3_probe_or, args, ctx)
8185 
8186 def FailIf(p, ctx=None):
8187  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8188 
8189  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8190 
8191  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8192  >>> x, y = Ints('x y')
8193  >>> g = Goal()
8194  >>> g.add(x > 0)
8195  >>> g.add(y > 0)
8196  >>> t(g)
8197  [[x > 0, y > 0]]
8198  >>> g.add(x == y + 1)
8199  >>> t(g)
8200  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8201  """
8202  p = _to_probe(p, ctx)
8203  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8204 
8205 def When(p, t, ctx=None):
8206  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8207 
8208  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8209  >>> x, y = Ints('x y')
8210  >>> g = Goal()
8211  >>> g.add(x > 0)
8212  >>> g.add(y > 0)
8213  >>> t(g)
8214  [[x > 0, y > 0]]
8215  >>> g.add(x == y + 1)
8216  >>> t(g)
8217  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8218  """
8219  p = _to_probe(p, ctx)
8220  t = _to_tactic(t, ctx)
8221  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8222 
8223 def Cond(p, t1, t2, ctx=None):
8224  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8225 
8226  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8227  """
8228  p = _to_probe(p, ctx)
8229  t1 = _to_tactic(t1, ctx)
8230  t2 = _to_tactic(t2, ctx)
8231  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8232 
8233 
8238 
8239 def simplify(a, *arguments, **keywords):
8240  """Simplify the expression `a` using the given options.
8241 
8242  This function has many options. Use `help_simplify` to obtain the complete list.
8243 
8244  >>> x = Int('x')
8245  >>> y = Int('y')
8246  >>> simplify(x + 1 + y + x + 1)
8247  2 + 2*x + y
8248  >>> simplify((x + 1)*(y + 1), som=True)
8249  1 + x + y + x*y
8250  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8251  And(Not(x == y), Not(x == 1), Not(y == 1))
8252  >>> simplify(And(x == 0, y == 1), elim_and=True)
8253  Not(Or(Not(x == 0), Not(y == 1)))
8254  """
8255  if z3_debug():
8256  _z3_assert(is_expr(a), "Z3 expression expected")
8257  if len(arguments) > 0 or len(keywords) > 0:
8258  p = args2params(arguments, keywords, a.ctx)
8259  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8260  else:
8261  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8262 
8264  """Return a string describing all options available for Z3 `simplify` procedure."""
8265  print(Z3_simplify_get_help(main_ctx().ref()))
8266 
8268  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8270 
8271 def substitute(t, *m):
8272  """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.
8273 
8274  >>> x = Int('x')
8275  >>> y = Int('y')
8276  >>> substitute(x + 1, (x, y + 1))
8277  y + 1 + 1
8278  >>> f = Function('f', IntSort(), IntSort())
8279  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8280  1 + 1
8281  """
8282  if isinstance(m, tuple):
8283  m1 = _get_args(m)
8284  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8285  m = m1
8286  if z3_debug():
8287  _z3_assert(is_expr(t), "Z3 expression expected")
8288  _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.")
8289  num = len(m)
8290  _from = (Ast * num)()
8291  _to = (Ast * num)()
8292  for i in range(num):
8293  _from[i] = m[i][0].as_ast()
8294  _to[i] = m[i][1].as_ast()
8295  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8296 
8297 def substitute_vars(t, *m):
8298  """Substitute the free variables in t with the expression in m.
8299 
8300  >>> v0 = Var(0, IntSort())
8301  >>> v1 = Var(1, IntSort())
8302  >>> x = Int('x')
8303  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8304  >>> # replace v0 with x+1 and v1 with x
8305  >>> substitute_vars(f(v0, v1), x + 1, x)
8306  f(x + 1, x)
8307  """
8308  if z3_debug():
8309  _z3_assert(is_expr(t), "Z3 expression expected")
8310  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8311  num = len(m)
8312  _to = (Ast * num)()
8313  for i in range(num):
8314  _to[i] = m[i].as_ast()
8315  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8316 
8317 def Sum(*args):
8318  """Create the sum of the Z3 expressions.
8319 
8320  >>> a, b, c = Ints('a b c')
8321  >>> Sum(a, b, c)
8322  a + b + c
8323  >>> Sum([a, b, c])
8324  a + b + c
8325  >>> A = IntVector('a', 5)
8326  >>> Sum(A)
8327  a__0 + a__1 + a__2 + a__3 + a__4
8328  """
8329  args = _get_args(args)
8330  if len(args) == 0:
8331  return 0
8332  ctx = _ctx_from_ast_arg_list(args)
8333  if ctx is None:
8334  return _reduce(lambda a, b: a + b, args, 0)
8335  args = _coerce_expr_list(args, ctx)
8336  if is_bv(args[0]):
8337  return _reduce(lambda a, b: a + b, args, 0)
8338  else:
8339  _args, sz = _to_ast_array(args)
8340  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8341 
8342 
8343 def Product(*args):
8344  """Create the product of the Z3 expressions.
8345 
8346  >>> a, b, c = Ints('a b c')
8347  >>> Product(a, b, c)
8348  a*b*c
8349  >>> Product([a, b, c])
8350  a*b*c
8351  >>> A = IntVector('a', 5)
8352  >>> Product(A)
8353  a__0*a__1*a__2*a__3*a__4
8354  """
8355  args = _get_args(args)
8356  if len(args) == 0:
8357  return 1
8358  ctx = _ctx_from_ast_arg_list(args)
8359  if ctx is None:
8360  return _reduce(lambda a, b: a * b, args, 1)
8361  args = _coerce_expr_list(args, ctx)
8362  if is_bv(args[0]):
8363  return _reduce(lambda a, b: a * b, args, 1)
8364  else:
8365  _args, sz = _to_ast_array(args)
8366  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8367 
8368 def AtMost(*args):
8369  """Create an at-most Pseudo-Boolean k constraint.
8370 
8371  >>> a, b, c = Bools('a b c')
8372  >>> f = AtMost(a, b, c, 2)
8373  """
8374  args = _get_args(args)
8375  if z3_debug():
8376  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8377  ctx = _ctx_from_ast_arg_list(args)
8378  if z3_debug():
8379  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8380  args1 = _coerce_expr_list(args[:-1], ctx)
8381  k = args[-1]
8382  _args, sz = _to_ast_array(args1)
8383  return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
8384 
8385 def AtLeast(*args):
8386  """Create an at-most Pseudo-Boolean k constraint.
8387 
8388  >>> a, b, c = Bools('a b c')
8389  >>> f = AtLeast(a, b, c, 2)
8390  """
8391  args = _get_args(args)
8392  if z3_debug():
8393  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8394  ctx = _ctx_from_ast_arg_list(args)
8395  if z3_debug():
8396  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8397  args1 = _coerce_expr_list(args[:-1], ctx)
8398  k = args[-1]
8399  _args, sz = _to_ast_array(args1)
8400  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8401 
8402 def _reorder_pb_arg(arg):
8403  a, b = arg
8404  if not _is_int(b) and _is_int(a):
8405  return b, a
8406  return arg
8407 
8408 def _pb_args_coeffs(args, default_ctx = None):
8409  args = _get_args_ast_list(args)
8410  if len(args) == 0:
8411  return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
8412  args = [_reorder_pb_arg(arg) for arg in args]
8413  args, coeffs = zip(*args)
8414  if z3_debug():
8415  _z3_assert(len(args) > 0, "Non empty list of arguments expected")
8416  ctx = _ctx_from_ast_arg_list(args)
8417  if z3_debug():
8418  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8419  args = _coerce_expr_list(args, ctx)
8420  _args, sz = _to_ast_array(args)
8421  _coeffs = (ctypes.c_int * len(coeffs))()
8422  for i in range(len(coeffs)):
8423  _z3_check_cint_overflow(coeffs[i], "coefficient")
8424  _coeffs[i] = coeffs[i]
8425  return ctx, sz, _args, _coeffs
8426 
8427 def PbLe(args, k):
8428  """Create a Pseudo-Boolean inequality k constraint.
8429 
8430  >>> a, b, c = Bools('a b c')
8431  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
8432  """
8433  _z3_check_cint_overflow(k, "k")
8434  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8435  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
8436 
8437 def PbGe(args, k):
8438  """Create a Pseudo-Boolean inequality k constraint.
8439 
8440  >>> a, b, c = Bools('a b c')
8441  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8442  """
8443  _z3_check_cint_overflow(k, "k")
8444  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8445  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8446 
8447 def PbEq(args, k, ctx = None):
8448  """Create a Pseudo-Boolean inequality k constraint.
8449 
8450  >>> a, b, c = Bools('a b c')
8451  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8452  """
8453  _z3_check_cint_overflow(k, "k")
8454  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8455  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8456 
8457 
8458 def solve(*args, **keywords):
8459  """Solve the constraints `*args`.
8460 
8461  This is a simple function for creating demonstrations. It creates a solver,
8462  configure it using the options in `keywords`, adds the constraints
8463  in `args`, and invokes check.
8464 
8465  >>> a = Int('a')
8466  >>> solve(a > 0, a < 2)
8467  [a = 1]
8468  """
8469  s = Solver()
8470  s.set(**keywords)
8471  s.add(*args)
8472  if keywords.get('show', False):
8473  print(s)
8474  r = s.check()
8475  if r == unsat:
8476  print("no solution")
8477  elif r == unknown:
8478  print("failed to solve")
8479  try:
8480  print(s.model())
8481  except Z3Exception:
8482  return
8483  else:
8484  print(s.model())
8485 
8486 def solve_using(s, *args, **keywords):
8487  """Solve the constraints `*args` using solver `s`.
8488 
8489  This is a simple function for creating demonstrations. It is similar to `solve`,
8490  but it uses the given solver `s`.
8491  It configures solver `s` using the options in `keywords`, adds the constraints
8492  in `args`, and invokes check.
8493  """
8494  if z3_debug():
8495  _z3_assert(isinstance(s, Solver), "Solver object expected")
8496  s.set(**keywords)
8497  s.add(*args)
8498  if keywords.get('show', False):
8499  print("Problem:")
8500  print(s)
8501  r = s.check()
8502  if r == unsat:
8503  print("no solution")
8504  elif r == unknown:
8505  print("failed to solve")
8506  try:
8507  print(s.model())
8508  except Z3Exception:
8509  return
8510  else:
8511  if keywords.get('show', False):
8512  print("Solution:")
8513  print(s.model())
8514 
8515 def prove(claim, **keywords):
8516  """Try to prove the given claim.
8517 
8518  This is a simple function for creating demonstrations. It tries to prove
8519  `claim` by showing the negation is unsatisfiable.
8520 
8521  >>> p, q = Bools('p q')
8522  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8523  proved
8524  """
8525  if z3_debug():
8526  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8527  s = Solver()
8528  s.set(**keywords)
8529  s.add(Not(claim))
8530  if keywords.get('show', False):
8531  print(s)
8532  r = s.check()
8533  if r == unsat:
8534  print("proved")
8535  elif r == unknown:
8536  print("failed to prove")
8537  print(s.model())
8538  else:
8539  print("counterexample")
8540  print(s.model())
8541 
8542 def _solve_html(*args, **keywords):
8543  """Version of function `solve` used in RiSE4Fun."""
8544  s = Solver()
8545  s.set(**keywords)
8546  s.add(*args)
8547  if keywords.get('show', False):
8548  print("<b>Problem:</b>")
8549  print(s)
8550  r = s.check()
8551  if r == unsat:
8552  print("<b>no solution</b>")
8553  elif r == unknown:
8554  print("<b>failed to solve</b>")
8555  try:
8556  print(s.model())
8557  except Z3Exception:
8558  return
8559  else:
8560  if keywords.get('show', False):
8561  print("<b>Solution:</b>")
8562  print(s.model())
8563 
8564 def _solve_using_html(s, *args, **keywords):
8565  """Version of function `solve_using` used in RiSE4Fun."""
8566  if z3_debug():
8567  _z3_assert(isinstance(s, Solver), "Solver object expected")
8568  s.set(**keywords)
8569  s.add(*args)
8570  if keywords.get('show', False):
8571  print("<b>Problem:</b>")
8572  print(s)
8573  r = s.check()
8574  if r == unsat:
8575  print("<b>no solution</b>")
8576  elif r == unknown:
8577  print("<b>failed to solve</b>")
8578  try:
8579  print(s.model())
8580  except Z3Exception:
8581  return
8582  else:
8583  if keywords.get('show', False):
8584  print("<b>Solution:</b>")
8585  print(s.model())
8586 
8587 def _prove_html(claim, **keywords):
8588  """Version of function `prove` used in RiSE4Fun."""
8589  if z3_debug():
8590  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8591  s = Solver()
8592  s.set(**keywords)
8593  s.add(Not(claim))
8594  if keywords.get('show', False):
8595  print(s)
8596  r = s.check()
8597  if r == unsat:
8598  print("<b>proved</b>")
8599  elif r == unknown:
8600  print("<b>failed to prove</b>")
8601  print(s.model())
8602  else:
8603  print("<b>counterexample</b>")
8604  print(s.model())
8605 
8606 def _dict2sarray(sorts, ctx):
8607  sz = len(sorts)
8608  _names = (Symbol * sz)()
8609  _sorts = (Sort * sz) ()
8610  i = 0
8611  for k in sorts:
8612  v = sorts[k]
8613  if z3_debug():
8614  _z3_assert(isinstance(k, str), "String expected")
8615  _z3_assert(is_sort(v), "Z3 sort expected")
8616  _names[i] = to_symbol(k, ctx)
8617  _sorts[i] = v.ast
8618  i = i + 1
8619  return sz, _names, _sorts
8620 
8621 def _dict2darray(decls, ctx):
8622  sz = len(decls)
8623  _names = (Symbol * sz)()
8624  _decls = (FuncDecl * sz) ()
8625  i = 0
8626  for k in decls:
8627  v = decls[k]
8628  if z3_debug():
8629  _z3_assert(isinstance(k, str), "String expected")
8630  _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
8631  _names[i] = to_symbol(k, ctx)
8632  if is_const(v):
8633  _decls[i] = v.decl().ast
8634  else:
8635  _decls[i] = v.ast
8636  i = i + 1
8637  return sz, _names, _decls
8638 
8639 
8640 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8641  """Parse a string in SMT 2.0 format using the given sorts and decls.
8642 
8643  The arguments sorts and decls are Python dictionaries used to initialize
8644  the symbol table used for the SMT 2.0 parser.
8645 
8646  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8647  [x > 0, x < 10]
8648  >>> x, y = Ints('x y')
8649  >>> f = Function('f', IntSort(), IntSort())
8650  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8651  [x + f(y) > 0]
8652  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8653  [a > 0]
8654  """
8655  ctx = _get_ctx(ctx)
8656  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8657  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8658  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8659 
8660 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8661  """Parse a file in SMT 2.0 format using the given sorts and decls.
8662 
8663  This function is similar to parse_smt2_string().
8664  """
8665  ctx = _get_ctx(ctx)
8666  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8667  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8668  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8669 
8670 
8671 
8676 
8677 
8678 # Global default rounding mode
8679 _dflt_rounding_mode = Z3_OP_FPA_RM_TOWARD_ZERO
8680 _dflt_fpsort_ebits = 11
8681 _dflt_fpsort_sbits = 53
8682 
8684  """Retrieves the global default rounding mode."""
8685  global _dflt_rounding_mode
8686  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8687  return RTZ(ctx)
8688  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8689  return RTN(ctx)
8690  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8691  return RTP(ctx)
8692  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8693  return RNE(ctx)
8694  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8695  return RNA(ctx)
8696 
8697 def set_default_rounding_mode(rm, ctx=None):
8698  global _dflt_rounding_mode
8699  if is_fprm_value(rm):
8700  _dflt_rounding_mode = rm.decl().kind()
8701  else:
8702  _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8703  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8704  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8705  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8706  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8707  "illegal rounding mode")
8708  _dflt_rounding_mode = rm
8709 
8710 def get_default_fp_sort(ctx=None):
8711  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8712 
8713 def set_default_fp_sort(ebits, sbits, ctx=None):
8714  global _dflt_fpsort_ebits
8715  global _dflt_fpsort_sbits
8716  _dflt_fpsort_ebits = ebits
8717  _dflt_fpsort_sbits = sbits
8718 
8719 def _dflt_rm(ctx=None):
8720  return get_default_rounding_mode(ctx)
8721 
8722 def _dflt_fps(ctx=None):
8723  return get_default_fp_sort(ctx)
8724 
8725 def _coerce_fp_expr_list(alist, ctx):
8726  first_fp_sort = None
8727  for a in alist:
8728  if is_fp(a):
8729  if first_fp_sort is None:
8730  first_fp_sort = a.sort()
8731  elif first_fp_sort == a.sort():
8732  pass # OK, same as before
8733  else:
8734  # we saw at least 2 different float sorts; something will
8735  # throw a sort mismatch later, for now assume None.
8736  first_fp_sort = None
8737  break
8738 
8739  r = []
8740  for i in range(len(alist)):
8741  a = alist[i]
8742  if (isinstance(a, str) and a.contains('2**(') and a.endswith(')')) or _is_int(a) or isinstance(a, float) or isinstance(a, bool):
8743  r.append(FPVal(a, None, first_fp_sort, ctx))
8744  else:
8745  r.append(a)
8746  return _coerce_expr_list(r, ctx)
8747 
8748 
8749 
8750 
8752  """Floating-point sort."""
8753 
8754  def ebits(self):
8755  """Retrieves the number of bits reserved for the exponent in the FloatingPoint sort `self`.
8756  >>> b = FPSort(8, 24)
8757  >>> b.ebits()
8758  8
8759  """
8760  return int(Z3_fpa_get_ebits(self.ctx_ref(), self.ast))
8761 
8762  def sbits(self):
8763  """Retrieves the number of bits reserved for the significand in the FloatingPoint sort `self`.
8764  >>> b = FPSort(8, 24)
8765  >>> b.sbits()
8766  24
8767  """
8768  return int(Z3_fpa_get_sbits(self.ctx_ref(), self.ast))
8769 
8770  def cast(self, val):
8771  """Try to cast `val` as a floating-point expression.
8772  >>> b = FPSort(8, 24)
8773  >>> b.cast(1.0)
8774  1
8775  >>> b.cast(1.0).sexpr()
8776  '(fp #b0 #x7f #b00000000000000000000000)'
8777  """
8778  if is_expr(val):
8779  if z3_debug():
8780  _z3_assert(self.ctx == val.ctx, "Context mismatch")
8781  return val
8782  else:
8783  return FPVal(val, None, self, self.ctx)
8784 
8785 
8786 def Float16(ctx=None):
8787  """Floating-point 16-bit (half) sort."""
8788  ctx = _get_ctx(ctx)
8789  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8790 
8791 def FloatHalf(ctx=None):
8792  """Floating-point 16-bit (half) sort."""
8793  ctx = _get_ctx(ctx)
8794  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8795 
8796 def Float32(ctx=None):
8797  """Floating-point 32-bit (single) sort."""
8798  ctx = _get_ctx(ctx)
8799  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8800 
8801 def FloatSingle(ctx=None):
8802  """Floating-point 32-bit (single) sort."""
8803  ctx = _get_ctx(ctx)
8804  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8805 
8806 def Float64(ctx=None):
8807  """Floating-point 64-bit (double) sort."""
8808  ctx = _get_ctx(ctx)
8809  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8810 
8811 def FloatDouble(ctx=None):
8812  """Floating-point 64-bit (double) sort."""
8813  ctx = _get_ctx(ctx)
8814  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8815 
8816 def Float128(ctx=None):
8817  """Floating-point 128-bit (quadruple) sort."""
8818  ctx = _get_ctx(ctx)
8819  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8820 
8821 def FloatQuadruple(ctx=None):
8822  """Floating-point 128-bit (quadruple) sort."""
8823  ctx = _get_ctx(ctx)
8824  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8825 
8827  """"Floating-point rounding mode sort."""
8828 
8829 
8830 def is_fp_sort(s):
8831  """Return True if `s` is a Z3 floating-point sort.
8832 
8833  >>> is_fp_sort(FPSort(8, 24))
8834  True
8835  >>> is_fp_sort(IntSort())
8836  False
8837  """
8838  return isinstance(s, FPSortRef)
8839 
8841  """Return True if `s` is a Z3 floating-point rounding mode sort.
8842 
8843  >>> is_fprm_sort(FPSort(8, 24))
8844  False
8845  >>> is_fprm_sort(RNE().sort())
8846  True
8847  """
8848  return isinstance(s, FPRMSortRef)
8849 
8850 
8851 
8853  """Floating-point expressions."""
8854 
8855  def sort(self):
8856  """Return the sort of the floating-point expression `self`.
8857 
8858  >>> x = FP('1.0', FPSort(8, 24))
8859  >>> x.sort()
8860  FPSort(8, 24)
8861  >>> x.sort() == FPSort(8, 24)
8862  True
8863  """
8864  return FPSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
8865 
8866  def ebits(self):
8867  """Retrieves the number of bits reserved for the exponent in the FloatingPoint expression `self`.
8868  >>> b = FPSort(8, 24)
8869  >>> b.ebits()
8870  8
8871  """
8872  return self.sort().ebits();
8873 
8874  def sbits(self):
8875  """Retrieves the number of bits reserved for the exponent in the FloatingPoint expression `self`.
8876  >>> b = FPSort(8, 24)
8877  >>> b.sbits()
8878  24
8879  """
8880  return self.sort().sbits();
8881 
8882  def as_string(self):
8883  """Return a Z3 floating point expression as a Python string."""
8884  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
8885 
8886  def __le__(self, other):
8887  return fpLEQ(self, other, self.ctx)
8888 
8889  def __lt__(self, other):
8890  return fpLT(self, other, self.ctx)
8891 
8892  def __ge__(self, other):
8893  return fpGEQ(self, other, self.ctx)
8894 
8895  def __gt__(self, other):
8896  return fpGT(self, other, self.ctx)
8897 
8898  def __add__(self, other):
8899  """Create the Z3 expression `self + other`.
8900 
8901  >>> x = FP('x', FPSort(8, 24))
8902  >>> y = FP('y', FPSort(8, 24))
8903  >>> x + y
8904  x + y
8905  >>> (x + y).sort()
8906  FPSort(8, 24)
8907  """
8908  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8909  return fpAdd(_dflt_rm(), a, b, self.ctx)
8910 
8911  def __radd__(self, other):
8912  """Create the Z3 expression `other + self`.
8913 
8914  >>> x = FP('x', FPSort(8, 24))
8915  >>> 10 + x
8916  1.25*(2**3) + x
8917  """
8918  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8919  return fpAdd(_dflt_rm(), a, b, self.ctx)
8920 
8921  def __sub__(self, other):
8922  """Create the Z3 expression `self - other`.
8923 
8924  >>> x = FP('x', FPSort(8, 24))
8925  >>> y = FP('y', FPSort(8, 24))
8926  >>> x - y
8927  x - y
8928  >>> (x - y).sort()
8929  FPSort(8, 24)
8930  """
8931  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8932  return fpSub(_dflt_rm(), a, b, self.ctx)
8933 
8934  def __rsub__(self, other):
8935  """Create the Z3 expression `other - self`.
8936 
8937  >>> x = FP('x', FPSort(8, 24))
8938  >>> 10 - x
8939  1.25*(2**3) - x
8940  """
8941  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8942  return fpSub(_dflt_rm(), a, b, self.ctx)
8943 
8944  def __mul__(self, other):
8945  """Create the Z3 expression `self * other`.
8946 
8947  >>> x = FP('x', FPSort(8, 24))
8948  >>> y = FP('y', FPSort(8, 24))
8949  >>> x * y
8950  x * y
8951  >>> (x * y).sort()
8952  FPSort(8, 24)
8953  >>> 10 * y
8954  1.25*(2**3) * y
8955  """
8956  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8957  return fpMul(_dflt_rm(), a, b, self.ctx)
8958 
8959  def __rmul__(self, other):
8960  """Create the Z3 expression `other * self`.
8961 
8962  >>> x = FP('x', FPSort(8, 24))
8963  >>> y = FP('y', FPSort(8, 24))
8964  >>> x * y
8965  x * y
8966  >>> x * 10
8967  x * 1.25*(2**3)
8968  """
8969  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8970  return fpMul(_dflt_rm(), a, b, self.ctx)
8971 
8972  def __pos__(self):
8973  """Create the Z3 expression `+self`."""
8974  return self
8975 
8976  def __neg__(self):
8977  """Create the Z3 expression `-self`.
8978 
8979  >>> x = FP('x', Float32())
8980  >>> -x
8981  -x
8982  """
8983  return fpNeg(self)
8984 
8985  def __div__(self, other):
8986  """Create the Z3 expression `self / other`.
8987 
8988  >>> x = FP('x', FPSort(8, 24))
8989  >>> y = FP('y', FPSort(8, 24))
8990  >>> x / y
8991  x / y
8992  >>> (x / y).sort()
8993  FPSort(8, 24)
8994  >>> 10 / y
8995  1.25*(2**3) / y
8996  """
8997  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8998  return fpDiv(_dflt_rm(), a, b, self.ctx)
8999 
9000  def __rdiv__(self, other):
9001  """Create the Z3 expression `other / self`.
9002 
9003  >>> x = FP('x', FPSort(8, 24))
9004  >>> y = FP('y', FPSort(8, 24))
9005  >>> x / y
9006  x / y
9007  >>> x / 10
9008  x / 1.25*(2**3)
9009  """
9010  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
9011  return fpDiv(_dflt_rm(), a, b, self.ctx)
9012 
9013  def __truediv__(self, other):
9014  """Create the Z3 expression division `self / other`."""
9015  return self.__div__(other)
9016 
9017  def __rtruediv__(self, other):
9018  """Create the Z3 expression division `other / self`."""
9019  return self.__rdiv__(other)
9020 
9021  def __mod__(self, other):
9022  """Create the Z3 expression mod `self % other`."""
9023  return fpRem(self, other)
9024 
9025  def __rmod__(self, other):
9026  """Create the Z3 expression mod `other % self`."""
9027  return fpRem(other, self)
9028 
9030  """Floating-point rounding mode expressions"""
9031 
9032  def as_string(self):
9033  """Return a Z3 floating point expression as a Python string."""
9034  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
9035 
9036 
9038  ctx = _get_ctx(ctx)
9039  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9040 
9041 def RNE (ctx=None):
9042  ctx = _get_ctx(ctx)
9043  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9044 
9046  ctx = _get_ctx(ctx)
9047  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9048 
9049 def RNA (ctx=None):
9050  ctx = _get_ctx(ctx)
9051  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9052 
9053 def RoundTowardPositive(ctx=None):
9054  ctx = _get_ctx(ctx)
9055  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9056 
9057 def RTP(ctx=None):
9058  ctx = _get_ctx(ctx)
9059  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9060 
9061 def RoundTowardNegative(ctx=None):
9062  ctx = _get_ctx(ctx)
9063  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9064 
9065 def RTN(ctx=None):
9066  ctx = _get_ctx(ctx)
9067  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9068 
9069 def RoundTowardZero(ctx=None):
9070  ctx = _get_ctx(ctx)
9071  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9072 
9073 def RTZ(ctx=None):
9074  ctx = _get_ctx(ctx)
9075  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9076 
9077 def is_fprm(a):
9078  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9079 
9080  >>> rm = RNE()
9081  >>> is_fprm(rm)
9082  True
9083  >>> rm = 1.0
9084  >>> is_fprm(rm)
9085  False
9086  """
9087  return isinstance(a, FPRMRef)
9088 
9090  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9091  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9092 
9093 
9094 
9096  """The sign of the numeral.
9097 
9098  >>> x = FPVal(+1.0, FPSort(8, 24))
9099  >>> x.sign()
9100  False
9101  >>> x = FPVal(-1.0, FPSort(8, 24))
9102  >>> x.sign()
9103  True
9104  """
9105  def sign(self):
9106  l = (ctypes.c_int)()
9107  if Z3_fpa_get_numeral_sign(self.ctx.ref(), self.as_ast(), byref(l)) == False:
9108  raise Z3Exception("error retrieving the sign of a numeral.")
9109  return l.value != 0
9110 
9111  """The sign of a floating-point numeral as a bit-vector expression.
9112 
9113  Remark: NaN's are invalid arguments.
9114  """
9115  def sign_as_bv(self):
9116  return BitVecNumRef(Z3_fpa_get_numeral_sign_bv(self.ctx.ref(), self.as_ast()), self.ctx)
9117 
9118  """The significand of the numeral.
9119 
9120  >>> x = FPVal(2.5, FPSort(8, 24))
9121  >>> x.significand()
9122  1.25
9123  """
9124  def significand(self):
9125  return Z3_fpa_get_numeral_significand_string(self.ctx.ref(), self.as_ast())
9126 
9127  """The significand of the numeral as a long.
9128 
9129  >>> x = FPVal(2.5, FPSort(8, 24))
9130  >>> x.significand_as_long()
9131  1.25
9132  """
9134  ptr = (ctypes.c_ulonglong * 1)()
9135  if not Z3_fpa_get_numeral_significand_uint64(self.ctx.ref(), self.as_ast(), ptr):
9136  raise Z3Exception("error retrieving the significand of a numeral.")
9137  return ptr[0]
9138 
9139  """The significand of the numeral as a bit-vector expression.
9140 
9141  Remark: NaN are invalid arguments.
9142  """
9144  return BitVecNumRef(Z3_fpa_get_numeral_significand_bv(self.ctx.ref(), self.as_ast()), self.ctx)
9145 
9146  """The exponent of the numeral.
9147 
9148  >>> x = FPVal(2.5, FPSort(8, 24))
9149  >>> x.exponent()
9150  1
9151  """
9152  def exponent(self, biased=True):
9153  return Z3_fpa_get_numeral_exponent_string(self.ctx.ref(), self.as_ast(), biased)
9154 
9155  """The exponent of the numeral as a long.
9156 
9157  >>> x = FPVal(2.5, FPSort(8, 24))
9158  >>> x.exponent_as_long()
9159  1
9160  """
9161  def exponent_as_long(self, biased=True):
9162  ptr = (ctypes.c_longlong * 1)()
9163  if not Z3_fpa_get_numeral_exponent_int64(self.ctx.ref(), self.as_ast(), ptr, biased):
9164  raise Z3Exception("error retrieving the exponent of a numeral.")
9165  return ptr[0]
9166 
9167  """The exponent of the numeral as a bit-vector expression.
9168 
9169  Remark: NaNs are invalid arguments.
9170  """
9171  def exponent_as_bv(self, biased=True):
9172  return BitVecNumRef(Z3_fpa_get_numeral_exponent_bv(self.ctx.ref(), self.as_ast(), biased), self.ctx)
9173 
9174  """Indicates whether the numeral is a NaN."""
9175  def isNaN(self):
9176  return Z3_fpa_is_numeral_nan(self.ctx.ref(), self.as_ast())
9177 
9178  """Indicates whether the numeral is +oo or -oo."""
9179  def isInf(self):
9180  return Z3_fpa_is_numeral_inf(self.ctx.ref(), self.as_ast())
9181 
9182  """Indicates whether the numeral is +zero or -zero."""
9183  def isZero(self):
9184  return Z3_fpa_is_numeral_zero(self.ctx.ref(), self.as_ast())
9185 
9186  """Indicates whether the numeral is normal."""
9187  def isNormal(self):
9188  return Z3_fpa_is_numeral_normal(self.ctx.ref(), self.as_ast())
9189 
9190  """Indicates whether the numeral is subnormal."""
9191  def isSubnormal(self):
9192  return Z3_fpa_is_numeral_subnormal(self.ctx.ref(), self.as_ast())
9193 
9194  """Indicates whether the numeral is positive."""
9195  def isPositive(self):
9196  return Z3_fpa_is_numeral_positive(self.ctx.ref(), self.as_ast())
9197 
9198  """Indicates whether the numeral is negative."""
9199  def isNegative(self):
9200  return Z3_fpa_is_numeral_negative(self.ctx.ref(), self.as_ast())
9201 
9202  """
9203  The string representation of the numeral.
9204 
9205  >>> x = FPVal(20, FPSort(8, 24))
9206  >>> x.as_string()
9207  1.25*(2**4)
9208  """
9209  def as_string(self):
9210  s = Z3_get_numeral_string(self.ctx.ref(), self.as_ast())
9211  return ("FPVal(%s, %s)" % (s, self.sort()))
9212 
9213 def is_fp(a):
9214  """Return `True` if `a` is a Z3 floating-point expression.
9215 
9216  >>> b = FP('b', FPSort(8, 24))
9217  >>> is_fp(b)
9218  True
9219  >>> is_fp(b + 1.0)
9220  True
9221  >>> is_fp(Int('x'))
9222  False
9223  """
9224  return isinstance(a, FPRef)
9225 
9227  """Return `True` if `a` is a Z3 floating-point numeral value.
9228 
9229  >>> b = FP('b', FPSort(8, 24))
9230  >>> is_fp_value(b)
9231  False
9232  >>> b = FPVal(1.0, FPSort(8, 24))
9233  >>> b
9234  1
9235  >>> is_fp_value(b)
9236  True
9237  """
9238  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9239 
9240 def FPSort(ebits, sbits, ctx=None):
9241  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9242 
9243  >>> Single = FPSort(8, 24)
9244  >>> Double = FPSort(11, 53)
9245  >>> Single
9246  FPSort(8, 24)
9247  >>> x = Const('x', Single)
9248  >>> eq(x, FP('x', FPSort(8, 24)))
9249  True
9250  """
9251  ctx = _get_ctx(ctx)
9252  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9253 
9254 def _to_float_str(val, exp=0):
9255  if isinstance(val, float):
9256  if math.isnan(val):
9257  res = "NaN"
9258  elif val == 0.0:
9259  sone = math.copysign(1.0, val)
9260  if sone < 0.0:
9261  return "-0.0"
9262  else:
9263  return "+0.0"
9264  elif val == float("+inf"):
9265  res = "+oo"
9266  elif val == float("-inf"):
9267  res = "-oo"
9268  else:
9269  v = val.as_integer_ratio()
9270  num = v[0]
9271  den = v[1]
9272  rvs = str(num) + '/' + str(den)
9273  res = rvs + 'p' + _to_int_str(exp)
9274  elif isinstance(val, bool):
9275  if val:
9276  res = "1.0"
9277  else:
9278  res = "0.0"
9279  elif _is_int(val):
9280  res = str(val)
9281  elif isinstance(val, str):
9282  inx = val.find('*(2**')
9283  if inx == -1:
9284  res = val
9285  elif val[-1] == ')':
9286  res = val[0:inx]
9287  exp = str(int(val[inx+5:-1]) + int(exp))
9288  else:
9289  _z3_assert(False, "String does not have floating-point numeral form.")
9290  elif z3_debug():
9291  _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
9292  if exp == 0:
9293  return res
9294  else:
9295  return res + 'p' + exp
9296 
9297 
9298 def fpNaN(s):
9299  """Create a Z3 floating-point NaN term.
9300 
9301  >>> s = FPSort(8, 24)
9302  >>> set_fpa_pretty(True)
9303  >>> fpNaN(s)
9304  NaN
9305  >>> pb = get_fpa_pretty()
9306  >>> set_fpa_pretty(False)
9307  >>> fpNaN(s)
9308  fpNaN(FPSort(8, 24))
9309  >>> set_fpa_pretty(pb)
9310  """
9311  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9312  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9313 
9315  """Create a Z3 floating-point +oo term.
9316 
9317  >>> s = FPSort(8, 24)
9318  >>> pb = get_fpa_pretty()
9319  >>> set_fpa_pretty(True)
9320  >>> fpPlusInfinity(s)
9321  +oo
9322  >>> set_fpa_pretty(False)
9323  >>> fpPlusInfinity(s)
9324  fpPlusInfinity(FPSort(8, 24))
9325  >>> set_fpa_pretty(pb)
9326  """
9327  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9328  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9329 
9331  """Create a Z3 floating-point -oo term."""
9332  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9333  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9334 
9335 def fpInfinity(s, negative):
9336  """Create a Z3 floating-point +oo or -oo term."""
9337  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9338  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9339  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9340 
9341 def fpPlusZero(s):
9342  """Create a Z3 floating-point +0.0 term."""
9343  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9344  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9345 
9347  """Create a Z3 floating-point -0.0 term."""
9348  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9349  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9350 
9351 def fpZero(s, negative):
9352  """Create a Z3 floating-point +0.0 or -0.0 term."""
9353  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9354  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9355  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9356 
9357 def FPVal(sig, exp=None, fps=None, ctx=None):
9358  """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9359 
9360  >>> v = FPVal(20.0, FPSort(8, 24))
9361  >>> v
9362  1.25*(2**4)
9363  >>> print("0x%.8x" % v.exponent_as_long(False))
9364  0x00000004
9365  >>> v = FPVal(2.25, FPSort(8, 24))
9366  >>> v
9367  1.125*(2**1)
9368  >>> v = FPVal(-2.25, FPSort(8, 24))
9369  >>> v
9370  -1.125*(2**1)
9371  >>> FPVal(-0.0, FPSort(8, 24))
9372  -0.0
9373  >>> FPVal(0.0, FPSort(8, 24))
9374  +0.0
9375  >>> FPVal(+0.0, FPSort(8, 24))
9376  +0.0
9377  """
9378  ctx = _get_ctx(ctx)
9379  if is_fp_sort(exp):
9380  fps = exp
9381  exp = None
9382  elif fps is None:
9383  fps = _dflt_fps(ctx)
9384  _z3_assert(is_fp_sort(fps), "sort mismatch")
9385  if exp is None:
9386  exp = 0
9387  val = _to_float_str(sig)
9388  if val == "NaN" or val == "nan":
9389  return fpNaN(fps)
9390  elif val == "-0.0":
9391  return fpMinusZero(fps)
9392  elif val == "0.0" or val == "+0.0":
9393  return fpPlusZero(fps)
9394  elif val == "+oo" or val == "+inf" or val == "+Inf":
9395  return fpPlusInfinity(fps)
9396  elif val == "-oo" or val == "-inf" or val == "-Inf":
9397  return fpMinusInfinity(fps)
9398  else:
9399  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9400 
9401 def FP(name, fpsort, ctx=None):
9402  """Return a floating-point constant named `name`.
9403  `fpsort` is the floating-point sort.
9404  If `ctx=None`, then the global context is used.
9405 
9406  >>> x = FP('x', FPSort(8, 24))
9407  >>> is_fp(x)
9408  True
9409  >>> x.ebits()
9410  8
9411  >>> x.sort()
9412  FPSort(8, 24)
9413  >>> word = FPSort(8, 24)
9414  >>> x2 = FP('x', word)
9415  >>> eq(x, x2)
9416  True
9417  """
9418  if isinstance(fpsort, FPSortRef) and ctx is None:
9419  ctx = fpsort.ctx
9420  else:
9421  ctx = _get_ctx(ctx)
9422  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9423 
9424 def FPs(names, fpsort, ctx=None):
9425  """Return an array of floating-point constants.
9426 
9427  >>> x, y, z = FPs('x y z', FPSort(8, 24))
9428  >>> x.sort()
9429  FPSort(8, 24)
9430  >>> x.sbits()
9431  24
9432  >>> x.ebits()
9433  8
9434  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9435  fpMul(RNE(), fpAdd(RNE(), x, y), z)
9436  """
9437  ctx = _get_ctx(ctx)
9438  if isinstance(names, str):
9439  names = names.split(" ")
9440  return [FP(name, fpsort, ctx) for name in names]
9441 
9442 def fpAbs(a, ctx=None):
9443  """Create a Z3 floating-point absolute value expression.
9444 
9445  >>> s = FPSort(8, 24)
9446  >>> rm = RNE()
9447  >>> x = FPVal(1.0, s)
9448  >>> fpAbs(x)
9449  fpAbs(1)
9450  >>> y = FPVal(-20.0, s)
9451  >>> y
9452  -1.25*(2**4)
9453  >>> fpAbs(y)
9454  fpAbs(-1.25*(2**4))
9455  >>> fpAbs(-1.25*(2**4))
9456  fpAbs(-1.25*(2**4))
9457  >>> fpAbs(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_abs(ctx.ref(), a.as_ast()), ctx)
9463 
9464 def fpNeg(a, ctx=None):
9465  """Create a Z3 floating-point addition expression.
9466 
9467  >>> s = FPSort(8, 24)
9468  >>> rm = RNE()
9469  >>> x = FP('x', s)
9470  >>> fpNeg(x)
9471  -x
9472  >>> fpNeg(x).sort()
9473  FPSort(8, 24)
9474  """
9475  ctx = _get_ctx(ctx)
9476  [a] = _coerce_fp_expr_list([a], ctx)
9477  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9478 
9479 def _mk_fp_unary(f, rm, a, ctx):
9480  ctx = _get_ctx(ctx)
9481  [a] = _coerce_fp_expr_list([a], 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), "Second argument must be a Z3 floating-point expression")
9485  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
9486 
9487 def _mk_fp_unary_pred(f, a, ctx):
9488  ctx = _get_ctx(ctx)
9489  [a] = _coerce_fp_expr_list([a], ctx)
9490  if z3_debug():
9491  _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
9492  return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
9493 
9494 def _mk_fp_bin(f, rm, 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_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9499  _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
9500  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
9501 
9502 def _mk_fp_bin_norm(f, a, b, ctx):
9503  ctx = _get_ctx(ctx)
9504  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9505  if z3_debug():
9506  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9507  return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
9508 
9509 def _mk_fp_bin_pred(f, a, b, ctx):
9510  ctx = _get_ctx(ctx)
9511  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9512  if z3_debug():
9513  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9514  return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
9515 
9516 def _mk_fp_tern(f, rm, a, b, c, ctx):
9517  ctx = _get_ctx(ctx)
9518  [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
9519  if z3_debug():
9520  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9521  _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")
9522  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
9523 
9524 def fpAdd(rm, a, b, ctx=None):
9525  """Create a Z3 floating-point addition expression.
9526 
9527  >>> s = FPSort(8, 24)
9528  >>> rm = RNE()
9529  >>> x = FP('x', s)
9530  >>> y = FP('y', s)
9531  >>> fpAdd(rm, x, y)
9532  fpAdd(RNE(), x, y)
9533  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9534  x + y
9535  >>> fpAdd(rm, x, y).sort()
9536  FPSort(8, 24)
9537  """
9538  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9539 
9540 def fpSub(rm, a, b, ctx=None):
9541  """Create a Z3 floating-point subtraction expression.
9542 
9543  >>> s = FPSort(8, 24)
9544  >>> rm = RNE()
9545  >>> x = FP('x', s)
9546  >>> y = FP('y', s)
9547  >>> fpSub(rm, x, y)
9548  fpSub(RNE(), x, y)
9549  >>> fpSub(rm, x, y).sort()
9550  FPSort(8, 24)
9551  """
9552  return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
9553 
9554 def fpMul(rm, a, b, ctx=None):
9555  """Create a Z3 floating-point multiplication expression.
9556 
9557  >>> s = FPSort(8, 24)
9558  >>> rm = RNE()
9559  >>> x = FP('x', s)
9560  >>> y = FP('y', s)
9561  >>> fpMul(rm, x, y)
9562  fpMul(RNE(), x, y)
9563  >>> fpMul(rm, x, y).sort()
9564  FPSort(8, 24)
9565  """
9566  return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
9567 
9568 def fpDiv(rm, a, b, ctx=None):
9569  """Create a Z3 floating-point division expression.
9570 
9571  >>> s = FPSort(8, 24)
9572  >>> rm = RNE()
9573  >>> x = FP('x', s)
9574  >>> y = FP('y', s)
9575  >>> fpDiv(rm, x, y)
9576  fpDiv(RNE(), x, y)
9577  >>> fpDiv(rm, x, y).sort()
9578  FPSort(8, 24)
9579  """
9580  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
9581 
9582 def fpRem(a, b, ctx=None):
9583  """Create a Z3 floating-point remainder expression.
9584 
9585  >>> s = FPSort(8, 24)
9586  >>> x = FP('x', s)
9587  >>> y = FP('y', s)
9588  >>> fpRem(x, y)
9589  fpRem(x, y)
9590  >>> fpRem(x, y).sort()
9591  FPSort(8, 24)
9592  """
9593  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9594 
9595 def fpMin(a, b, ctx=None):
9596  """Create a Z3 floating-point minimum expression.
9597 
9598  >>> s = FPSort(8, 24)
9599  >>> rm = RNE()
9600  >>> x = FP('x', s)
9601  >>> y = FP('y', s)
9602  >>> fpMin(x, y)
9603  fpMin(x, y)
9604  >>> fpMin(x, y).sort()
9605  FPSort(8, 24)
9606  """
9607  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
9608 
9609 def fpMax(a, b, ctx=None):
9610  """Create a Z3 floating-point maximum expression.
9611 
9612  >>> s = FPSort(8, 24)
9613  >>> rm = RNE()
9614  >>> x = FP('x', s)
9615  >>> y = FP('y', s)
9616  >>> fpMax(x, y)
9617  fpMax(x, y)
9618  >>> fpMax(x, y).sort()
9619  FPSort(8, 24)
9620  """
9621  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9622 
9623 def fpFMA(rm, a, b, c, ctx=None):
9624  """Create a Z3 floating-point fused multiply-add expression.
9625  """
9626  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9627 
9628 def fpSqrt(rm, a, ctx=None):
9629  """Create a Z3 floating-point square root expression.
9630  """
9631  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9632 
9633 def fpRoundToIntegral(rm, a, ctx=None):
9634  """Create a Z3 floating-point roundToIntegral expression.
9635  """
9636  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9637 
9638 def fpIsNaN(a, ctx=None):
9639  """Create a Z3 floating-point isNaN expression.
9640 
9641  >>> s = FPSort(8, 24)
9642  >>> x = FP('x', s)
9643  >>> y = FP('y', s)
9644  >>> fpIsNaN(x)
9645  fpIsNaN(x)
9646  """
9647  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9648 
9649 def fpIsInf(a, ctx=None):
9650  """Create a Z3 floating-point isInfinite expression.
9651 
9652  >>> s = FPSort(8, 24)
9653  >>> x = FP('x', s)
9654  >>> fpIsInf(x)
9655  fpIsInf(x)
9656  """
9657  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9658 
9659 def fpIsZero(a, ctx=None):
9660  """Create a Z3 floating-point isZero expression.
9661  """
9662  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9663 
9664 def fpIsNormal(a, ctx=None):
9665  """Create a Z3 floating-point isNormal expression.
9666  """
9667  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9668 
9669 def fpIsSubnormal(a, ctx=None):
9670  """Create a Z3 floating-point isSubnormal expression.
9671  """
9672  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9673 
9674 def fpIsNegative(a, ctx=None):
9675  """Create a Z3 floating-point isNegative expression.
9676  """
9677  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9678 
9679 def fpIsPositive(a, ctx=None):
9680  """Create a Z3 floating-point isPositive expression.
9681  """
9682  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9683 
9684 def _check_fp_args(a, b):
9685  if z3_debug():
9686  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9687 
9688 def fpLT(a, b, ctx=None):
9689  """Create the Z3 floating-point expression `other < self`.
9690 
9691  >>> x, y = FPs('x y', FPSort(8, 24))
9692  >>> fpLT(x, y)
9693  x < y
9694  >>> (x < y).sexpr()
9695  '(fp.lt x y)'
9696  """
9697  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
9698 
9699 def fpLEQ(a, b, ctx=None):
9700  """Create the Z3 floating-point expression `other <= self`.
9701 
9702  >>> x, y = FPs('x y', FPSort(8, 24))
9703  >>> fpLEQ(x, y)
9704  x <= y
9705  >>> (x <= y).sexpr()
9706  '(fp.leq x y)'
9707  """
9708  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
9709 
9710 def fpGT(a, b, ctx=None):
9711  """Create the Z3 floating-point expression `other > self`.
9712 
9713  >>> x, y = FPs('x y', FPSort(8, 24))
9714  >>> fpGT(x, y)
9715  x > y
9716  >>> (x > y).sexpr()
9717  '(fp.gt x y)'
9718  """
9719  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
9720 
9721 def fpGEQ(a, b, ctx=None):
9722  """Create the Z3 floating-point expression `other >= self`.
9723 
9724  >>> x, y = FPs('x y', FPSort(8, 24))
9725  >>> fpGEQ(x, y)
9726  x >= y
9727  >>> (x >= y).sexpr()
9728  '(fp.geq x y)'
9729  """
9730  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
9731 
9732 def fpEQ(a, b, ctx=None):
9733  """Create the Z3 floating-point expression `fpEQ(other, self)`.
9734 
9735  >>> x, y = FPs('x y', FPSort(8, 24))
9736  >>> fpEQ(x, y)
9737  fpEQ(x, y)
9738  >>> fpEQ(x, y).sexpr()
9739  '(fp.eq x y)'
9740  """
9741  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
9742 
9743 def fpNEQ(a, b, ctx=None):
9744  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9745 
9746  >>> x, y = FPs('x y', FPSort(8, 24))
9747  >>> fpNEQ(x, y)
9748  Not(fpEQ(x, y))
9749  >>> (x != y).sexpr()
9750  '(distinct x y)'
9751  """
9752  return Not(fpEQ(a, b, ctx))
9753 
9754 def fpFP(sgn, exp, sig, ctx=None):
9755  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9756 
9757  >>> s = FPSort(8, 24)
9758  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9759  >>> print(x)
9760  fpFP(1, 127, 4194304)
9761  >>> xv = FPVal(-1.5, s)
9762  >>> print(xv)
9763  -1.5
9764  >>> slvr = Solver()
9765  >>> slvr.add(fpEQ(x, xv))
9766  >>> slvr.check()
9767  sat
9768  >>> xv = FPVal(+1.5, s)
9769  >>> print(xv)
9770  1.5
9771  >>> slvr = Solver()
9772  >>> slvr.add(fpEQ(x, xv))
9773  >>> slvr.check()
9774  unsat
9775  """
9776  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9777  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9778  ctx = _get_ctx(ctx)
9779  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9780  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9781 
9782 def fpToFP(a1, a2=None, a3=None, ctx=None):
9783  """Create a Z3 floating-point conversion expression from other term sorts
9784  to floating-point.
9785 
9786  From a bit-vector term in IEEE 754-2008 format:
9787  >>> x = FPVal(1.0, Float32())
9788  >>> x_bv = fpToIEEEBV(x)
9789  >>> simplify(fpToFP(x_bv, Float32()))
9790  1
9791 
9792  From a floating-point term with different precision:
9793  >>> x = FPVal(1.0, Float32())
9794  >>> x_db = fpToFP(RNE(), x, Float64())
9795  >>> x_db.sort()
9796  FPSort(11, 53)
9797 
9798  From a real term:
9799  >>> x_r = RealVal(1.5)
9800  >>> simplify(fpToFP(RNE(), x_r, Float32()))
9801  1.5
9802 
9803  From a signed bit-vector term:
9804  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9805  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9806  -1.25*(2**2)
9807  """
9808  ctx = _get_ctx(ctx)
9809  if is_bv(a1) and is_fp_sort(a2):
9810  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9811  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9812  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9813  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9814  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9815  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9816  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9817  else:
9818  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9819 
9820 def fpBVToFP(v, sort, ctx=None):
9821  """Create a Z3 floating-point conversion expression that represents the
9822  conversion from a bit-vector term to a floating-point term.
9823 
9824  >>> x_bv = BitVecVal(0x3F800000, 32)
9825  >>> x_fp = fpBVToFP(x_bv, Float32())
9826  >>> x_fp
9827  fpToFP(1065353216)
9828  >>> simplify(x_fp)
9829  1
9830  """
9831  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
9832  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9833  ctx = _get_ctx(ctx)
9834  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9835 
9836 def fpFPToFP(rm, v, sort, ctx=None):
9837  """Create a Z3 floating-point conversion expression that represents the
9838  conversion from a floating-point term to a floating-point term of different precision.
9839 
9840  >>> x_sgl = FPVal(1.0, Float32())
9841  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9842  >>> x_dbl
9843  fpToFP(RNE(), 1)
9844  >>> simplify(x_dbl)
9845  1
9846  >>> x_dbl.sort()
9847  FPSort(11, 53)
9848  """
9849  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9850  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9851  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9852  ctx = _get_ctx(ctx)
9853  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9854 
9855 def fpRealToFP(rm, v, sort, ctx=None):
9856  """Create a Z3 floating-point conversion expression that represents the
9857  conversion from a real term to a floating-point term.
9858 
9859  >>> x_r = RealVal(1.5)
9860  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9861  >>> x_fp
9862  fpToFP(RNE(), 3/2)
9863  >>> simplify(x_fp)
9864  1.5
9865  """
9866  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9867  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9868  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9869  ctx = _get_ctx(ctx)
9870  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9871 
9872 def fpSignedToFP(rm, v, sort, ctx=None):
9873  """Create a Z3 floating-point conversion expression that represents the
9874  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
9875 
9876  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9877  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
9878  >>> x_fp
9879  fpToFP(RNE(), 4294967291)
9880  >>> simplify(x_fp)
9881  -1.25*(2**2)
9882  """
9883  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9884  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9885  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9886  ctx = _get_ctx(ctx)
9887  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9888 
9889 def fpUnsignedToFP(rm, v, sort, ctx=None):
9890  """Create a Z3 floating-point conversion expression that represents the
9891  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9892 
9893  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9894  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9895  >>> x_fp
9896  fpToFPUnsigned(RNE(), 4294967291)
9897  >>> simplify(x_fp)
9898  1*(2**32)
9899  """
9900  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9901  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
9902  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9903  ctx = _get_ctx(ctx)
9904  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9905 
9906 def fpToFPUnsigned(rm, x, s, ctx=None):
9907  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
9908  if z3_debug():
9909  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9910  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
9911  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9912  ctx = _get_ctx(ctx)
9913  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9914 
9915 def fpToSBV(rm, x, s, ctx=None):
9916  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
9917 
9918  >>> x = FP('x', FPSort(8, 24))
9919  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
9920  >>> print(is_fp(x))
9921  True
9922  >>> print(is_bv(y))
9923  True
9924  >>> print(is_fp(y))
9925  False
9926  >>> print(is_bv(x))
9927  False
9928  """
9929  if z3_debug():
9930  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9931  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9932  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9933  ctx = _get_ctx(ctx)
9934  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9935 
9936 def fpToUBV(rm, x, s, ctx=None):
9937  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9938 
9939  >>> x = FP('x', FPSort(8, 24))
9940  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9941  >>> print(is_fp(x))
9942  True
9943  >>> print(is_bv(y))
9944  True
9945  >>> print(is_fp(y))
9946  False
9947  >>> print(is_bv(x))
9948  False
9949  """
9950  if z3_debug():
9951  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9952  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9953  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9954  ctx = _get_ctx(ctx)
9955  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9956 
9957 def fpToReal(x, ctx=None):
9958  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9959 
9960  >>> x = FP('x', FPSort(8, 24))
9961  >>> y = fpToReal(x)
9962  >>> print(is_fp(x))
9963  True
9964  >>> print(is_real(y))
9965  True
9966  >>> print(is_fp(y))
9967  False
9968  >>> print(is_real(x))
9969  False
9970  """
9971  if z3_debug():
9972  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9973  ctx = _get_ctx(ctx)
9974  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9975 
9976 def fpToIEEEBV(x, ctx=None):
9977  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9978 
9979  The size of the resulting bit-vector is automatically determined.
9980 
9981  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9982  knows only one NaN and it will always produce the same bit-vector representation of
9983  that NaN.
9984 
9985  >>> x = FP('x', FPSort(8, 24))
9986  >>> y = fpToIEEEBV(x)
9987  >>> print(is_fp(x))
9988  True
9989  >>> print(is_bv(y))
9990  True
9991  >>> print(is_fp(y))
9992  False
9993  >>> print(is_bv(x))
9994  False
9995  """
9996  if z3_debug():
9997  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9998  ctx = _get_ctx(ctx)
9999  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
10000 
10001 
10002 
10003 
10008 
10010  """Sequence sort."""
10011 
10012  def is_string(self):
10013  """Determine if sort is a string
10014  >>> s = StringSort()
10015  >>> s.is_string()
10016  True
10017  >>> s = SeqSort(IntSort())
10018  >>> s.is_string()
10019  False
10020  """
10021  return Z3_is_string_sort(self.ctx_ref(), self.ast)
10022 
10023  def basis(self):
10024  return _to_sort_ref(Z3_get_seq_sort_basis(self.ctx_ref(), self.ast), self.ctx)
10025 
10026 
10027 def StringSort(ctx=None):
10028  """Create a string sort
10029  >>> s = StringSort()
10030  >>> print(s)
10031  String
10032  """
10033  ctx = _get_ctx(ctx)
10034  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10035 
10036 
10037 def SeqSort(s):
10038  """Create a sequence sort over elements provided in the argument
10039  >>> s = SeqSort(IntSort())
10040  >>> s == Unit(IntVal(1)).sort()
10041  True
10042  """
10043  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10044 
10046  """Sequence expression."""
10047 
10048  def sort(self):
10049  return SeqSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
10050 
10051  def __add__(self, other):
10052  return Concat(self, other)
10053 
10054  def __radd__(self, other):
10055  return Concat(other, self)
10056 
10057  def __getitem__(self, i):
10058  if _is_int(i):
10059  i = IntVal(i, self.ctx)
10060  return _to_expr_ref(Z3_mk_seq_nth(self.ctx_ref(), self.as_ast(), i.as_ast()), self.ctx)
10061 
10062  def at(self, i):
10063  if _is_int(i):
10064  i = IntVal(i, self.ctx)
10065  return SeqRef(Z3_mk_seq_at(self.ctx_ref(), self.as_ast(), i.as_ast()), self.ctx)
10066 
10067  def is_string(self):
10068  return Z3_is_string_sort(self.ctx_ref(), Z3_get_sort(self.ctx_ref(), self.as_ast()))
10069 
10070  def is_string_value(self):
10071  return Z3_is_string(self.ctx_ref(), self.as_ast())
10072 
10073 
10074  def as_string(self):
10075  """Return a string representation of sequence expression."""
10076  if self.is_string_value():
10077  string_length = ctypes.c_uint()
10078  chars = Z3_get_lstring(self.ctx_ref(), self.as_ast(), byref(string_length))
10079  return string_at(chars, size=string_length.value).decode('latin-1')
10080  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
10081 
10082  def __le__(self, other):
10083  return SeqRef(Z3_mk_str_le(self.ctx_ref(), self.as_ast(), other.as_ast()), self.ctx)
10084 
10085  def __lt__(self, other):
10086  return SeqRef(Z3_mk_str_lt(self.ctx_ref(), self.as_ast(), other.as_ast()), self.ctx)
10087 
10088  def __ge__(self, other):
10089  return SeqRef(Z3_mk_str_le(self.ctx_ref(), other.as_ast(), self.as_ast()), self.ctx)
10090 
10091  def __gt__(self, other):
10092  return SeqRef(Z3_mk_str_lt(self.ctx_ref(), other.as_ast(), self.as_ast()), self.ctx)
10093 
10094 
10095 def _coerce_seq(s, ctx=None):
10096  if isinstance(s, str):
10097  ctx = _get_ctx(ctx)
10098  s = StringVal(s, ctx)
10099  if not is_expr(s):
10100  raise Z3Exception("Non-expression passed as a sequence")
10101  if not is_seq(s):
10102  raise Z3Exception("Non-sequence passed as a sequence")
10103  return s
10104 
10105 def _get_ctx2(a, b, ctx=None):
10106  if is_expr(a):
10107  return a.ctx
10108  if is_expr(b):
10109  return b.ctx
10110  if ctx is None:
10111  ctx = main_ctx()
10112  return ctx
10113 
10114 def is_seq(a):
10115  """Return `True` if `a` is a Z3 sequence expression.
10116  >>> print (is_seq(Unit(IntVal(0))))
10117  True
10118  >>> print (is_seq(StringVal("abc")))
10119  True
10120  """
10121  return isinstance(a, SeqRef)
10122 
10123 def is_string(a):
10124  """Return `True` if `a` is a Z3 string expression.
10125  >>> print (is_string(StringVal("ab")))
10126  True
10127  """
10128  return isinstance(a, SeqRef) and a.is_string()
10129 
10131  """return 'True' if 'a' is a Z3 string constant expression.
10132  >>> print (is_string_value(StringVal("a")))
10133  True
10134  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10135  False
10136  """
10137  return isinstance(a, SeqRef) and a.is_string_value()
10138 
10139 
10140 def StringVal(s, ctx=None):
10141  """create a string expression"""
10142  ctx = _get_ctx(ctx)
10143  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10144 
10145 def String(name, ctx=None):
10146  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10147 
10148  >>> x = String('x')
10149  """
10150  ctx = _get_ctx(ctx)
10151  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10152 
10153 def Strings(names, ctx=None):
10154  """Return 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 SubString(s, offset, length):
10161  """Extract substring or subsequence starting at offset"""
10162  return Extract(s, offset, length)
10163 
10164 def SubSeq(s, offset, length):
10165  """Extract substring or subsequence starting at offset"""
10166  return Extract(s, offset, length)
10167 
10168 def Strings(names, ctx=None):
10169  """Return a tuple of String constants. """
10170  ctx = _get_ctx(ctx)
10171  if isinstance(names, str):
10172  names = names.split(" ")
10173  return [String(name, ctx) for name in names]
10174 
10175 def Empty(s):
10176  """Create the empty sequence of the given sort
10177  >>> e = Empty(StringSort())
10178  >>> e2 = StringVal("")
10179  >>> print(e.eq(e2))
10180  True
10181  >>> e3 = Empty(SeqSort(IntSort()))
10182  >>> print(e3)
10183  Empty(Seq(Int))
10184  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10185  >>> print(e4)
10186  Empty(ReSort(Seq(Int)))
10187  """
10188  if isinstance(s, SeqSortRef):
10189  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10190  if isinstance(s, ReSortRef):
10191  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10192  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10193 
10194 def Full(s):
10195  """Create the regular expression that accepts the universal language
10196  >>> e = Full(ReSort(SeqSort(IntSort())))
10197  >>> print(e)
10198  Full(ReSort(Seq(Int)))
10199  >>> e1 = Full(ReSort(StringSort()))
10200  >>> print(e1)
10201  Full(ReSort(String))
10202  """
10203  if isinstance(s, ReSortRef):
10204  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10205  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10206 
10207 
10208 def Unit(a):
10209  """Create a singleton sequence"""
10210  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10211 
10212 def PrefixOf(a, b):
10213  """Check if 'a' is a prefix of 'b'
10214  >>> s1 = PrefixOf("ab", "abc")
10215  >>> simplify(s1)
10216  True
10217  >>> s2 = PrefixOf("bc", "abc")
10218  >>> simplify(s2)
10219  False
10220  """
10221  ctx = _get_ctx2(a, b)
10222  a = _coerce_seq(a, ctx)
10223  b = _coerce_seq(b, ctx)
10224  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10225 
10226 def SuffixOf(a, b):
10227  """Check if 'a' is a suffix of 'b'
10228  >>> s1 = SuffixOf("ab", "abc")
10229  >>> simplify(s1)
10230  False
10231  >>> s2 = SuffixOf("bc", "abc")
10232  >>> simplify(s2)
10233  True
10234  """
10235  ctx = _get_ctx2(a, b)
10236  a = _coerce_seq(a, ctx)
10237  b = _coerce_seq(b, ctx)
10238  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10239 
10240 def Contains(a, b):
10241  """Check if 'a' contains 'b'
10242  >>> s1 = Contains("abc", "ab")
10243  >>> simplify(s1)
10244  True
10245  >>> s2 = Contains("abc", "bc")
10246  >>> simplify(s2)
10247  True
10248  >>> x, y, z = Strings('x y z')
10249  >>> s3 = Contains(Concat(x,y,z), y)
10250  >>> simplify(s3)
10251  True
10252  """
10253  ctx = _get_ctx2(a, b)
10254  a = _coerce_seq(a, ctx)
10255  b = _coerce_seq(b, ctx)
10256  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10257 
10258 
10259 def Replace(s, src, dst):
10260  """Replace the first occurrence of 'src' by 'dst' in 's'
10261  >>> r = Replace("aaa", "a", "b")
10262  >>> simplify(r)
10263  "baa"
10264  """
10265  ctx = _get_ctx2(dst, s)
10266  if ctx is None and is_expr(src):
10267  ctx = src.ctx
10268  src = _coerce_seq(src, ctx)
10269  dst = _coerce_seq(dst, ctx)
10270  s = _coerce_seq(s, ctx)
10271  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10272 
10273 def IndexOf(s, substr):
10274  return IndexOf(s, substr, IntVal(0))
10275 
10276 def IndexOf(s, substr, offset):
10277  """Retrieve the index of substring within a string starting at a specified offset.
10278  >>> simplify(IndexOf("abcabc", "bc", 0))
10279  1
10280  >>> simplify(IndexOf("abcabc", "bc", 2))
10281  4
10282  """
10283  ctx = None
10284  if is_expr(offset):
10285  ctx = offset.ctx
10286  ctx = _get_ctx2(s, substr, ctx)
10287  s = _coerce_seq(s, ctx)
10288  substr = _coerce_seq(substr, ctx)
10289  if _is_int(offset):
10290  offset = IntVal(offset, ctx)
10291  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10292 
10293 def LastIndexOf(s, substr):
10294  """Retrieve the last index of substring within a string"""
10295  ctx = None
10296  ctx = _get_ctx2(s, substr, ctx)
10297  s = _coerce_seq(s, ctx)
10298  substr = _coerce_seq(substr, ctx)
10299  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10300 
10301 
10302 def Length(s):
10303  """Obtain the length of a sequence 's'
10304  >>> l = Length(StringVal("abc"))
10305  >>> simplify(l)
10306  3
10307  """
10308  s = _coerce_seq(s)
10309  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10310 
10311 def StrToInt(s):
10312  """Convert string expression to integer
10313  >>> a = StrToInt("1")
10314  >>> simplify(1 == a)
10315  True
10316  >>> b = StrToInt("2")
10317  >>> simplify(1 == b)
10318  False
10319  >>> c = StrToInt(IntToStr(2))
10320  >>> simplify(1 == c)
10321  False
10322  """
10323  s = _coerce_seq(s)
10324  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10325 
10326 
10327 def IntToStr(s):
10328  """Convert integer expression to string"""
10329  if not is_expr(s):
10330  s = _py2expr(s)
10331  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10332 
10333 
10334 def Re(s, ctx=None):
10335  """The regular expression that accepts sequence 's'
10336  >>> s1 = Re("ab")
10337  >>> s2 = Re(StringVal("ab"))
10338  >>> s3 = Re(Unit(BoolVal(True)))
10339  """
10340  s = _coerce_seq(s, ctx)
10341  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10342 
10343 
10344 
10345 
10346 
10347 
10349  """Regular expression sort."""
10350 
10351  def basis(self):
10352  return _to_sort_ref(Z3_get_re_sort_basis(self.ctx_ref(), self.ast), self.ctx)
10353 
10354 def ReSort(s):
10355  if is_ast(s):
10356  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10357  if s is None or isinstance(s, Context):
10358  ctx = _get_ctx(s)
10359  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10360  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10361 
10362 
10364  """Regular expressions."""
10365 
10366  def __add__(self, other):
10367  return Union(self, other)
10368 
10369 def is_re(s):
10370  return isinstance(s, ReRef)
10371 
10372 
10373 def InRe(s, re):
10374  """Create regular expression membership test
10375  >>> re = Union(Re("a"),Re("b"))
10376  >>> print (simplify(InRe("a", re)))
10377  True
10378  >>> print (simplify(InRe("b", re)))
10379  True
10380  >>> print (simplify(InRe("c", re)))
10381  False
10382  """
10383  s = _coerce_seq(s, re.ctx)
10384  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10385 
10386 def Union(*args):
10387  """Create union of regular expressions.
10388  >>> re = Union(Re("a"), Re("b"), Re("c"))
10389  >>> print (simplify(InRe("d", re)))
10390  False
10391  """
10392  args = _get_args(args)
10393  sz = len(args)
10394  if z3_debug():
10395  _z3_assert(sz > 0, "At least one argument expected.")
10396  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10397  if sz == 1:
10398  return args[0]
10399  ctx = args[0].ctx
10400  v = (Ast * sz)()
10401  for i in range(sz):
10402  v[i] = args[i].as_ast()
10403  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10404 
10405 def Intersect(*args):
10406  """Create intersection of regular expressions.
10407  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10408  """
10409  args = _get_args(args)
10410  sz = len(args)
10411  if z3_debug():
10412  _z3_assert(sz > 0, "At least one argument expected.")
10413  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10414  if sz == 1:
10415  return args[0]
10416  ctx = args[0].ctx
10417  v = (Ast * sz)()
10418  for i in range(sz):
10419  v[i] = args[i].as_ast()
10420  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10421 
10422 def Plus(re):
10423  """Create the regular expression accepting one or more repetitions of argument.
10424  >>> re = Plus(Re("a"))
10425  >>> print(simplify(InRe("aa", re)))
10426  True
10427  >>> print(simplify(InRe("ab", re)))
10428  False
10429  >>> print(simplify(InRe("", re)))
10430  False
10431  """
10432  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
10433 
10434 def Option(re):
10435  """Create the regular expression that optionally accepts the argument.
10436  >>> re = Option(Re("a"))
10437  >>> print(simplify(InRe("a", re)))
10438  True
10439  >>> print(simplify(InRe("", re)))
10440  True
10441  >>> print(simplify(InRe("aa", re)))
10442  False
10443  """
10444  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10445 
10446 def Complement(re):
10447  """Create the complement regular expression."""
10448  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10449 
10450 def Star(re):
10451  """Create the regular expression accepting zero or more repetitions of argument.
10452  >>> re = Star(Re("a"))
10453  >>> print(simplify(InRe("aa", re)))
10454  True
10455  >>> print(simplify(InRe("ab", re)))
10456  False
10457  >>> print(simplify(InRe("", re)))
10458  True
10459  """
10460  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10461 
10462 def Loop(re, lo, hi=0):
10463  """Create the regular expression accepting between a lower and upper bound repetitions
10464  >>> re = Loop(Re("a"), 1, 3)
10465  >>> print(simplify(InRe("aa", re)))
10466  True
10467  >>> print(simplify(InRe("aaaa", re)))
10468  False
10469  >>> print(simplify(InRe("", re)))
10470  False
10471  """
10472  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10473 
10474 def Range(lo, hi, ctx = None):
10475  """Create the range regular expression over two sequences of length 1
10476  >>> range = Range("a","z")
10477  >>> print(simplify(InRe("b", range)))
10478  True
10479  >>> print(simplify(InRe("bb", range)))
10480  False
10481  """
10482  lo = _coerce_seq(lo, ctx)
10483  hi = _coerce_seq(hi, ctx)
10484  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10485 
10486 # Special Relations
10487 
10488 def PartialOrder(a, index):
10489  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10490 
10491 def LinearOrder(a, index):
10492  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10493 
10494 def TreeOrder(a, index):
10495  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10496 
10497 def PiecewiseLinearOrder(a, index):
10498  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10499 
10501  """Given a binary relation R, such that the two arguments have the same sort
10502  create the transitive closure relation R+.
10503  The transitive closure R+ is a new relation.
10504  """
10505  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
10506 
10507 
10509  def __init__(self):
10510  self.bases = {}
10511  self.lock = None
10512 
10514  if self.lock is None:
10515  import threading
10516  self.lock = threading.thread.Lock()
10517 
10518  def get(self, ctx):
10519  if self.lock: self.lock.acquire()
10520  r = self.bases[ctx]
10521  if self.lock: self.lock.release()
10522  return r
10523 
10524  def set(self, ctx, r):
10525  if self.lock: self.lock.acquire()
10526  self.bases[ctx] = r
10527  if self.lock: self.lock.release()
10528 
10529  def insert(self, r):
10530  if self.lock: self.lock.acquire()
10531  id = len(self.bases) + 3
10532  self.bases[id] = r
10533  if self.lock: self.lock.release()
10534  return id
10535 
10536 _prop_closures = None
10537 
10539  global _prop_closures
10540  if _prop_closures is None:
10541  _prop_closures = PropClosures()
10542 
10544  _prop_closures.get(ctx).push();
10545 
10546 def user_prop_pop(ctx, num_scopes):
10547  _prop_closures.get(ctx).pop(num_scopes)
10548 
10549 def user_prop_fresh(id, ctx):
10550  prop = _prop_closures.get(id)
10551  _prop_closures.set_threaded()
10552  new_prop = UsePropagateBase(None, ctx)
10553  _prop_closures.set(new_prop.id, new_prop.fresh())
10554  return ctypes.c_void_p(new_prop.id)
10555 
10556 def user_prop_fixed(ctx, cb, id, value):
10557  prop = _prop_closures.get(ctx)
10558  prop.cb = cb
10559  prop.fixed(id, _to_expr_ref(ctypes.c_void_p(value), prop.ctx()))
10560  prop.cb = None
10561 
10562 def user_prop_final(ctx, cb):
10563  prop = _prop_closures.get(ctx)
10564  prop.cb = cb
10565  prop.final()
10566  prop.cb = None
10567 
10568 def user_prop_eq(ctx, cb, x, y):
10569  prop = _prop_closures.get(ctx)
10570  prop.cb = cb
10571  prop.eq(x, y)
10572  prop.cb = None
10573 
10574 def user_prop_diseq(ctx, cb, x, y):
10575  prop = _prop_closures.get(ctx)
10576  prop.cb = cb
10577  prop.diseq(x, y)
10578  prop.cb = None
10579 
10580 _user_prop_push = push_eh_type(user_prop_push)
10581 _user_prop_pop = pop_eh_type(user_prop_pop)
10582 _user_prop_fresh = fresh_eh_type(user_prop_fresh)
10583 _user_prop_fixed = fixed_eh_type(user_prop_fixed)
10584 _user_prop_final = final_eh_type(user_prop_final)
10585 _user_prop_eq = eq_eh_type(user_prop_eq)
10586 _user_prop_diseq = eq_eh_type(user_prop_diseq)
10587 
10589 
10590  #
10591  # Either solver is set or ctx is set.
10592  # Propagators that are created throuh callbacks
10593  # to "fresh" inherit the context of that is supplied
10594  # as argument to the callback.
10595  # This context should not be deleted. It is owned by the solver.
10596  #
10597  def __init__(self, s, ctx = None):
10598  assert s is None or ctx is None
10600  self.solver = s
10601  self._ctx = None
10602  self.cb = None
10603  self.id = _prop_closures.insert(self)
10604  self.fixed = None
10605  self.final = None
10606  self.eq = None
10607  self.diseq = None
10608  if ctx:
10609  self._ctx = Context()
10610  Z3_del_context(self._ctx.ctx)
10611  self._ctx.ctx = ctx
10612  self._ctx.eh = Z3_set_error_handler(ctx, z3_error_handler)
10613  Z3_set_ast_print_mode(ctx, Z3_PRINT_SMTLIB2_COMPLIANT)
10614  if s:
10616  s.solver,
10617  ctypes.c_void_p(self.id),
10618  _user_prop_push,
10619  _user_prop_pop,
10620  _user_prop_fresh)
10621 
10622  def __del__(self):
10623  if self._ctx:
10624  self._ctx.ctx = None
10625 
10626  def ctx(self):
10627  if self._ctx:
10628  return self._ctx
10629  else:
10630  return self.solver.ctx
10631 
10632  def ctx_ref(self):
10633  return self.ctx().ref()
10634 
10635  def add_fixed(self, fixed):
10636  assert not self.fixed
10637  assert not self._ctx
10638  Z3_solver_propagate_fixed(self.ctx_ref(), self.solver.solver, _user_prop_fixed)
10639  self.fixed = fixed
10640 
10641  def add_final(self, final):
10642  assert not self.final
10643  assert not self._ctx
10644  Z3_solver_propagate_final(self.ctx_ref(), self.solver.solver, _user_prop_final)
10645  self.final = final
10646 
10647  def add_eq(self, eq):
10648  assert not self.eq
10649  assert not self._ctx
10650  Z3_solver_propagate_eq(self.ctx_ref(), self.solver.solver, _user_prop_eq)
10651  self.eq = eq
10652 
10653  def add_diseq(self, diseq):
10654  assert not self.diseq
10655  assert not self._ctx
10656  Z3_solver_propagate_diseq(self.ctx_ref(), self.solver.solver, _user_prop_diseq)
10657  self.diseq = diseq
10658 
10659  def push(self):
10660  raise Z3Exception("push needs to be overwritten")
10661 
10662  def pop(self, num_scopes):
10663  raise Z3Exception("pop needs to be overwritten")
10664 
10665  def fresh(self):
10666  raise Z3Exception("fresh needs to be overwritten")
10667 
10668  def add(self, e):
10669  assert self.solver
10670  assert not self._ctx
10671  return Z3_solver_propagate_register(self.ctx_ref(), self.solver.solver, e.ast)
10672 
10673  #
10674  # Propagation can only be invoked as during a fixed-callback.
10675  #
10676  def propagate(self, e, ids, eqs = []):
10677  num_fixed = len(ids)
10678  _ids = (ctypes.c_uint * num_fixed)()
10679  for i in range(num_fixed):
10680  _ids[i] = ids[i]
10681  num_eqs = len(eqs)
10682  _lhs = (ctypes.c_uint * num_eqs)()
10683  _rhs = (ctypes.c_uint * num_eqs)()
10684  for i in range(num_eqs):
10685  _lhs[i] = eqs[i][0]
10686  _rhs[i] = eqs[i][1]
10687  Z3_solver_propagate_consequence(e.ctx.ref(), ctypes.c_void_p(self.cb), num_fixed, _ids, num_eqs, _lhs, _rhs, e.ast)
10688 
10689  def conflict(self, ids):
10690  self.propagate(BoolVal(False, self.ctx()), ids, eqs=[])
Z3_mk_re_plus
Z3_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
z3py.PatternRef.get_id
def get_id(self)
Definition: z3py.py:1777
Z3_model_get_func_interp
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...
z3py.Reals
def Reals(names, ctx=None)
Definition: z3py.py:3106
Z3_model_eval
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_global_param_reset_all
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...
z3py.BitVecRef.__rand__
def __rand__(self, other)
Definition: z3py.py:3399
Z3_mk_unary_minus
Z3_ast Z3_API Z3_mk_unary_minus(Z3_context c, Z3_ast arg)
Create an AST node representing - arg.
Z3_fpa_is_numeral_positive
bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is positive.
z3py.fpInfinity
def fpInfinity(s, negative)
Definition: z3py.py:9335
Z3_fpa_is_numeral_inf
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.
z3py.FuncEntry.entry
entry
Definition: z3py.py:5777
Z3_pattern_to_ast
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.
z3py.RNA
def RNA(ctx=None)
Definition: z3py.py:9049
Z3_optimize_get_lower_as_vector
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 ...
Z3_solver_get_implied_lower
Z3_ast Z3_API Z3_solver_get_implied_lower(Z3_context c, Z3_solver s, Z3_ast e)
retrieve implied lower bound value for arithmetic expression. If a lower bound is implied at search l...
z3py.FiniteDomainRef.as_string
def as_string(self)
Definition: z3py.py:7303
z3py.fpLT
def fpLT(a, b, ctx=None)
Definition: z3py.py:9688
Z3_model_dec_ref
void Z3_API Z3_model_dec_ref(Z3_context c, Z3_model m)
Decrement the reference counter of the given model.
z3py.fpRoundToIntegral
def fpRoundToIntegral(rm, a, ctx=None)
Definition: z3py.py:9633
Z3_model_translate
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context dst)
translate model from context c to context dst.
z3py.BitVecRef.__rsub__
def __rsub__(self, other)
Definition: z3py.py:3353
z3py.RepeatBitVec
def RepeatBitVec(n, a)
Definition: z3py.py:4171
z3py.QuantifierRef.num_vars
def num_vars(self)
Definition: z3py.py:1963
Z3_solver_propagate_diseq
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_optimize_pop
void Z3_API Z3_optimize_pop(Z3_context c, Z3_optimize d)
Backtrack one level.
Z3_mk_string_symbol
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_apply_result_to_string
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_mk_re_option
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
z3py.Statistics.__init__
def __init__(self, stats, ctx)
Definition: z3py.py:6299
z3py.AstRef.__bool__
def __bool__(self)
Definition: z3py.py:335
Z3_mk_solver_from_tactic
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_mk_bvshl
Z3_ast Z3_API Z3_mk_bvshl(Z3_context c, Z3_ast t1, Z3_ast t2)
Shift left.
z3py.is_fprm_sort
def is_fprm_sort(s)
Definition: z3py.py:8840
z3py.get_version_string
def get_version_string()
Definition: z3py.py:73
Z3_func_entry_inc_ref
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_solver_import_model_converter
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.
z3py.Fixedpoint.add
def add(self, *args)
Definition: z3py.py:7055
Z3_to_func_decl
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.
z3py.ParamDescrsRef.__init__
def __init__(self, descr, ctx=None)
Definition: z3py.py:5136
z3py.ModelRef.get_sort
def get_sort(self, idx)
Definition: z3py.py:6140
z3py.Fixedpoint.help
def help(self)
Definition: z3py.py:7033
Z3_tactic_par_and_then
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....
z3py.Solver.push
def push(self)
Definition: z3py.py:6509
z3py.ParamDescrsRef.__repr__
def __repr__(self)
Definition: z3py.py:5180
z3py.Optimize.unsat_core
def unsat_core(self)
Definition: z3py.py:7547
z3py.RoundTowardPositive
def RoundTowardPositive(ctx=None)
Definition: z3py.py:9053
z3py.UserPropagateBase.__init__
def __init__(self, s, ctx=None)
Definition: z3py.py:10597
Z3_mk_fpa_to_fp_bv
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.
z3py.SeqRef.is_string_value
def is_string_value(self)
Definition: z3py.py:10070
z3py.Optimize.help
def help(self)
Definition: z3py.py:7435
Z3_mk_select
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.
z3py.RatNumRef.as_long
def as_long(self)
Definition: z3py.py:2865
z3py.QuantifierRef.body
def body(self)
Definition: z3py.py:1952
z3py.FreshReal
def FreshReal(prefix='b', ctx=None)
Definition: z3py.py:3134
z3py.Fixedpoint.fact
def fact(self, head, name=None)
Definition: z3py.py:7098
z3py.is_distinct
def is_distinct(a)
Definition: z3py.py:1542
z3py.enable_trace
def enable_trace(msg)
Definition: z3py.py:67
Z3_solver_to_string
Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s)
Convert a solver into a string.
z3py.Statistics.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:6304
Z3_mk_int_to_str
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
Z3_fpa_get_numeral_exponent_bv
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_params_set_uint
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_mk_re_complement
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
Z3_params_set_double
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.
z3py.Probe.__gt__
def __gt__(self, other)
Definition: z3py.py:8025
z3py.FPNumRef.exponent
def exponent(self, biased=True)
Definition: z3py.py:9152
z3py.Fixedpoint.parse_string
def parse_string(self, s)
Definition: z3py.py:7200
z3py.Goal.get
def get(self, i)
Definition: z3py.py:5304
z3py.UserPropagateBase.add_diseq
def add_diseq(self, diseq)
Definition: z3py.py:10653
z3py.BitVecRef.__xor__
def __xor__(self, other)
Definition: z3py.py:3409
Z3_tactic_inc_ref
void Z3_API Z3_tactic_inc_ref(Z3_context c, Z3_tactic t)
Increment the reference counter of the given tactic.
z3py.Optimize.param_descrs
def param_descrs(self)
Definition: z3py.py:7439
z3py.ArithRef.__pos__
def __pos__(self)
Definition: z3py.py:2437
z3py.Probe.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:8005
z3py.BitVecRef.__rxor__
def __rxor__(self, other)
Definition: z3py.py:3422
z3py.is_fprm
def is_fprm(a)
Definition: z3py.py:9077
z3py.ExprRef
Expressions.
Definition: z3py.py:893
Z3_solver_get_levels
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...
z3py.ArrayRef.domain
def domain(self)
Definition: z3py.py:4297
z3py.Optimize.ctx
ctx
Definition: z3py.py:7418
Z3_optimize_assert_and_track
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.
z3py.ArithRef.__le__
def __le__(self, other)
Definition: z3py.py:2446
z3py.ArithRef.__mod__
def __mod__(self, other)
Definition: z3py.py:2399
Z3_stats_get_double_value
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_get_probe_name
Z3_string Z3_API Z3_get_probe_name(Z3_context c, unsigned i)
Return the name of the i probe.
Z3_get_version
void Z3_API Z3_get_version(unsigned *major, unsigned *minor, unsigned *build_number, unsigned *revision_number)
Return Z3 version number information.
z3py.DatatypeSortRef
Definition: z3py.py:4915
z3py.QuantifierRef.sort
def sort(self)
Definition: z3py.py:1841
z3py.FiniteDomainNumRef.as_long
def as_long(self)
Definition: z3py.py:7323
z3py.fpIsInf
def fpIsInf(a, ctx=None)
Definition: z3py.py:9649
z3py.SeqRef.__le__
def __le__(self, other)
Definition: z3py.py:10082
Z3_fpa_get_numeral_exponent_int64
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.
z3py.FuncInterp.__copy__
def __copy__(self)
Definition: z3py.py:5975
z3py.QuantifierRef.get_id
def get_id(self)
Definition: z3py.py:1838
z3py.FuncDeclRef.range
def range(self)
Definition: z3py.py:710
z3py.Tactic.__del__
def __del__(self)
Definition: z3py.py:7720
Z3_mk_ext_rotate_left
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.
Z3_mk_bvslt
Z3_ast Z3_API Z3_mk_bvslt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than.
z3py.ArithSortRef
Arithmetic.
Definition: z3py.py:2128
Z3_model_get_sort
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.
z3py.AstRef.hash
def hash(self)
Definition: z3py.py:402
z3py.TupleSort
def TupleSort(name, sorts, ctx=None)
Definition: z3py.py:5012
z3py.FPRef.__div__
def __div__(self, other)
Definition: z3py.py:8985
Z3_mk_ge
Z3_ast Z3_API Z3_mk_ge(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than or equal to.
z3py.FPRef.sbits
def sbits(self)
Definition: z3py.py:8874
z3py.BitVecRef.__le__
def __le__(self, other)
Definition: z3py.py:3545
z3py.ScopedConstructor.__del__
def __del__(self)
Definition: z3py.py:4810
z3py.FuncEntry.arg_value
def arg_value(self, idx)
Definition: z3py.py:5806
z3py.UserPropagateBase.cb
cb
Definition: z3py.py:10602
z3py.ModelRef.evaluate
def evaluate(self, t, model_completion=False)
Definition: z3py.py:6050
Z3_solver_reset
void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s)
Remove all assertions from the solver.
Z3_mk_true
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
z3py.is_to_real
def is_to_real(a)
Definition: z3py.py:2743
z3py.fpBVToFP
def fpBVToFP(v, sort, ctx=None)
Definition: z3py.py:9820
Z3_del_context
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
z3py.FuncEntry
Definition: z3py.py:5773
z3py.ArithRef.__truediv__
def __truediv__(self, other)
Definition: z3py.py:2374
z3py.fpMinusInfinity
def fpMinusInfinity(s)
Definition: z3py.py:9330
Z3_dec_ref
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_...
z3py.OptimizeObjective.lower
def lower(self)
Definition: z3py.py:7388
Z3_parse_smtlib2_file
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_mk_bvmul_no_underflow
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_param_descrs_get_name
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.
z3py.FPs
def FPs(names, fpsort, ctx=None)
Definition: z3py.py:9424
z3py.ArithRef
Definition: z3py.py:2214
z3py.Fixedpoint.__repr__
def __repr__(self)
Definition: z3py.py:7216
z3py.BitVecNumRef.as_binary_string
def as_binary_string(self)
Definition: z3py.py:3720
Z3_ast_vector_translate
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_mk_bvmul_no_overflow
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.
z3py.AstVector.__contains__
def __contains__(self, item)
Definition: z3py.py:5595
Z3_probe_dec_ref
void Z3_API Z3_probe_dec_ref(Z3_context c, Z3_probe p)
Decrement the reference counter of the given probe.
z3py.FPSortRef.sbits
def sbits(self)
Definition: z3py.py:8762
Z3_probe_le
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...
Z3_ast_map_keys
Z3_ast_vector Z3_API Z3_ast_map_keys(Z3_context c, Z3_ast_map m)
Return the keys stored in the given map.
z3py.AstMap.keys
def keys(self)
Definition: z3py.py:5755
Z3_ast_map_size
unsigned Z3_API Z3_ast_map_size(Z3_context c, Z3_ast_map m)
Return the size of the given map.
z3py.ZeroExt
def ZeroExt(n, a)
Definition: z3py.py:4144
z3py.ParOr
def ParOr(*ts, **ks)
Definition: z3py.py:7855
Z3_get_datatype_sort_num_constructors
unsigned Z3_API Z3_get_datatype_sort_num_constructors(Z3_context c, Z3_sort t)
Return number of constructors for datatype.
Z3_ast_map_dec_ref
void Z3_API Z3_ast_map_dec_ref(Z3_context c, Z3_ast_map m)
Decrement the reference counter of the given AST map.
Z3_get_ast_kind
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.
z3py.ParamDescrsRef.__len__
def __len__(self)
Definition: z3py.py:5154
z3py.IsMember
def IsMember(e, s)
Definition: z3py.py:4692
z3py.FuncDeclRef.as_func_decl
def as_func_decl(self)
Definition: z3py.py:674
z3py.SetIntersect
def SetIntersect(*args)
Definition: z3py.py:4641
Z3_fpa_is_numeral_negative
bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is negative.
z3py.SeqRef.__lt__
def __lt__(self, other)
Definition: z3py.py:10085
Z3_optimize_dec_ref
void Z3_API Z3_optimize_dec_ref(Z3_context c, Z3_optimize d)
Decrement the reference counter of the given optimize context.
z3py.FPNumRef.isZero
def isZero(self)
Definition: z3py.py:9183
z3py.FPRef.__mod__
def __mod__(self, other)
Definition: z3py.py:9021
Z3_mk_fresh_const
Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty)
Declare and create a fresh constant.
z3py.ToInt
def ToInt(a)
Definition: z3py.py:3164
Z3_mk_zero_ext
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,...
Z3_get_as_array_func_decl
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.
z3py.ModelRef.num_sorts
def num_sorts(self)
Definition: z3py.py:6125
z3py.FuncInterp.num_entries
def num_entries(self)
Definition: z3py.py:5920
z3py.QuantifierRef.as_ast
def as_ast(self)
Definition: z3py.py:1835
z3py.DisjointSum
def DisjointSum(name, sorts, ctx=None)
Definition: z3py.py:5023
z3py.Strings
def Strings(names, ctx=None)
Definition: z3py.py:10153
Z3_fixedpoint_query
Z3_lbool Z3_API Z3_fixedpoint_query(Z3_context c, Z3_fixedpoint d, Z3_ast query)
Pose a query against the asserted rules.
z3py.is_fp
def is_fp(a)
Definition: z3py.py:9213
z3py.user_prop_fixed
def user_prop_fixed(ctx, cb, id, value)
Definition: z3py.py:10556
Z3_mk_seq_concat
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
z3py.Solver.proof
def proof(self)
Definition: z3py.py:6819
Z3_mk_config
Z3_config Z3_API Z3_mk_config(void)
Create a configuration object for the Z3 context object.
z3py.Solver.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:6934
Z3_tactic_fail_if
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.
z3py.SetHasSize
def SetHasSize(a, k)
Definition: z3py.py:4574
z3py.RealSort
def RealSort(ctx=None)
Definition: z3py.py:2958
Z3_optimize_get_reason_unknown
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.
Z3_mk_fpa_to_ubv
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.
z3py.ParamsRef.__init__
def __init__(self, ctx=None, params=None)
Definition: z3py.py:5072
z3py.Solver.cube
def cube(self, vars=None)
Definition: z3py.py:6791
z3py.BitVecRef.__rlshift__
def __rlshift__(self, other)
Definition: z3py.py:3667
z3py.ModelRef
Definition: z3py.py:6001
z3py.is_array_sort
def is_array_sort(a)
Definition: z3py.py:4331
Z3_inc_ref
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_...
z3py.FPVal
def FPVal(sig, exp=None, fps=None, ctx=None)
Definition: z3py.py:9357
z3py.Goal.add
def add(self, *args)
Definition: z3py.py:5369
Z3_mk_fpa_sort_64
Z3_sort Z3_API Z3_mk_fpa_sort_64(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
Z3_translate
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...
z3py.RealVarVector
def RealVarVector(n, ctx=None)
Definition: z3py.py:1373
Z3_fixedpoint_update_rule
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.
z3py.fpToUBV
def fpToUBV(rm, x, s, ctx=None)
Definition: z3py.py:9936
Z3_mk_gt
Z3_ast Z3_API Z3_mk_gt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than.
Z3_tactic_try_for
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...
z3py.Consts
def Consts(names, sort)
Definition: z3py.py:1332
z3py.RTP
def RTP(ctx=None)
Definition: z3py.py:9057
z3py.ArrayRef.range
def range(self)
Definition: z3py.py:4306
Z3_get_symbol_kind
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_get_decl_ast_parameter
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.
z3py.user_prop_fresh
def user_prop_fresh(id, ctx)
Definition: z3py.py:10549
Z3_append_log
void Z3_API Z3_append_log(Z3_string string)
Append user-defined string to interaction log.
Z3_probe_const
Z3_probe Z3_API Z3_probe_const(Z3_context x, double val)
Return a probe that always evaluates to val.
Z3_solver_get_proof
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_fixedpoint_from_string
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_get_quantifier_pattern_ast
Z3_pattern Z3_API Z3_get_quantifier_pattern_ast(Z3_context c, Z3_ast a, unsigned i)
Return i'th pattern.
Z3_param_descrs_to_string
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...
z3py.TransitiveClosure
def TransitiveClosure(f)
Definition: z3py.py:10500
z3py.FPRef.__sub__
def __sub__(self, other)
Definition: z3py.py:8921
z3py.Var
def Var(idx, s)
Definition: z3py.py:1351
z3py.FuncEntry.num_args
def num_args(self)
Definition: z3py.py:5788
z3py.Fixedpoint.query
def query(self, *query)
Definition: z3py.py:7102
z3py.Optimize.set
def set(self, *args, **keys)
Definition: z3py.py:7429
z3py.AtLeast
def AtLeast(*args)
Definition: z3py.py:8385
Z3_mk_fpa_zero
Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative)
Create a floating-point zero of sort s.
z3py.probes
def probes(ctx=None)
Definition: z3py.py:8135
z3py.SignExt
def SignExt(n, a)
Definition: z3py.py:4115
z3py.AstVector.push
def push(self, v)
Definition: z3py.py:5570
z3py.FPNumRef.isNormal
def isNormal(self)
Definition: z3py.py:9187
Z3_mk_fpa_round_toward_positive
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::range
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3518
Z3_goal_precision
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...
z3py.BVSubNoOverflow
def BVSubNoOverflow(a, b)
Definition: z3py.py:4218
Z3_get_app_num_args
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_mk_re_full
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
z3py.ParamDescrsRef.get_kind
def get_kind(self, n)
Definition: z3py.py:5164
Z3_get_app_decl
Z3_func_decl Z3_API Z3_get_app_decl(Z3_context c, Z3_app a)
Return the declaration of a constant or function application.
z3py.parse_smt2_string
def parse_smt2_string(s, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8640
z3py.reset_params
def reset_params()
Definition: z3py.py:263
z3py.ULT
def ULT(a, b)
Definition: z3py.py:3943
z3py.Optimize.lower
def lower(self, obj)
Definition: z3py.py:7550
Z3_get_ast_hash
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...
z3py.Context.__init__
def __init__(self, *args, **kws)
Definition: z3py.py:172
Z3_mk_bv2int
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...
Z3_get_lstring
Z3_char_ptr Z3_API Z3_get_lstring(Z3_context c, Z3_ast s, unsigned *length)
Retrieve the unescaped string constant stored in s.
z3py.Datatype.declare_core
def declare_core(self, name, rec_name, *args)
Definition: z3py.py:4759
Z3_get_numeral_binary_string
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.
z3py.RoundTowardNegative
def RoundTowardNegative(ctx=None)
Definition: z3py.py:9061
z3py.Datatype.ctx
ctx
Definition: z3py.py:4750
z3py.ApplyResult.__init__
def __init__(self, result, ctx)
Definition: z3py.py:7611
Z3_mk_and
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].
z3py.BitVecSortRef.size
def size(self)
Definition: z3py.py:3230
z3py.ApplyResult.__repr__
def __repr__(self)
Definition: z3py.py:7659
Z3_apply_result_get_num_subgoals
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.
z3py.ArithSortRef.is_int
def is_int(self)
Definition: z3py.py:2145
z3py.QuantifierRef.var_name
def var_name(self, idx)
Definition: z3py.py:1975
z3py.set_param
def set_param(*args, **kws)
Definition: z3py.py:240
z3py.Datatype.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:4754
z3py.RatVal
def RatVal(a, b, ctx=None)
Definition: z3py.py:3018
z3py.IntVal
def IntVal(val, ctx=None)
Definition: z3py.py:2989
z3py.FuncDeclRef.params
def params(self)
Definition: z3py.py:731
z3py.SetDifference
def SetDifference(a, b)
Definition: z3py.py:4682
z3py.AlgebraicNumRef.poly
def poly(self)
Definition: z3py.py:2924
z3py.Solver.translate
def translate(self, target)
Definition: z3py.py:6918
z3py.BoolSortRef.cast
def cast(self, val)
Definition: z3py.py:1392
Z3_solver_get_reason_unknown
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_get_decl_int_parameter
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.
Z3_add_rec_def
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.
z3py.fpToFP
def fpToFP(a1, a2=None, a3=None, ctx=None)
Definition: z3py.py:9782
z3py.ModelRef.eval
def eval(self, t, model_completion=False)
Definition: z3py.py:6021
z3py.FuncInterp.ctx
ctx
Definition: z3py.py:5886
Z3_solver_pop
void Z3_API Z3_solver_pop(Z3_context c, Z3_solver s, unsigned n)
Backtrack n backtracking points.
z3py.FPRef.__le__
def __le__(self, other)
Definition: z3py.py:8886
Z3_params_to_string
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...
z3py.ExprRef.__ne__
def __ne__(self, other)
Definition: z3py.py:953
Z3_fixedpoint_set_params
void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint f, Z3_params p)
Set parameters on fixedpoint context.
Z3_interrupt
void Z3_API Z3_interrupt(Z3_context c)
Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers,...
z3py.Tactic.__init__
def __init__(self, tactic, ctx=None)
Definition: z3py.py:7703
z3py.Datatype.__repr__
def __repr__(self)
Definition: z3py.py:4786
z3py.FPRMSortRef
Definition: z3py.py:8826
z3py.BitVecRef.__div__
def __div__(self, other)
Definition: z3py.py:3463
z3py.BitVecRef.__ge__
def __ge__(self, other)
Definition: z3py.py:3593
Z3_ast_map_insert
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.
Z3_optimize_from_string
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....
z3py.FuncInterp.__del__
def __del__(self)
Definition: z3py.py:5893
z3py.AstRef.ast
ast
Definition: z3py.py:308
z3py.fpGT
def fpGT(a, b, ctx=None)
Definition: z3py.py:9710
z3py.Goal.inconsistent
def inconsistent(self)
Definition: z3py.py:5230
z3py.tactics
def tactics(ctx=None)
Definition: z3py.py:7944
z3py.Fixedpoint.to_string
def to_string(self, queries)
Definition: z3py.py:7225
z3py.Optimize.optimize
optimize
Definition: z3py.py:7419
z3py.FPRef.__ge__
def __ge__(self, other)
Definition: z3py.py:8892
Z3_optimize_get_objectives
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...
z3py.SeqRef
Definition: z3py.py:10045
Z3_mk_set_has_size
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.
z3py.FPNumRef.significand
def significand(self)
Definition: z3py.py:9124
Z3_get_quantifier_num_no_patterns
unsigned Z3_API Z3_get_quantifier_num_no_patterns(Z3_context c, Z3_ast a)
Return number of no_patterns used in quantifier.
z3py.fpUnsignedToFP
def fpUnsignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9889
z3py.Solver.ctx
ctx
Definition: z3py.py:6482
z3py.FPNumRef
FP Numerals.
Definition: z3py.py:9095
z3py.IsInt
def IsInt(a)
Definition: z3py.py:3181
Z3_goal_size
unsigned Z3_API Z3_goal_size(Z3_context c, Z3_goal g)
Return the number of formulas in the given goal.
z3py.RTN
def RTN(ctx=None)
Definition: z3py.py:9065
z3py.Datatype
Definition: z3py.py:4723
z3py.Solver.cube_vars
def cube_vars(self)
Definition: z3py.py:6812
Z3_mk_set_del
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
z3py.Fixedpoint.register_relation
def register_relation(self, *relations)
Definition: z3py.py:7184
z3py.AstVector.__repr__
def __repr__(self)
Definition: z3py.py:5637
Z3_func_decl_to_ast
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.
z3py.is_arith_sort
def is_arith_sort(s)
Definition: z3py.py:2199
Z3_set_param_value
void Z3_API Z3_set_param_value(Z3_config c, Z3_string param_id, Z3_string param_value)
Set a configuration parameter.
z3py.RotateLeft
def RotateLeft(a, b)
Definition: z3py.py:4085
Z3_mk_fpa_round_nearest_ties_to_even
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.
z3py.Or
def Or(*args)
Definition: z3py.py:1732
Z3_stats_is_uint
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.
z3py.SeqRef.__ge__
def __ge__(self, other)
Definition: z3py.py:10088
Z3_mk_goal
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...
z3py.Fixedpoint.add_rule
def add_rule(self, head, body=None, name=None)
Definition: z3py.py:7071
z3py.RatNumRef.numerator_as_long
def numerator_as_long(self)
Definition: z3py.py:2832
Z3_mk_seq_suffix
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.
z3py.Fixedpoint.add_cover
def add_cover(self, level, predicate, property)
Definition: z3py.py:7180
z3py.TreeOrder
def TreeOrder(a, index)
Definition: z3py.py:10494
z3py.Optimize.__repr__
def __repr__(self)
Definition: z3py.py:7586
z3py.BoolVector
def BoolVector(prefix, sz, ctx=None)
Definition: z3py.py:1614
Z3_mk_xor
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
z3py.AstRef.get_id
def get_id(self)
Definition: z3py.py:358
Z3_mk_tactic
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...
z3py.AstRef.__init__
def __init__(self, ast, ctx=None)
Definition: z3py.py:307
Z3_mk_bvneg_no_overflow
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.
z3py.Loop
def Loop(re, lo, hi=0)
Definition: z3py.py:10462
z3py.SubSeq
def SubSeq(s, offset, length)
Definition: z3py.py:10164
Z3_mk_fpa_fp
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.
z3py.ensure_prop_closures
def ensure_prop_closures()
Definition: z3py.py:10538
Z3_param_descrs_size
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.
z3py.SimpleSolver
def SimpleSolver(ctx=None, logFile=None)
Definition: z3py.py:6988
z3py.AstVector.__len__
def __len__(self)
Definition: z3py.py:5517
Z3_mk_bvmul
Z3_ast Z3_API Z3_mk_bvmul(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement multiplication.
Z3_solver_check_assumptions
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.
z3py.UserPropagateBase._ctx
_ctx
Definition: z3py.py:10601
z3py.With
def With(t, *args, **keys)
Definition: z3py.py:7891
Z3_optimize_get_statistics
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.
z3py.Solver.to_smt2
def to_smt2(self)
Definition: z3py.py:6952
Z3_mk_full_set
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
Z3_optimize_get_assertions
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.
z3py.FPRMRef.as_string
def as_string(self)
Definition: z3py.py:9032
Z3_ast_map_inc_ref
void Z3_API Z3_ast_map_inc_ref(Z3_context c, Z3_ast_map m)
Increment the reference counter of the given AST map.
z3py.is_select
def is_select(a)
Definition: z3py.py:4579
z3py.simplify
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8239
Z3_is_eq_ast
bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast t1, Z3_ast t2)
Compare terms.
z3py.AstRef.sexpr
def sexpr(self)
Definition: z3py.py:345
Z3_get_decl_parameter_kind
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_mk_solver_for_logic
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...
z3py.FiniteDomainSortRef.size
def size(self)
Definition: z3py.py:7270
Z3_simplify_get_help
Z3_string Z3_API Z3_simplify_get_help(Z3_context c)
Return a string describing all available parameters.
z3py.AstVector.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5510
Z3_fixedpoint_inc_ref
void Z3_API Z3_fixedpoint_inc_ref(Z3_context c, Z3_fixedpoint d)
Increment the reference counter of the given fixedpoint context.
z3py.QuantifierRef.var_sort
def var_sort(self, idx)
Definition: z3py.py:1991
z3py.FiniteDomainRef
Definition: z3py.py:7296
z3py.SeqSortRef.is_string
def is_string(self)
Definition: z3py.py:10012
z3py.Fixedpoint.sexpr
def sexpr(self)
Definition: z3py.py:7220
Z3_optimize_get_param_descrs
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.
Z3_mk_or
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].
z3py.Solver.sexpr
def sexpr(self)
Definition: z3py.py:6937
z3py.Solver.__copy__
def __copy__(self)
Definition: z3py.py:6931
Z3_algebraic_get_i
unsigned Z3_API Z3_algebraic_get_i(Z3_context c, Z3_ast a)
Return which root of the polynomial the algebraic number represents.
z3py.StringSort
def StringSort(ctx=None)
Definition: z3py.py:10027
Z3_get_seq_sort_basis
Z3_sort Z3_API Z3_get_seq_sort_basis(Z3_context c, Z3_sort s)
Retrieve basis sort for sequence sort.
Z3_solver_propagate_init
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.
z3py.is_gt
def is_gt(a)
Definition: z3py.py:2721
z3py.QuantifierRef.num_no_patterns
def num_no_patterns(self)
Definition: z3py.py:1942
Z3_mk_finite_domain_sort
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_mk_set_union
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.
z3py.Optimize.__init__
def __init__(self, ctx=None)
Definition: z3py.py:7417
z3py.UserPropagateBase.pop
def pop(self, num_scopes)
Definition: z3py.py:10662
z3py.Solver.param_descrs
def param_descrs(self)
Definition: z3py.py:6910
Z3_fixedpoint_get_help
Z3_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint f)
Return a string describing all fixedpoint available parameters.
Z3_mk_set_intersect
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.
z3py.BitVecRef.__neg__
def __neg__(self)
Definition: z3py.py:3441
z3py.Optimize.minimize
def minimize(self, arg)
Definition: z3py.py:7515
z3py.ReRef
Definition: z3py.py:10363
z3py.Tactic.__call__
def __call__(self, goal, *arguments, **keywords)
Definition: z3py.py:7758
z3py.BitVecRef.__rdiv__
def __rdiv__(self, other)
Definition: z3py.py:3486
z3py.SeqRef.at
def at(self, i)
Definition: z3py.py:10062
z3py.Exists
def Exists(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2082
Z3_ast_vector_push
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.
z3py.is_implies
def is_implies(a)
Definition: z3py.py:1511
z3py.AstMap.__repr__
def __repr__(self)
Definition: z3py.py:5723
z3py.to_symbol
def to_symbol(s, ctx=None)
Definition: z3py.py:109
z3py.ArithRef.__ge__
def __ge__(self, other)
Definition: z3py.py:2485
Z3_func_interp_get_else
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.
z3py.is_map
def is_map(a)
Definition: z3py.py:4372
z3py.is_or
def is_or(a)
Definition: z3py.py:1500
Z3_get_decl_rational_parameter
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.
z3py.SeqRef.is_string
def is_string(self)
Definition: z3py.py:10067
Z3_fixedpoint_query_relations
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.
z3py.ArraySortRef
Arrays.
Definition: z3py.py:4264
z3py.ReRef.__add__
def __add__(self, other)
Definition: z3py.py:10366
z3py.fpMul
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9554
Z3_mk_distinct
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]).
z3py.Solver.dimacs
def dimacs(self, include_names=True)
Definition: z3py.py:6948
Z3_simplify_ex
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
z3py.SeqRef.__add__
def __add__(self, other)
Definition: z3py.py:10051
Z3_fixedpoint_from_file
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....
z3py.FPRef.sort
def sort(self)
Definition: z3py.py:8855
z3py.fpGEQ
def fpGEQ(a, b, ctx=None)
Definition: z3py.py:9721
z3py.ScopedConstructor.ctx
ctx
Definition: z3py.py:4809
z3py.is_string_value
def is_string_value(a)
Definition: z3py.py:10130
Z3_solver_push
void Z3_API Z3_solver_push(Z3_context c, Z3_solver s)
Create a backtracking point.
z3py.IndexOf
def IndexOf(s, substr)
Definition: z3py.py:10273
z3py.is_app
def is_app(a)
Definition: z3py.py:1157
z3py.fpEQ
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9732
Z3_mk_rec_func_decl
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.
Z3_model_get_const_decl
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.
Z3_mk_empty_set
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
z3py.AstRef.translate
def translate(self, target)
Definition: z3py.py:383
z3py.LShR
def LShR(a, b)
Definition: z3py.py:4054
z3py.CheckSatResult.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:6441
z3py.Statistics.ctx
ctx
Definition: z3py.py:6301
Z3_goal_formula
Z3_ast Z3_API Z3_goal_formula(Z3_context c, Z3_goal g, unsigned idx)
Return a formula from the given goal.
z3py.is_default
def is_default(a)
Definition: z3py.py:4387
Z3_optimize_assert_soft
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.
z3py.AlgebraicNumRef
Definition: z3py.py:2899
z3py.AstVector.__init__
def __init__(self, v=None, ctx=None)
Definition: z3py.py:5499
z3py.Solver.consequences
def consequences(self, assumptions, variables)
Definition: z3py.py:6755
Z3_solver_propagate_eq
void Z3_API Z3_solver_propagate_eq(Z3_context c, Z3_solver s, Z3_eq_eh eq_eh)
register a callback on expression equalities.
z3py.FPRef.__add__
def __add__(self, other)
Definition: z3py.py:8898
z3py.fpRem
def fpRem(a, b, ctx=None)
Definition: z3py.py:9582
z3py.UserPropagateBase.add_final
def add_final(self, final)
Definition: z3py.py:10641
Z3_get_quantifier_num_patterns
unsigned Z3_API Z3_get_quantifier_num_patterns(Z3_context c, Z3_ast a)
Return number of patterns used in quantifier.
z3py.substitute
def substitute(t, *m)
Definition: z3py.py:8271
z3py.Union
def Union(*args)
Definition: z3py.py:10386
Z3_is_numeral_ast
bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a)
z3py.fpMinusZero
def fpMinusZero(s)
Definition: z3py.py:9346
z3py.Statistics
Statistics.
Definition: z3py.py:6296
z3py.Solver.set
def set(self, *args, **keys)
Definition: z3py.py:6497
z3py.Goal
Definition: z3py.py:5189
z3py.RotateRight
def RotateRight(a, b)
Definition: z3py.py:4100
z3py.FiniteDomainSort
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7278
Z3_get_numeral_string
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.
Z3_ast_vector_size
unsigned Z3_API Z3_ast_vector_size(Z3_context c, Z3_ast_vector v)
Return the size of the given AST vector.
z3py.is_ge
def is_ge(a)
Definition: z3py.py:2710
z3py.is_and
def is_and(a)
Definition: z3py.py:1489
Z3_mk_model
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
Z3_mk_re_loop
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...
z3py.AstMap.reset
def reset(self)
Definition: z3py.py:5740
Z3_goal_depth
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.
z3py.Fixedpoint.ctx
ctx
Definition: z3py.py:7011
z3py.ExprRef.sort_kind
def sort_kind(self)
Definition: z3py.py:921
z3py.MultiPattern
def MultiPattern(*args)
Definition: z3py.py:1797
Z3_optimize_maximize
unsigned Z3_API Z3_optimize_maximize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a maximization constraint.
Z3_mk_linear_order
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_is_as_array
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....
z3py.PrefixOf
def PrefixOf(a, b)
Definition: z3py.py:10212
z3py.InRe
def InRe(s, re)
Definition: z3py.py:10373
z3py.BoolSortRef.is_int
def is_int(self)
Definition: z3py.py:1417
z3py.RatNumRef.is_int_value
def is_int_value(self)
Definition: z3py.py:2862
Z3_mk_fpa_to_sbv
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.
z3py.ArrayRef.default
def default(self)
Definition: z3py.py:4328
z3py.RatNumRef.as_fraction
def as_fraction(self)
Definition: z3py.py:2890
Z3_fixedpoint_get_answer
Z3_ast Z3_API Z3_fixedpoint_get_answer(Z3_context c, Z3_fixedpoint d)
Retrieve a formula that encodes satisfying answers to the query.
z3py.Fixedpoint.abstract
def abstract(self, fml, is_forall=True)
Definition: z3py.py:7252
Z3_optimize_to_string
Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o)
Print the current context as a string.
Z3_mk_add
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].
z3py.FuncDeclRef.kind
def kind(self)
Definition: z3py.py:719
z3py.z3_error_handler
def z3_error_handler(c, e)
Definition: z3py.py:156
Z3_tactic_dec_ref
void Z3_API Z3_tactic_dec_ref(Z3_context c, Z3_tactic g)
Decrement the reference counter of the given tactic.
z3py.And
def And(*args)
Definition: z3py.py:1700
z3py.Statistics.__len__
def __len__(self)
Definition: z3py.py:6329
Z3_is_quantifier_forall
bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a)
Determine if an ast is a universal quantifier.
Z3_is_string
bool Z3_API Z3_is_string(Z3_context c, Z3_ast s)
Determine if s is a string constant.
z3py.ParamDescrsRef.ctx
ctx
Definition: z3py.py:5138
z3py.UGE
def UGE(a, b)
Definition: z3py.py:3960
z3py.Cbrt
def Cbrt(a, ctx=None)
Definition: z3py.py:3209
z3py.disable_trace
def disable_trace(msg)
Definition: z3py.py:70
z3py.Z3PPObject
ASTs base class.
Definition: z3py.py:292
z3py.FuncEntry.__init__
def __init__(self, entry, ctx)
Definition: z3py.py:5776
z3py.Float64
def Float64(ctx=None)
Definition: z3py.py:8806
z3py.UserPropagateBase.push
def push(self)
Definition: z3py.py:10659
z3py.BitVecVal
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3795
Z3_set_ast_print_mode
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.
z3py.FPNumRef.isSubnormal
def isSubnormal(self)
Definition: z3py.py:9191
Z3_mk_bvugt
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
z3py.ScopedConstructor.c
c
Definition: z3py.py:4808
Z3_solver_get_assertions
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_mk_seq_prefix
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.
z3py.is_K
def is_K(a)
Definition: z3py.py:4360
Z3_param_descrs_dec_ref
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.
z3py.BitVecRef.__radd__
def __radd__(self, other)
Definition: z3py.py:3307
z3py.Float32
def Float32(ctx=None)
Definition: z3py.py:8796
z3py.BoolRef.sort
def sort(self)
Definition: z3py.py:1426
z3py.AstMap.__setitem__
def __setitem__(self, k, v)
Definition: z3py.py:5707
z3py.Range
def Range(lo, hi, ctx=None)
Definition: z3py.py:10474
Z3_mk_pattern
Z3_pattern Z3_API Z3_mk_pattern(Z3_context c, unsigned num_patterns, Z3_ast const terms[])
Create a pattern for quantifier instantiation.
Z3_get_algebraic_number_upper
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...
z3py.FPNumRef.exponent_as_long
def exponent_as_long(self, biased=True)
Definition: z3py.py:9161
z3py.BitVecRef.__or__
def __or__(self, other)
Definition: z3py.py:3363
Z3_mk_fpa_to_fp_signed
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.
z3py.Cond
def Cond(p, t1, t2, ctx=None)
Definition: z3py.py:8223
z3py.FPRef.__truediv__
def __truediv__(self, other)
Definition: z3py.py:9013
z3py.AstVector
Definition: z3py.py:5496
z3py.QuantifierRef.is_forall
def is_forall(self)
Definition: z3py.py:1847
Z3_mk_app
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.
z3py.FuncInterp.f
f
Definition: z3py.py:5885
z3py.is_fp_value
def is_fp_value(a)
Definition: z3py.py:9226
z3py.is_finite_domain_sort
def is_finite_domain_sort(s)
Definition: z3py.py:7285
Z3_mk_concat
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
z3py.Optimize.sexpr
def sexpr(self)
Definition: z3py.py:7590
z3py.fpMax
def fpMax(a, b, ctx=None)
Definition: z3py.py:9609
Z3_mk_implies
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
Z3_solver_propagate_consequence
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...
z3py.Solver.from_file
def from_file(self, filename)
Definition: z3py.py:6783
z3py.RealVal
def RealVal(val, ctx=None)
Definition: z3py.py:3000
z3py.Solver.non_units
def non_units(self)
Definition: z3py.py:6842
z3py.PbLe
def PbLe(args, k)
Definition: z3py.py:8427
z3py.ModelRef.translate
def translate(self, target)
Definition: z3py.py:6263
z3py.solve
def solve(*args, **keywords)
Definition: z3py.py:8458
z3py.FPRef.__rdiv__
def __rdiv__(self, other)
Definition: z3py.py:9000
Z3_algebraic_get_poly
Z3_ast_vector Z3_API Z3_algebraic_get_poly(Z3_context c, Z3_ast a)
Return the coefficients of the defining polynomial.
z3py.RoundNearestTiesToEven
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:9037
Z3_mk_seq_unit
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
z3py.Const
def Const(name, sort)
Definition: z3py.py:1321
Z3_get_sort_kind
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_mk_pbeq
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.
z3py.FuncDeclRef.arity
def arity(self)
Definition: z3py.py:688
z3py.ParamDescrsRef.__getitem__
def __getitem__(self, arg)
Definition: z3py.py:5174
Z3_mk_numeral
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
Z3_fpa_get_numeral_significand_uint64
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_mk_bvadd_no_overflow
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.
z3py.ForAll
def ForAll(vs, body, weight=1, qid="", skid="", patterns=[], no_patterns=[])
Definition: z3py.py:2065
Z3_params_set_bool
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.
Z3_fixedpoint_dec_ref
void Z3_API Z3_fixedpoint_dec_ref(Z3_context c, Z3_fixedpoint d)
Decrement the reference counter of the given fixedpoint context.
z3py.fpToFPUnsigned
def fpToFPUnsigned(rm, x, s, ctx=None)
Definition: z3py.py:9906
z3py.Fixedpoint.set_predicate_representation
def set_predicate_representation(self, f, *representations)
Definition: z3py.py:7190
Z3_mk_real2int
Z3_ast Z3_API Z3_mk_real2int(Z3_context c, Z3_ast t1)
Coerce a real to an integer.
z3py.SortRef.as_ast
def as_ast(self)
Definition: z3py.py:513
z3py.FloatQuadruple
def FloatQuadruple(ctx=None)
Definition: z3py.py:8821
Z3_ast_map_reset
void Z3_API Z3_ast_map_reset(Z3_context c, Z3_ast_map m)
Remove all keys from the given map.
z3py.ApplyResult.result
result
Definition: z3py.py:7612
Z3_mk_bvnot
Z3_ast Z3_API Z3_mk_bvnot(Z3_context c, Z3_ast t1)
Bitwise negation.
z3py.BitVecRef
Definition: z3py.py:3269
z3py.eq
def eq(a, b)
Definition: z3py.py:432
z3py.fpAbs
def fpAbs(a, ctx=None)
Definition: z3py.py:9442
z3py.FuncEntry.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5781
z3py.UserPropagateBase.__del__
def __del__(self)
Definition: z3py.py:10622
Z3_stats_get_uint_value
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.
z3py.AstMap.ctx
ctx
Definition: z3py.py:5655
z3py.Optimize.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7422
Z3_mk_bvredor
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
z3py.If
def If(a, b, c, ctx=None)
Definition: z3py.py:1268
z3py.FPRef.__neg__
def __neg__(self)
Definition: z3py.py:8976
Z3_mk_fpa_sort
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
Z3_ast_to_string
Z3_string Z3_API Z3_ast_to_string(Z3_context c, Z3_ast a)
Convert the given AST node into a string.
Z3_fpa_get_sbits
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.
z3py.RatNumRef.denominator_as_long
def denominator_as_long(self)
Definition: z3py.py:2845
Z3_fpa_get_numeral_sign_bv
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.
z3py.ArithRef.__neg__
def __neg__(self)
Definition: z3py.py:2426
Z3_mk_fpa_to_fp_unsigned
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.
z3py.FPRef.ebits
def ebits(self)
Definition: z3py.py:8866
z3py.set_default_rounding_mode
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8697
z3py.ParamDescrsRef.get_documentation
def get_documentation(self, n)
Definition: z3py.py:5169
z3py.Goal.__repr__
def __repr__(self)
Definition: z3py.py:5409
Z3_mk_fpa_to_fp_real
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.
z3py.is_array
def is_array(a)
Definition: z3py.py:4335
z3py.BitVecRef.__add__
def __add__(self, other)
Definition: z3py.py:3294
z3py.ArithRef.__rpow__
def __rpow__(self, other)
Definition: z3py.py:2337
Z3_mk_seq_length
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
Z3_ast_map_contains
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_mk_re_star
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
z3py.ExprRef.__eq__
def __eq__(self, other)
Definition: z3py.py:932
z3py.Optimize.lower_values
def lower_values(self, obj)
Definition: z3py.py:7560
z3py.mk_not
def mk_not(a)
Definition: z3py.py:1687
Z3_mk_array_default
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 ...
z3py.Optimize.pop
def pop(self)
Definition: z3py.py:7523
Z3_mk_fpa_sort_quadruple
Z3_sort Z3_API Z3_mk_fpa_sort_quadruple(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_mk_array_ext
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_sort_to_ast
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_mk_map
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.
z3py.get_as_array_func
def get_as_array_func(n)
Definition: z3py.py:6285
z3py.ApplyResult.__getitem__
def __getitem__(self, idx)
Definition: z3py.py:7642
Z3_mk_quantifier_const_ex
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_func_interp_get_entry
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...
z3py.fpFMA
def fpFMA(rm, a, b, c, ctx=None)
Definition: z3py.py:9623
z3py.is_not
def is_not(a)
Definition: z3py.py:1522
z3py.Int
def Int(name, ctx=None)
Definition: z3py.py:3045
Z3_mk_eq
Z3_ast Z3_API Z3_mk_eq(Z3_context c, Z3_ast l, Z3_ast r)
Create an AST node representing l = r.
Z3_simplify_get_param_descrs
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
Z3_mk_fpa_to_real
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.
z3py.AstRef.__str__
def __str__(self)
Definition: z3py.py:320
z3py.open_log
def open_log(fname)
Definition: z3py.py:101
Z3_stats_size
unsigned Z3_API Z3_stats_size(Z3_context c, Z3_stats s)
Return the number of statistical data in s.
z3py.SortRef
Definition: z3py.py:511
Z3_solver_to_dimacs_string
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.
z3py.Tactic.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7717
z3py.ModelRef.__copy__
def __copy__(self)
Definition: z3py.py:6271
z3py.ArithRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:2290
z3py.simplify_param_descrs
def simplify_param_descrs()
Definition: z3py.py:8267
z3py.EmptySet
def EmptySet(s)
Definition: z3py.py:4613
z3py.FPRef.__lt__
def __lt__(self, other)
Definition: z3py.py:8889
z3py.FPNumRef.exponent_as_bv
def exponent_as_bv(self, biased=True)
Definition: z3py.py:9171
z3py.SuffixOf
def SuffixOf(a, b)
Definition: z3py.py:10226
z3py.FPNumRef.sign
def sign(self)
Definition: z3py.py:9105
z3py.Context.eh
eh
Definition: z3py.py:187
z3py.user_prop_eq
def user_prop_eq(ctx, cb, x, y)
Definition: z3py.py:10568
z3py.BitVecRef.__sub__
def __sub__(self, other)
Definition: z3py.py:3340
z3py.Solver.__iadd__
def __iadd__(self, fml)
Definition: z3py.py:6615
z3py.fpSignedToFP
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9872
z3py.CheckSatResult.__eq__
def __eq__(self, other)
Definition: z3py.py:6444
z3py.get_default_rounding_mode
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8683
z3py.Statistics.__getitem__
def __getitem__(self, idx)
Definition: z3py.py:6343
Z3_solver_get_param_descrs
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.
z3py.PbEq
def PbEq(args, k, ctx=None)
Definition: z3py.py:8447
Z3_mk_set_complement
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
Z3_params_dec_ref
void Z3_API Z3_params_dec_ref(Z3_context c, Z3_params p)
Decrement the reference counter of the given parameter set.
z3py.CheckSatResult.__init__
def __init__(self, r)
Definition: z3py.py:6438
z3py.DatatypeRef
Definition: z3py.py:5006
Z3_mk_fpa_neg
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
z3py.BitVecSortRef.subsort
def subsort(self, other)
Definition: z3py.py:3239
z3py.is_fprm_value
def is_fprm_value(a)
Definition: z3py.py:9089
z3py.AstRef.ctx_ref
def ctx_ref(self)
Definition: z3py.py:362
z3py.RatNumRef.denominator
def denominator(self)
Definition: z3py.py:2821
z3py.Context
Definition: z3py.py:161
z3py.RatNumRef.is_int
def is_int(self)
Definition: z3py.py:2856
Z3_get_denominator
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.
z3py.BoolSortRef.subsort
def subsort(self, other)
Definition: z3py.py:1414
z3py.user_prop_diseq
def user_prop_diseq(ctx, cb, x, y)
Definition: z3py.py:10574
Z3_ast_map_find
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_tactic_using_params
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.
z3py.OptimizeObjective.value
def value(self)
Definition: z3py.py:7404
z3py.Solver.model
def model(self)
Definition: z3py.py:6700
z3py.AstMap.__getitem__
def __getitem__(self, key)
Definition: z3py.py:5696
z3py.ScopedConstructorList.c
c
Definition: z3py.py:4817
z3py.BVRedOr
def BVRedOr(a)
Definition: z3py.py:4200
z3py.BitVecRef.__lt__
def __lt__(self, other)
Definition: z3py.py:3561
z3py.AstRef.__hash__
def __hash__(self)
Definition: z3py.py:329
z3py.BitVecRef.__mul__
def __mul__(self, other)
Definition: z3py.py:3317
z3py.Goal.insert
def insert(self, *args)
Definition: z3py.py:5358
z3py.is_quantifier
def is_quantifier(a)
Definition: z3py.py:2018
Z3_mk_bvsge
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.
z3py.FPSortRef.cast
def cast(self, val)
Definition: z3py.py:8770
z3py.Tactic.tactic
tactic
Definition: z3py.py:7705
Z3_mk_seq_last_index
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,...
z3py.Length
def Length(s)
Definition: z3py.py:10302
Z3_get_quantifier_weight
unsigned Z3_API Z3_get_quantifier_weight(Z3_context c, Z3_ast a)
Obtain weight of quantifier.
z3py.get_ctx
def get_ctx(ctx)
Definition: z3py.py:237
Z3_mk_bvadd
Z3_ast Z3_API Z3_mk_bvadd(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement addition.
z3py.Solver.from_string
def from_string(self, s)
Definition: z3py.py:6787
z3py.Goal.dimacs
def dimacs(self, include_names=True)
Definition: z3py.py:5416
Z3_stats_to_string
Z3_string Z3_API Z3_stats_to_string(Z3_context c, Z3_stats s)
Convert a statistics into a string.
z3py.DatatypeRef.sort
def sort(self)
Definition: z3py.py:5008
z3py.BVAddNoOverflow
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4206
z3py.is_eq
def is_eq(a)
Definition: z3py.py:1533
z3py.Fixedpoint.get_assertions
def get_assertions(self)
Definition: z3py.py:7212
z3py.AstMap.__del__
def __del__(self)
Definition: z3py.py:5666
Z3_mk_constructor
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.
z3py.FPRef.__rmod__
def __rmod__(self, other)
Definition: z3py.py:9025
z3py.ApplyResult.__del__
def __del__(self)
Definition: z3py.py:7619
Z3_is_quantifier_exists
bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a)
Determine if ast is an existential quantifier.
z3py.fpIsNaN
def fpIsNaN(a, ctx=None)
Definition: z3py.py:9638
z3py.Fixedpoint.get_cover_delta
def get_cover_delta(self, level, predicate)
Definition: z3py.py:7175
Z3_ast_vector_to_string
Z3_string Z3_API Z3_ast_vector_to_string(Z3_context c, Z3_ast_vector v)
Convert AST vector into a string.
z3py.PropClosures.bases
bases
Definition: z3py.py:10510
z3py.URem
def URem(a, b)
Definition: z3py.py:4014
z3py.is_const
def is_const(a)
Definition: z3py.py:1182
Z3_ast_vector_dec_ref
void Z3_API Z3_ast_vector_dec_ref(Z3_context c, Z3_ast_vector v)
Decrement the reference counter of the given AST vector.
z3py.ArithRef.__rtruediv__
def __rtruediv__(self, other)
Definition: z3py.py:2395
z3py.Star
def Star(re)
Definition: z3py.py:10450
z3py.Solver.__repr__
def __repr__(self)
Definition: z3py.py:6914
z3py.AstMap.map
map
Definition: z3py.py:5653
z3py.RatNumRef.numerator
def numerator(self)
Definition: z3py.py:2806
Z3_mk_fpa_sort_128
Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c)
Create the quadruple-precision (128-bit) FloatingPoint sort.
Z3_mk_fpa_to_ieee_bv
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.
z3py.is_real
def is_real(a)
Definition: z3py.py:2536
z3py.Ints
def Ints(names, ctx=None)
Definition: z3py.py:3057
z3py.is_mod
def is_mod(a)
Definition: z3py.py:2677
Z3_optimize_get_lower
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.
z3py.AstRef.__del__
def __del__(self)
Definition: z3py.py:312
z3py.Model
def Model(ctx=None)
Definition: z3py.py:6277
z3py.Extract
def Extract(high, low, a)
Definition: z3py.py:3899
Z3_get_domain
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.
z3py.SortRef.__hash__
def __hash__(self)
Definition: z3py.py:592
z3py.QuantifierRef.num_patterns
def num_patterns(self)
Definition: z3py.py:1912
z3py.Int2BV
def Int2BV(a, num_bits)
Definition: z3py.py:3773
Z3_mk_bvneg
Z3_ast Z3_API Z3_mk_bvneg(Z3_context c, Z3_ast t1)
Standard two's complement unary minus.
z3py.FuncEntry.as_list
def as_list(self)
Definition: z3py.py:5859
Z3_mk_str_to_int
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
Z3_goal_dec_ref
void Z3_API Z3_goal_dec_ref(Z3_context c, Z3_goal g)
Decrement the reference counter of the given goal.
z3py.Replace
def Replace(s, src, dst)
Definition: z3py.py:10259
Z3_tactic_apply
Z3_apply_result Z3_API Z3_tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g)
Apply tactic t to the goal g.
z3py.FreshBool
def FreshBool(prefix='b', ctx=None)
Definition: z3py.py:1628
z3py.AlgebraicNumRef.approx
def approx(self, precision=10)
Definition: z3py.py:2902
z3py.FPSortRef.ebits
def ebits(self)
Definition: z3py.py:8754
z3py.Array
def Array(name, dom, rng)
Definition: z3py.py:4444
z3py.CreateDatatypes
def CreateDatatypes(*ds)
Definition: z3py.py:4823
z3py.main_ctx
def main_ctx()
Definition: z3py.py:211
z3py.SeqRef.sort
def sort(self)
Definition: z3py.py:10048
z3py.ArithRef.__rdiv__
def __rdiv__(self, other)
Definition: z3py.py:2378
Z3_get_numerator
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_get_tactic_name
Z3_string Z3_API Z3_get_tactic_name(Z3_context c, unsigned i)
Return the name of the idx tactic.
Z3_mk_repeat
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.
Z3_ast_map_erase
void Z3_API Z3_ast_map_erase(Z3_context c, Z3_ast_map m, Z3_ast k)
Erase a key from the map.
z3py.Tactic.param_descrs
def param_descrs(self)
Definition: z3py.py:7772
Z3_solver_get_num_scopes
unsigned Z3_API Z3_solver_get_num_scopes(Z3_context c, Z3_solver s)
Return the number of backtracking points.
z3py.ParamDescrsRef.size
def size(self)
Definition: z3py.py:5149
z3py.RNE
def RNE(ctx=None)
Definition: z3py.py:9041
z3py.Optimize.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:7443
Z3_optimize_get_upper
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.
z3py.Goal.goal
goal
Definition: z3py.py:5201
Z3_get_decl_sort_parameter
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.
z3py.ParAndThen
def ParAndThen(t1, t2, ctx=None)
Definition: z3py.py:7887
z3py.BVAddNoUnderflow
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4212
z3py.FloatDouble
def FloatDouble(ctx=None)
Definition: z3py.py:8811
z3py.Optimize.add
def add(self, *args)
Definition: z3py.py:7455
z3py.Fixedpoint.append
def append(self, *args)
Definition: z3py.py:7063
Z3_mk_func_decl
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.
z3py.SortRef.get_id
def get_id(self)
Definition: z3py.py:516
z3py.FPRef.as_string
def as_string(self)
Definition: z3py.py:8882
z3py.Float16
def Float16(ctx=None)
Definition: z3py.py:8786
Z3_get_ast_id
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....
z3py.Bools
def Bools(names, ctx=None)
Definition: z3py.py:1599
Z3_probe_inc_ref
void Z3_API Z3_probe_inc_ref(Z3_context c, Z3_probe p)
Increment the reference counter of the given probe.
z3py.Intersect
def Intersect(*args)
Definition: z3py.py:10405
Z3_is_eq_sort
bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2)
compare sorts.
z3py.Sum
def Sum(*args)
Definition: z3py.py:8317
z3py.FPRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:8959
z3py.RoundNearestTiesToAway
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:9045
z3py.ReSortRef.basis
def basis(self)
Definition: z3py.py:10351
Z3_get_quantifier_bound_sort
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.
z3py.BoolRef.__mul__
def __mul__(self, other)
Definition: z3py.py:1432
Z3_solver_get_trail
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...
z3py.Fixedpoint.get_answer
def get_answer(self)
Definition: z3py.py:7149
z3py.is_pattern
def is_pattern(a)
Definition: z3py.py:1780
z3py.Goal.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5206
Z3_param_descrs_inc_ref
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_mk_re_range
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.
z3py.parse_smt2_file
def parse_smt2_file(f, sorts={}, decls={}, ctx=None)
Definition: z3py.py:8660
z3py.DatatypeSortRef.recognizer
def recognizer(self, idx)
Definition: z3py.py:4949
z3py.substitute_vars
def substitute_vars(t, *m)
Definition: z3py.py:8297
z3py.Goal.sexpr
def sexpr(self)
Definition: z3py.py:5412
z3py.Optimize.push
def push(self)
Definition: z3py.py:7519
Z3_mk_fresh_func_decl
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.
z3py.FuncDeclRef.as_ast
def as_ast(self)
Definition: z3py.py:668
z3py.is_le
def is_le(a)
Definition: z3py.py:2688
Z3_solver_dec_ref
void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s)
Decrement the reference counter of the given solver.
z3py.help_simplify
def help_simplify()
Definition: z3py.py:8263
z3py.IsSubset
def IsSubset(a, b)
Definition: z3py.py:4702
Z3_mk_ite
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_mk_extract
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_vector_inc_ref
void Z3_API Z3_ast_vector_inc_ref(Z3_context c, Z3_ast_vector v)
Increment the reference counter of the given AST vector.
z3py.user_prop_push
def user_prop_push(ctx)
Definition: z3py.py:10543
z3py.Implies
def Implies(a, b, ctx=None)
Definition: z3py.py:1641
Z3_is_algebraic_number
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a)
Return true if the given AST is a real algebraic number.
z3py.ExprRef.decl
def decl(self)
Definition: z3py.py:974
z3py.FPNumRef.isInf
def isInf(self)
Definition: z3py.py:9179
z3py.Tactic.ctx
ctx
Definition: z3py.py:7704
z3py.BitVecRef.__mod__
def __mod__(self, other)
Definition: z3py.py:3506
Z3_mk_seq_in_re
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.
z3py.DatatypeSortRef.constructor
def constructor(self, idx)
Definition: z3py.py:4930
z3py.CheckSatResult.__ne__
def __ne__(self, other)
Definition: z3py.py:6447
z3py.FPRef.__mul__
def __mul__(self, other)
Definition: z3py.py:8944
Z3_mk_set_difference
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
z3py.ReSortRef
Regular expressions.
Definition: z3py.py:10348
z3py.ModelRef.__del__
def __del__(self)
Definition: z3py.py:6010
Z3_mk_bvule
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
Z3_func_interp_inc_ref
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.
z3py.Fixedpoint.get_rules_along_trace
def get_rules_along_trace(self)
Definition: z3py.py:7159
z3py.Context.interrupt
def interrupt(self)
Definition: z3py.py:200
z3py.BVSDivNoOverflow
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4231
z3py.ExprRef.sort
def sort(self)
Definition: z3py.py:909
z3py.BitVec
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3811
z3py.is_arith
def is_arith(a)
Definition: z3py.py:2498
z3py.is_sort
def is_sort(s)
Definition: z3py.py:596
Z3_model_get_const_interp
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,...
z3py.Tactic
Definition: z3py.py:7698
z3py.is_int_value
def is_int_value(a)
Definition: z3py.py:2560
z3py.Optimize.statistics
def statistics(self)
Definition: z3py.py:7595
Z3_mk_bool_sort
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
z3py.ModelRef.ctx
ctx
Definition: z3py.py:6007
z3py.ToReal
def ToReal(a)
Definition: z3py.py:3147
z3py.FuncInterp.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5890
Z3_optimize_check
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.
Z3_get_num_tactics
unsigned Z3_API Z3_get_num_tactics(Z3_context c)
Return the number of builtin tactics available in Z3.
z3py.BitVecRef.__rtruediv__
def __rtruediv__(self, other)
Definition: z3py.py:3502
z3py.UserPropagateBase.add_eq
def add_eq(self, eq)
Definition: z3py.py:10647
z3py.SeqRef.__radd__
def __radd__(self, other)
Definition: z3py.py:10054
z3py.UserPropagateBase
Definition: z3py.py:10588
z3py.BitVecs
def BitVecs(names, bv, ctx=None)
Definition: z3py.py:3834
z3py.is_re
def is_re(s)
Definition: z3py.py:10369
Z3_goal_translate
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.
z3py.Solver.units
def units(self)
Definition: z3py.py:6837
z3py.Fixedpoint.__del__
def __del__(self)
Definition: z3py.py:7023
z3py.is_int
def is_int(a)
Definition: z3py.py:2518
Z3_tactic_cond
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...
z3py.LastIndexOf
def LastIndexOf(s, substr)
Definition: z3py.py:10293
Z3_func_interp_dec_ref
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.
Z3_mk_lstring
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...
z3py.Optimize.upper
def upper(self, obj)
Definition: z3py.py:7555
z3py.is_string
def is_string(a)
Definition: z3py.py:10123
z3py.OptimizeObjective
Optimize.
Definition: z3py.py:7382
z3py.ArithRef.__sub__
def __sub__(self, other)
Definition: z3py.py:2300
z3py.PropClosures.set_threaded
def set_threaded()
Definition: z3py.py:10513
z3py.Default
def Default(a)
Definition: z3py.py:4478
Z3_mk_power
Z3_ast Z3_API Z3_mk_power(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 ^ arg2.
Z3_fixedpoint_get_statistics
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.
z3py.AstMap.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5663
Z3_global_param_get
Z3_bool Z3_API Z3_global_param_get(Z3_string param_id, Z3_string_ptr param_value)
Get a global (or module) parameter.
z3py.ParamDescrsRef.get_name
def get_name(self, i)
Definition: z3py.py:5159
z3py.QuantifierRef.is_lambda
def is_lambda(self)
Definition: z3py.py:1875
z3py.get_map_func
def get_map_func(a)
Definition: z3py.py:4395
z3py.Solver.assertions
def assertions(self)
Definition: z3py.py:6823
Z3_ast_vector_set
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.
z3py.ArithSortRef.is_real
def is_real(self)
Definition: z3py.py:2131
Z3_goal_to_string
Z3_string Z3_API Z3_goal_to_string(Z3_context c, Z3_goal g)
Convert a goal into a string.
z3py.Distinct
def Distinct(*args)
Definition: z3py.py:1290
Z3_fixedpoint_register_relation
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...
z3py.ArithSortRef.subsort
def subsort(self, other)
Definition: z3py.py:2159
z3py.fpIsNormal
def fpIsNormal(a, ctx=None)
Definition: z3py.py:9664
z3py.Fixedpoint.__init__
def __init__(self, fixedpoint=None, ctx=None)
Definition: z3py.py:7009
z3py.ModelRef.get_universe
def get_universe(self, s)
Definition: z3py.py:6180
z3py.FreshConst
def FreshConst(sort, prefix='c')
Definition: z3py.py:1346
z3py.PbGe
def PbGe(args, k)
Definition: z3py.py:8437
Z3_mk_div
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_goal_inc_ref
void Z3_API Z3_goal_inc_ref(Z3_context c, Z3_goal g)
Increment the reference counter of the given goal.
z3py.ParamsRef
Parameter Sets.
Definition: z3py.py:5067
z3py.AstRef.__repr__
def __repr__(self)
Definition: z3py.py:323
Z3_tactic_repeat
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_mk_ext_rotate_right
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.
z3py.Datatype.constructors
constructors
Definition: z3py.py:4752
z3py.ParamDescrsRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5142
Z3_get_re_sort_basis
Z3_sort Z3_API Z3_get_re_sort_basis(Z3_context c, Z3_sort s)
Retrieve basis sort for regex sort.
Z3_optimize_assert
void Z3_API Z3_optimize_assert(Z3_context c, Z3_optimize o, Z3_ast a)
Assert hard constraint to the optimization context.
z3py.Solver.backtrack_level
backtrack_level
Definition: z3py.py:6483
Z3_mk_lt
Z3_ast Z3_API Z3_mk_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than.
Z3_get_decl_num_parameters
unsigned Z3_API Z3_get_decl_num_parameters(Z3_context c, Z3_func_decl d)
Return the number of parameters associated with a declaration.
z3py.Optimize.add_soft
def add_soft(self, arg, weight="1", id=None)
Definition: z3py.py:7492
Z3_mk_fpa_sort_32
Z3_sort Z3_API Z3_mk_fpa_sort_32(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
Z3_optimize_from_file
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....
z3py.Solver.append
def append(self, *args)
Definition: z3py.py:6619
z3py.PropClosures.__init__
def __init__(self)
Definition: z3py.py:10509
z3py.AstRef.__copy__
def __copy__(self)
Definition: z3py.py:399
z3py.z3_debug
def z3_debug()
Definition: z3py.py:56
z3py.Goal.as_expr
def as_expr(self)
Definition: z3py.py:5469
z3py.is_true
def is_true(a)
Definition: z3py.py:1459
z3py.ScopedConstructorList.__del__
def __del__(self)
Definition: z3py.py:4819
Z3_mk_const
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
z3py.Solver.trail
def trail(self)
Definition: z3py.py:6855
Z3_stats_dec_ref
void Z3_API Z3_stats_dec_ref(Z3_context c, Z3_stats s)
Decrement the reference counter of the given statistics object.
z3py.SetSort
def SetSort(s)
Sets.
Definition: z3py.py:4609
z3py.Goal.__len__
def __len__(self)
Definition: z3py.py:5291
Z3_model_get_num_funcs
unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m)
Return the number of function interpretations in the given model.
z3py.Real
def Real(name, ctx=None)
Definition: z3py.py:3094
z3py.ApplyResult.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7616
z3py.probe_description
def probe_description(name, ctx=None)
Definition: z3py.py:8145
Z3_disable_trace
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.
z3py.SeqSortRef
Strings, Sequences and Regular expressions.
Definition: z3py.py:10009
z3py.Tactic.solver
def solver(self, logFile=None)
Definition: z3py.py:7724
z3py.Optimize.assert_and_track
def assert_and_track(self, a, p)
Definition: z3py.py:7463
z3py.Lambda
def Lambda(vs, body)
Definition: z3py.py:2102
z3py.tactic_description
def tactic_description(name, ctx=None)
Definition: z3py.py:7954
Z3_mk_bv_sort
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
z3py.StringVal
def StringVal(s, ctx=None)
Definition: z3py.py:10140
z3py.QuantifierRef
Quantifiers.
Definition: z3py.py:1832
z3py.StrToInt
def StrToInt(s)
Definition: z3py.py:10311
Z3_mk_fixedpoint
Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c)
Create a new fixedpoint context.
z3py.Fixedpoint.update_rule
def update_rule(self, head, body, name)
Definition: z3py.py:7140
Z3_solver_from_string
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a string.
Z3_get_index_value
unsigned Z3_API Z3_get_index_value(Z3_context c, Z3_ast a)
Return index of de-Bruijn bound variable.
Z3_fixedpoint_assert
void Z3_API Z3_fixedpoint_assert(Z3_context c, Z3_fixedpoint d, Z3_ast axiom)
Assert a constraint to the fixedpoint context.
Z3_mk_seq_to_re
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
z3py.fpFP
def fpFP(sgn, exp, sig, ctx=None)
Definition: z3py.py:9754
Z3_mk_int_sort
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
Z3_probe_get_descr
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.
z3py.FPNumRef.as_string
def as_string(self)
Definition: z3py.py:9209
Z3_probe_ge
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...
z3py.FPNumRef.significand_as_long
def significand_as_long(self)
Definition: z3py.py:9133
Z3_mk_enumeration_sort
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.
z3py.fpPlusZero
def fpPlusZero(s)
Definition: z3py.py:9341
z3py.ScopedConstructorList
Definition: z3py.py:4814
z3py.fpNaN
def fpNaN(s)
Definition: z3py.py:9298
z3py.ParamDescrsRef
Definition: z3py.py:5133
Z3_solver_get_unsat_core
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...
z3py.UserPropagateBase.solver
solver
Definition: z3py.py:10600
z3py.FPSort
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9240
Z3_get_full_version
Z3_string Z3_API Z3_get_full_version(void)
Return a string that fully describes the version of Z3 in use.
Z3_fpa_is_numeral_nan
bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is a NaN.
z3py.ApplyResult.__len__
def __len__(self)
Definition: z3py.py:7623
Z3_mk_bvashr
Z3_ast Z3_API Z3_mk_bvashr(Z3_context c, Z3_ast t1, Z3_ast t2)
Arithmetic shift right.
z3py.FuncDeclRef.name
def name(self)
Definition: z3py.py:677
Z3_mk_bvurem
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
z3py.ArithRef.__lt__
def __lt__(self, other)
Definition: z3py.py:2459
Z3_goal_to_dimacs_string
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...
z3py.ParamsRef.set
def set(self, name, val)
Definition: z3py.py:5087
z3py.get_version
def get_version()
Definition: z3py.py:81
z3py.BitVecRef.__and__
def __and__(self, other)
Definition: z3py.py:3386
z3py.ParamDescrsRef.descr
descr
Definition: z3py.py:5139
Z3_fixedpoint_set_predicate_representation
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.
z3py.CheckSatResult.__repr__
def __repr__(self)
Definition: z3py.py:6450
z3py.DeclareSort
def DeclareSort(name, ctx=None)
Definition: z3py.py:637
Z3_mk_bvsub_no_overflow
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.
z3py.Unit
def Unit(a)
Definition: z3py.py:10208
Z3_solver_get_units
Z3_ast_vector Z3_API Z3_solver_get_units(Z3_context c, Z3_solver s)
Return the set of units modulo model conversion.
z3py.AstVector.resize
def resize(self, sz)
Definition: z3py.py:5582
z3py.PropClosures.insert
def insert(self, r)
Definition: z3py.py:10529
Z3_mk_bvsmod
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_probe_eq
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_mk_constructor_list
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
z3py.ArithRef.__rmod__
def __rmod__(self, other)
Definition: z3py.py:2414
z3py.AstMap.erase
def erase(self, k)
Definition: z3py.py:5726
z3py.fpSqrt
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9628
z3py.fpZero
def fpZero(s, negative)
Definition: z3py.py:9351
z3py.is_finite_domain
def is_finite_domain(a)
Definition: z3py.py:7307
Z3_mk_seq_replace
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.
z3py.ApplyResult.as_expr
def as_expr(self)
Definition: z3py.py:7667
z3py.Solver.cube_vs
cube_vs
Definition: z3py.py:6798
z3py.ParamsRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5080
z3py.Tactic.apply
def apply(self, goal, *arguments, **keywords)
Definition: z3py.py:7741
z3py.UserPropagateBase.ctx
def ctx(self)
Definition: z3py.py:10626
z3py.SortRef.cast
def cast(self, val)
Definition: z3py.py:543
z3py.RealVar
def RealVar(idx, ctx=None)
Definition: z3py.py:1363
z3py.PropClosures.lock
lock
Definition: z3py.py:10511
z3py.FP
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9401
Z3_get_arity
unsigned Z3_API Z3_get_arity(Z3_context c, Z3_func_decl d)
Alias for Z3_get_domain_size.
Z3_mk_context_rc
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_mk_seq_contains
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
z3py.fpDiv
def fpDiv(rm, a, b, ctx=None)
Definition: z3py.py:9568
z3py.FuncDeclRef
Function Declarations.
Definition: z3py.py:661
z3py.ExprRef.params
def params(self)
Definition: z3py.py:971
Z3_get_quantifier_no_pattern_ast
Z3_ast Z3_API Z3_get_quantifier_no_pattern_ast(Z3_context c, Z3_ast a, unsigned i)
Return i'th no_pattern.
z3py.is_as_array
def is_as_array(n)
Definition: z3py.py:6281
z3py.QuantifierRef.__getitem__
def __getitem__(self, arg)
Definition: z3py.py:1889
z3py.set_default_fp_sort
def set_default_fp_sort(ebits, sbits, ctx=None)
Definition: z3py.py:8713
z3py.UserPropagateBase.ctx_ref
def ctx_ref(self)
Definition: z3py.py:10632
z3py.ScopedConstructorList.__init__
def __init__(self, c, ctx)
Definition: z3py.py:4816
z3py.Goal.precision
def precision(self)
Definition: z3py.py:5269
Z3_probe_apply
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....
z3py.BoolRef
Definition: z3py.py:1424
z3py.BitVecNumRef
Definition: z3py.py:3681
Z3_mk_bound
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a bound variable.
Z3_params_validate
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.
z3py.QuantifierRef.is_exists
def is_exists(self)
Definition: z3py.py:1861
Z3_ast_vector_get
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.
Z3_mk_ast_vector
Z3_ast_vector Z3_API Z3_mk_ast_vector(Z3_context c)
Return an empty AST vector.
z3py.ModelRef.__init__
def __init__(self, m, ctx)
Definition: z3py.py:6004
z3py.PiecewiseLinearOrder
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:10497
Z3_get_datatype_sort_constructor
Z3_func_decl Z3_API Z3_get_datatype_sort_constructor(Z3_context c, Z3_sort t, unsigned idx)
Return idx'th constructor.
z3py.SeqRef.__gt__
def __gt__(self, other)
Definition: z3py.py:10091
z3py.is_store
def is_store(a)
Definition: z3py.py:4591
Z3_mk_datatypes
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.
Z3_tactic_get_param_descrs
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.
z3py.UserPropagateBase.conflict
def conflict(self, ids)
Definition: z3py.py:10689
Z3_mk_bvadd_no_underflow
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.
z3py.Solver.insert
def insert(self, *args)
Definition: z3py.py:6630
Z3_goal_assert
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_probe_lt
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_model_get_sort_universe
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_mk_seq_empty
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
z3py.Select
def Select(a, i)
Definition: z3py.py:4505
Z3_optimize_set_params
void Z3_API Z3_optimize_set_params(Z3_context c, Z3_optimize o, Z3_params p)
Set parameters on optimization context.
Z3_ast_vector_resize
void Z3_API Z3_ast_vector_resize(Z3_context c, Z3_ast_vector v, unsigned n)
Resize the AST vector v.
z3py.FPNumRef.sign_as_bv
def sign_as_bv(self)
Definition: z3py.py:9115
z3py.FreshFunction
def FreshFunction(*sig)
Definition: z3py.py:821
z3py.AtMost
def AtMost(*args)
Definition: z3py.py:8368
Z3_solver_get_implied_value
Z3_ast Z3_API Z3_solver_get_implied_value(Z3_context c, Z3_solver s, Z3_ast e)
retrieve implied value for expression, if any is implied by solver at search level....
z3py.FPRef.__radd__
def __radd__(self, other)
Definition: z3py.py:8911
Z3_mk_params
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...
Z3_solver_assert_and_track
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.
z3py.ParamsRef.validate
def validate(self, ds)
Definition: z3py.py:5107
z3py.Fixedpoint.get_ground_sat_answer
def get_ground_sat_answer(self)
Definition: z3py.py:7154
z3py.RecAddDefinition
def RecAddDefinition(f, args, body)
Definition: z3py.py:860
z3py.Optimize.maximize
def maximize(self, arg)
Definition: z3py.py:7511
Z3_mk_probe
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_tactic_get_help
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.
z3py.fpToSBV
def fpToSBV(rm, x, s, ctx=None)
Definition: z3py.py:9915
z3py.QuantifierRef.pattern
def pattern(self, idx)
Definition: z3py.py:1924
z3py.Datatype.create
def create(self)
Definition: z3py.py:4789
z3py.FuncInterp.as_list
def as_list(self)
Definition: z3py.py:5981
z3py.ExprRef.num_args
def num_args(self)
Definition: z3py.py:989
Z3_params_inc_ref
void Z3_API Z3_params_inc_ref(Z3_context c, Z3_params p)
Increment the reference counter of the given parameter set.
z3py.is_div
def is_div(a)
Definition: z3py.py:2650
Z3_mk_string_sort
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for 8 bit strings.
z3py.AstMap.__contains__
def __contains__(self, key)
Definition: z3py.py:5683
Z3_probe_not
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.
z3py.ScopedConstructorList.ctx
ctx
Definition: z3py.py:4818
z3py.ModelRef.__repr__
def __repr__(self)
Definition: z3py.py:6014
z3py.Re
def Re(s, ctx=None)
Definition: z3py.py:10334
Z3_fixedpoint_get_assertions
Z3_ast_vector Z3_API Z3_fixedpoint_get_assertions(Z3_context c, Z3_fixedpoint f)
Retrieve set of background assertions from fixedpoint context.
z3py.FullSet
def FullSet(s)
Definition: z3py.py:4621
z3py.Solver.assert_and_track
def assert_and_track(self, a, p)
Definition: z3py.py:6641
z3py.PropClosures.set
def set(self, ctx, r)
Definition: z3py.py:10524
Z3_del_config
void Z3_API Z3_del_config(Z3_config c)
Delete the given configuration object.
z3py.OrElse
def OrElse(*ts, **ks)
Definition: z3py.py:7835
z3py.ModelRef.sorts
def sorts(self)
Definition: z3py.py:6163
z3py.Optimize.from_string
def from_string(self, s)
Definition: z3py.py:7574
z3py.Fixedpoint.rule
def rule(self, head, body=None, name=None)
Definition: z3py.py:7094
Z3_apply_result_get_subgoal
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_is_lambda
bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a)
Determine if ast is a lambda expression.
z3py.is_probe
def is_probe(p)
Definition: z3py.py:8119
Z3_mk_array_sort
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
Z3_mk_bvsle
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.
z3py.OptimizeObjective.lower_values
def lower_values(self)
Definition: z3py.py:7396
z3py.is_mul
def is_mul(a)
Definition: z3py.py:2628
Z3_mk_int2bv
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.
Z3_solver_propagate_final
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...
z3py.Statistics.__getattr__
def __getattr__(self, name)
Definition: z3py.py:6399
Z3_solver_get_statistics
Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s)
Return statistics for the given solver.
z3py.FreshInt
def FreshInt(prefix='x', ctx=None)
Definition: z3py.py:3081
z3py.BoolSortRef
Booleans.
Definition: z3py.py:1390
z3py.BitVecSortRef
Bit-Vectors.
Definition: z3py.py:3227
Z3_get_bv_sort_size
unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t)
Return the size of the given bit-vector sort.
z3py.ModelRef.sexpr
def sexpr(self)
Definition: z3py.py:6017
z3py.Solver.trail_levels
def trail_levels(self)
Definition: z3py.py:6847
z3py.fpPlusInfinity
def fpPlusInfinity(s)
Definition: z3py.py:9314
Z3_fixedpoint_to_string
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_get_numeral_decimal_string
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_mk_false
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
z3py.ArraySortRef.domain
def domain(self)
Definition: z3py.py:4267
z3py.solve_using
def solve_using(s, *args, **keywords)
Definition: z3py.py:8486
z3py.ExprRef.get_id
def get_id(self)
Definition: z3py.py:906
z3py.ScopedConstructor
Definition: z3py.py:4805
Z3_get_array_sort_range
Z3_sort Z3_API Z3_get_array_sort_range(Z3_context c, Z3_sort t)
Return the range of the given array sort.
z3py.RatNumRef.is_real
def is_real(self)
Definition: z3py.py:2859
z3py.Solver.help
def help(self)
Definition: z3py.py:6906
Z3_mk_fpa_round_toward_negative
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.
z3py.BitVecRef.sort
def sort(self)
Definition: z3py.py:3272
z3py.Fixedpoint.insert
def insert(self, *args)
Definition: z3py.py:7067
z3py.Function
def Function(name, *sig)
Definition: z3py.py:799
z3py.Plus
def Plus(re)
Definition: z3py.py:10422
z3py.Solver.statistics
def statistics(self)
Definition: z3py.py:6875
z3py.append_log
def append_log(s)
Definition: z3py.py:105
z3py.Probe.__le__
def __le__(self, other)
Definition: z3py.py:8038
z3py.Probe.__lt__
def __lt__(self, other)
Definition: z3py.py:8012
z3py.FiniteDomainVal
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7346
z3py.FuncInterp.arity
def arity(self)
Definition: z3py.py:5936
Z3_model_inc_ref
void Z3_API Z3_model_inc_ref(Z3_context c, Z3_model m)
Increment the reference counter of the given model.
z3py.SeqRef.as_string
def as_string(self)
Definition: z3py.py:10074
z3py.Float128
def Float128(ctx=None)
Definition: z3py.py:8816
z3py.OptimizeObjective.__str__
def __str__(self)
Definition: z3py.py:7410
z3py.is_add
def is_add(a)
Definition: z3py.py:2617
z3py.Then
def Then(*ts, **ks)
Definition: z3py.py:7823
z3py.AstMap.__init__
def __init__(self, m=None, ctx=None)
Definition: z3py.py:5652
Z3_parse_smtlib2_string
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_get_num_probes
unsigned Z3_API Z3_get_num_probes(Z3_context c)
Return the number of builtin probes available in Z3.
Z3_mk_atleast
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
Z3_solver_set_params
void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p)
Set the given solver using the given parameters.
Z3_solver_get_non_units
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_mk_bvsdiv
Z3_ast Z3_API Z3_mk_bvsdiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed division.
Z3_tactic_apply_ex
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.
z3py.IntNumRef.as_binary_string
def as_binary_string(self)
Definition: z3py.py:2795
z3py.DatatypeSortRef.num_constructors
def num_constructors(self)
Definition: z3py.py:4917
z3py.AstMap.__len__
def __len__(self)
Definition: z3py.py:5670
z3py.LinearOrder
def LinearOrder(a, index)
Definition: z3py.py:10491
z3py.ArraySort
def ArraySort(*sig)
Definition: z3py.py:4412
z3py.ArrayRef
Definition: z3py.py:4285
z3py.ApplyResult.ctx
ctx
Definition: z3py.py:7613
z3py.BitVecSort
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3781
z3py.BoolSortRef.is_bool
def is_bool(self)
Definition: z3py.py:1420
Z3_get_range
Z3_sort Z3_API Z3_get_range(Z3_context c, Z3_func_decl d)
Return the range of the given declaration.
z3py.Optimize.objectives
def objectives(self)
Definition: z3py.py:7582
z3py.Goal.__copy__
def __copy__(self)
Definition: z3py.py:5443
Z3_solver_cube
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...
Z3_del_constructor_list
void Z3_API Z3_del_constructor_list(Z3_context c, Z3_constructor_list clist)
Reclaim memory allocated for constructor list.
z3py.FuncDeclRef.domain
def domain(self, i)
Definition: z3py.py:697
z3py.ParamsRef.ctx
ctx
Definition: z3py.py:5073
z3py.ArithRef.sort
def sort(self)
Definition: z3py.py:2217
Z3_get_app_arg
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.
z3py.Solver.add
def add(self, *args)
Definition: z3py.py:6604
z3py.Goal.translate
def translate(self, target)
Definition: z3py.py:5420
z3py.SortRef.__ne__
def __ne__(self, other)
Definition: z3py.py:581
z3py.AstVector.ctx
ctx
Definition: z3py.py:5502
z3py.BoolRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:1429
z3py.Contains
def Contains(a, b)
Definition: z3py.py:10240
z3py.fpAdd
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9524
Z3_mk_optimize
Z3_optimize Z3_API Z3_mk_optimize(Z3_context c)
Create a new optimize context.
z3py.is_finite_domain_value
def is_finite_domain_value(a)
Definition: z3py.py:7360
z3py.OptimizeObjective._opt
_opt
Definition: z3py.py:7384
z3py.Bool
def Bool(name, ctx=None)
Definition: z3py.py:1588
z3py.SetUnion
def SetUnion(*args)
Definition: z3py.py:4629
Z3_mk_fpa_sort_double
Z3_sort Z3_API Z3_mk_fpa_sort_double(Z3_context c)
Create the double-precision (64-bit) FloatingPoint sort.
z3py.Fixedpoint.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7020
Z3_optimize_get_upper_as_vector
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_apply_result_dec_ref
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_del_constructor
void Z3_API Z3_del_constructor(Z3_context c, Z3_constructor constr)
Reclaim memory allocated to constructor.
z3py.AstRef.as_ast
def as_ast(self)
Definition: z3py.py:354
Z3_model_to_string
Z3_string Z3_API Z3_model_to_string(Z3_context c, Z3_model m)
Convert the given model into a string.
Z3_tactic_get_descr
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.
z3py.BitVecNumRef.as_signed_long
def as_signed_long(self)
Definition: z3py.py:3695
z3py.FPRMRef
Definition: z3py.py:9029
z3py.Probe.__ne__
def __ne__(self, other)
Definition: z3py.py:8077
z3py.Solver.upper
def upper(self, e)
Definition: z3py.py:6870
z3py.UserPropagateBase.diseq
diseq
Definition: z3py.py:10607
z3py.Probe.ctx
ctx
Definition: z3py.py:7983
z3py.fpSub
def fpSub(rm, a, b, ctx=None)
Definition: z3py.py:9540
z3py.Fixedpoint.__iadd__
def __iadd__(self, fml)
Definition: z3py.py:7059
Z3_solver_assert
void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a)
Assert a constraint into the solver.
Z3_mk_set_member
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
z3py.Fixedpoint.reason_unknown
def reason_unknown(self)
Definition: z3py.py:7238
z3py.is_const_array
def is_const_array(a)
Definition: z3py.py:4348
z3py.FPSortRef
FP Sorts.
Definition: z3py.py:8751
Z3_get_decl_double_parameter
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.
z3py.Product
def Product(*args)
Definition: z3py.py:8343
Z3_func_entry_get_arg
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.
z3py.ScopedConstructor.__init__
def __init__(self, c, ctx)
Definition: z3py.py:4807
Z3_tactic_par_or
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.
z3py.AstRef.__nonzero__
def __nonzero__(self)
Definition: z3py.py:332
Z3_get_datatype_sort_recognizer
Z3_func_decl Z3_API Z3_get_datatype_sort_recognizer(Z3_context c, Z3_sort t, unsigned idx)
Return idx'th recognizer.
Z3_fixedpoint_get_param_descrs
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.
z3py.IntToStr
def IntToStr(s)
Definition: z3py.py:10327
z3py.QuantifierRef.no_pattern
def no_pattern(self, idx)
Definition: z3py.py:1946
z3py.TryFor
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7936
z3py.ExprRef.arg
def arg(self, idx)
Definition: z3py.py:1005
z3py.FPNumRef.isNaN
def isNaN(self)
Definition: z3py.py:9175
z3py.Probe.__init__
def __init__(self, probe, ctx=None)
Definition: z3py.py:7982
z3py.FPRef
FP Expressions.
Definition: z3py.py:8852
z3py.AstRef.ctx
ctx
Definition: z3py.py:309
z3py.Context.ref
def ref(self)
Definition: z3py.py:196
z3py.ModelRef.get_interp
def get_interp(self, decl)
Definition: z3py.py:6091
Z3_model_get_num_sorts
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.
z3py.SetDel
def SetDel(s, e)
Definition: z3py.py:4663
Z3_fixedpoint_get_reason_unknown
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_simplify
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_mk_bvult
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
Z3_model_get_func_decl
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.
z3py.user_prop_final
def user_prop_final(ctx, cb)
Definition: z3py.py:10562
z3py.ParamsRef.params
params
Definition: z3py.py:5075
Z3_fpa_get_numeral_significand_string
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.
z3py.Probe.probe
probe
Definition: z3py.py:7984
z3py.SRem
def SRem(a, b)
Definition: z3py.py:4034
z3py.get_var_index
def get_var_index(a)
Definition: z3py.py:1224
z3py.CheckSatResult.r
r
Definition: z3py.py:6439
z3py.fpNeg
def fpNeg(a, ctx=None)
Definition: z3py.py:9464
Z3_solver_translate
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.
z3py.fpLEQ
def fpLEQ(a, b, ctx=None)
Definition: z3py.py:9699
z3py.EnumSort
def EnumSort(name, values, ctx=None)
Definition: z3py.py:5035
z3py.BoolVal
def BoolVal(val, ctx=None)
Definition: z3py.py:1570
z3py.RatNumRef.as_string
def as_string(self)
Definition: z3py.py:2881
z3py.FPRef.__gt__
def __gt__(self, other)
Definition: z3py.py:8895
z3py.Solver.reason_unknown
def reason_unknown(self)
Definition: z3py.py:6893
z3py.is_ast
def is_ast(a)
Definition: z3py.py:412
z3py.FiniteDomainSortRef
Definition: z3py.py:7267
z3py.Solver.lower
def lower(self, e)
Definition: z3py.py:6865
Z3_get_datatype_sort_constructor_accessor
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.
z3py.FPNumRef.significand_as_bv
def significand_as_bv(self)
Definition: z3py.py:9143
z3py.Optimize.__del__
def __del__(self)
Definition: z3py.py:7425
Z3_func_entry_dec_ref
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.
z3py.get_default_fp_sort
def get_default_fp_sort(ctx=None)
Definition: z3py.py:8710
z3py.ExprRef.__hash__
def __hash__(self)
Definition: z3py.py:949
z3py.Optimize
Definition: z3py.py:7414
Z3_mk_re_union
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.
z3py.BitVecRef.size
def size(self)
Definition: z3py.py:3283
Z3_mk_bvudiv
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.
z3py.IntNumRef.as_string
def as_string(self)
Definition: z3py.py:2787
z3py.Goal.__init__
def __init__(self, models=True, unsat_cores=False, proofs=False, ctx=None, goal=None)
Definition: z3py.py:5197
z3py.ArithRef.is_int
def is_int(self)
Definition: z3py.py:2227
z3py.FuncDeclRef.__call__
def __call__(self, *args)
Definition: z3py.py:755
z3py.Datatype.name
name
Definition: z3py.py:4751
z3py.UserPropagateBase.add_fixed
def add_fixed(self, fixed)
Definition: z3py.py:10635
z3py.FuncEntry.ctx
ctx
Definition: z3py.py:5778
Z3_optimize_push
void Z3_API Z3_optimize_push(Z3_context c, Z3_optimize d)
Create a backtracking point.
Z3_mk_re_sort
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
z3py.QuantifierRef.weight
def weight(self)
Definition: z3py.py:1898
z3py.is_bv_value
def is_bv_value(a)
Definition: z3py.py:3737
Z3_mk_bvsub
Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement subtraction.
z3py.Solver.check
def check(self, *assumptions)
Definition: z3py.py:6671
z3py.Goal.convert_model
def convert_model(self, model)
Definition: z3py.py:5380
z3py.is_idiv
def is_idiv(a)
Definition: z3py.py:2666
z3py.DatatypeSortRef.accessor
def accessor(self, i, j)
Definition: z3py.py:4977
Z3_probe_gt
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...
z3py.Solver.num_scopes
def num_scopes(self)
Definition: z3py.py:6553
z3py.IntNumRef.as_long
def as_long(self)
Definition: z3py.py:2774
Z3_mk_sign_ext
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,...
z3py.Concat
def Concat(*args)
Definition: z3py.py:3854
z3py.Probe
Definition: z3py.py:7980
z3py.Statistics.keys
def keys(self)
Definition: z3py.py:6367
z3py.Goal.size
def size(self)
Definition: z3py.py:5278
Z3_mk_tree_order
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.
z3py.FuncInterp.__init__
def __init__(self, f, ctx)
Definition: z3py.py:5884
Z3_func_interp_get_arity
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_mk_seq_sort
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.
z3py.ArithRef.__gt__
def __gt__(self, other)
Definition: z3py.py:2472
Z3_solver_propagate_register
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...
z3py.FuncInterp
Definition: z3py.py:5881
z3py.SolverFor
def SolverFor(logic, ctx=None, logFile=None)
Definition: z3py.py:6968
z3py.AstVector.vector
vector
Definition: z3py.py:5500
z3py.describe_probes
def describe_probes()
Definition: z3py.py:8153
Z3_get_quantifier_bound_name
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_mk_pble
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.
z3py.BitVecRef.__rrshift__
def __rrshift__(self, other)
Definition: z3py.py:3653
Z3_mk_bvand
Z3_ast Z3_API Z3_mk_bvand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise and.
Z3_solver_get_implied_upper
Z3_ast Z3_API Z3_solver_get_implied_upper(Z3_context c, Z3_solver s, Z3_ast e)
retrieve implied upper bound value for arithmetic expression. If an upper bound is implied at search ...
Z3_mk_solver
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 ...
z3py.ModelRef.__len__
def __len__(self)
Definition: z3py.py:6076
Z3_fpa_get_ebits
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.
Z3_param_descrs_get_kind
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.
z3py.Solver.reset
def reset(self)
Definition: z3py.py:6571
z3py.Not
def Not(a, ctx=None)
Definition: z3py.py:1669
z3py.Goal.simplify
def simplify(self, *arguments, **keywords)
Definition: z3py.py:5449
Z3_fpa_get_numeral_exponent_string
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_substitute
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_mk_simple_solver
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
z3py.BitVecRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:3330
z3py.Datatype.__init__
def __init__(self, name, ctx=None)
Definition: z3py.py:4749
z3py.ParamsRef.__repr__
def __repr__(self)
Definition: z3py.py:5104
z3py.K
def K(dom, v)
Definition: z3py.py:4542
Z3_set_error_handler
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.
Z3_mk_bvsub_no_underflow
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.
z3py.UserPropagateBase.id
id
Definition: z3py.py:10603
Z3_get_finite_domain_sort_size
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_...
z3py.BVRedAnd
def BVRedAnd(a)
Definition: z3py.py:4194
z3py.is_fp_sort
def is_fp_sort(s)
Definition: z3py.py:8830
Z3_get_array_sort_domain
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,...
z3py.is_var
def is_var(a)
Definition: z3py.py:1200
z3py.Goal.depth
def depth(self)
Definition: z3py.py:5213
Z3_open_log
bool Z3_API Z3_open_log(Z3_string filename)
Log interaction to a file.
z3py.ArithRef.is_real
def is_real(self)
Definition: z3py.py:2241
z3py.BVSNegNoOverflow
def BVSNegNoOverflow(a)
Definition: z3py.py:4237
Z3_mk_store
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
z3py.Optimize.from_file
def from_file(self, filename)
Definition: z3py.py:7570
Z3_get_sort_name
Z3_symbol Z3_API Z3_get_sort_name(Z3_context c, Z3_sort d)
Return the sort name as a symbol.
z3py.ArraySortRef.range
def range(self)
Definition: z3py.py:4276
Z3_stats_inc_ref
void Z3_API Z3_stats_inc_ref(Z3_context c, Z3_stats s)
Increment the reference counter of the given statistics object.
Z3_mk_bvredand
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
z3py.IntVector
def IntVector(prefix, sz, ctx=None)
Definition: z3py.py:3069
Z3_solver_from_file
void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a file.
z3py.OptimizeObjective._value
_value
Definition: z3py.py:7385
z3py.AstVector.translate
def translate(self, other_ctx)
Definition: z3py.py:5618
z3py.Goal.prec
def prec(self)
Definition: z3py.py:5248
z3py.Fixedpoint.query_from_lvl
def query_from_lvl(self, lvl, *query)
Definition: z3py.py:7124
z3py.is_bv_sort
def is_bv_sort(s)
Definition: z3py.py:3259
z3py.AlgebraicNumRef.index
def index(self)
Definition: z3py.py:2927
Z3_model_get_num_consts
unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m)
Return the number of constants assigned by the given model.
z3py.RatNumRef.as_decimal
def as_decimal(self, prec)
Definition: z3py.py:2869
z3py.Statistics.get_key_value
def get_key_value(self, key)
Definition: z3py.py:6379
z3py.FuncInterp.__repr__
def __repr__(self)
Definition: z3py.py:5998
z3py.Solver.__del__
def __del__(self)
Definition: z3py.py:6493
Z3_get_symbol_int
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
z3py.Full
def Full(s)
Definition: z3py.py:10194
z3py.Optimize.model
def model(self)
Definition: z3py.py:7540
Z3_mk_fpa_sort_half
Z3_sort Z3_API Z3_mk_fpa_sort_half(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
Z3_get_decl_symbol_parameter
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.
z3py.ArithRef.__rsub__
def __rsub__(self, other)
Definition: z3py.py:2313
Z3_mk_not
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
z3py.is_is_int
def is_is_int(a)
Definition: z3py.py:2732
z3py.BitVecSortRef.cast
def cast(self, val)
Definition: z3py.py:3242
z3py.BitVecNumRef.as_long
def as_long(self)
Definition: z3py.py:3684
z3py.ArithRef.__radd__
def __radd__(self, other)
Definition: z3py.py:2265
z3py.OptimizeObjective.__init__
def __init__(self, opt, value, is_max)
Definition: z3py.py:7383
z3py.AndThen
def AndThen(*ts, **ks)
Definition: z3py.py:7804
z3py.AstVector.__copy__
def __copy__(self)
Definition: z3py.py:5631
z3py.AstVector.sexpr
def sexpr(self)
Definition: z3py.py:5640
z3py.user_prop_pop
def user_prop_pop(ctx, num_scopes)
Definition: z3py.py:10546
z3py.IntSort
def IntSort(ctx=None)
Definition: z3py.py:2942
z3py.fpIsZero
def fpIsZero(a, ctx=None)
Definition: z3py.py:9659
z3py.OptimizeObjective.upper_values
def upper_values(self)
Definition: z3py.py:7400
z3py.OptimizeObjective._is_max
_is_max
Definition: z3py.py:7386
z3py.Fixedpoint.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:7041
z3py.SortRef.subsort
def subsort(self, other)
Definition: z3py.py:535
z3py.is_rational_value
def is_rational_value(a)
Definition: z3py.py:2583
Z3_get_decl_name
Z3_symbol Z3_API Z3_get_decl_name(Z3_context c, Z3_func_decl d)
Return the constant declaration name as a symbol.
z3py.PartialOrder
def PartialOrder(a, index)
Definition: z3py.py:10488
Z3_enable_trace
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.
z3py.IntNumRef
Definition: z3py.py:2771
z3py.AstVector.__setitem__
def __setitem__(self, i, v)
Definition: z3py.py:5554
Z3_mk_set_add
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
z3py.Goal.ctx
ctx
Definition: z3py.py:5200
z3py.Goal.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:5332
Z3_solver_propagate_fixed
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 ...
z3py.FPRef.__rtruediv__
def __rtruediv__(self, other)
Definition: z3py.py:9017
z3py.Fixedpoint.set
def set(self, *args, **keys)
Definition: z3py.py:7027
Z3_mk_seq_index
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...
z3py.UGT
def UGT(a, b)
Definition: z3py.py:3977
Z3_mk_const_array
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
z3py.Solver.value
def value(self, e)
Definition: z3py.py:6860
Z3_get_decl_kind
Z3_decl_kind Z3_API Z3_get_decl_kind(Z3_context c, Z3_func_decl d)
Return declaration kind corresponding to declaration.
Z3_get_decl_func_decl_parameter
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.
z3py.BitVecRef.__gt__
def __gt__(self, other)
Definition: z3py.py:3577
Z3_mk_str_lt
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.
z3py.UserPropagateBase.propagate
def propagate(self, e, ids, eqs=[])
Definition: z3py.py:10676
Z3_params_set_symbol
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_substitute_vars
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_map_to_string
Z3_string Z3_API Z3_ast_map_to_string(Z3_context c, Z3_ast_map m)
Convert the given map into a string.
Z3_mk_fpa_inf
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_mk_int2real
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.
Z3_apply_result_inc_ref
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.
z3py.FPNumRef.isPositive
def isPositive(self)
Definition: z3py.py:9195
Z3_mk_re_intersect
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
z3py.ArithSortRef.cast
def cast(self, val)
Definition: z3py.py:2163
Z3_mk_fpa_to_fp_float
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_mk_fpa_round_toward_zero
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.
z3py.UDiv
def UDiv(a, b)
Definition: z3py.py:3994
z3py.BV2Int
def BV2Int(a, is_signed=False)
Definition: z3py.py:3751
z3py.Solver.__init__
def __init__(self, solver=None, ctx=None, logFile=None)
Definition: z3py.py:6480
Z3_get_quantifier_num_bound
unsigned Z3_API Z3_get_quantifier_num_bound(Z3_context c, Z3_ast a)
Return number of bound variables of quantifier.
z3py.is_func_decl
def is_func_decl(a)
Definition: z3py.py:787
z3py.RoundTowardZero
def RoundTowardZero(ctx=None)
Definition: z3py.py:9069
z3py.Optimize.reason_unknown
def reason_unknown(self)
Definition: z3py.py:7536
z3py.SortRef.kind
def kind(self)
Definition: z3py.py:519
z3py.BitVecRef.__rshift__
def __rshift__(self, other)
Definition: z3py.py:3609
z3py.WithParams
def WithParams(t, p)
Definition: z3py.py:7904
z3py.Fixedpoint.get_rule_names_along_trace
def get_rule_names_along_trace(self)
Definition: z3py.py:7163
z3py.RecFunction
def RecFunction(name, *sig)
Definition: z3py.py:843
z3py.Xor
def Xor(a, b, ctx=None)
Definition: z3py.py:1654
Z3_mk_bvxor
Z3_ast Z3_API Z3_mk_bvxor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise exclusive-or.
Z3_fpa_is_numeral_subnormal
bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is subnormal.
z3py.Solver.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:6585
z3py.SortRef.__eq__
def __eq__(self, other)
Definition: z3py.py:568
z3py.ModelRef.model
model
Definition: z3py.py:6006
Z3_mk_fpa_sort_16
Z3_sort Z3_API Z3_mk_fpa_sort_16(Z3_context c)
Create the half-precision (16-bit) FloatingPoint sort.
z3py.is_algebraic_value
def is_algebraic_value(a)
Definition: z3py.py:2604
z3py.BVMulNoUnderflow
def BVMulNoUnderflow(a, b)
Definition: z3py.py:4250
z3py.Fixedpoint.parse_file
def parse_file(self, f)
Definition: z3py.py:7204
z3py.is_to_int
def is_to_int(a)
Definition: z3py.py:2757
z3py.AstRef
Definition: z3py.py:305
Z3_mk_fpa_abs
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
Z3_mk_ast_map
Z3_ast_map Z3_API Z3_mk_ast_map(Z3_context c)
Return an empty mapping from AST to AST.
z3py.Probe.__eq__
def __eq__(self, other)
Definition: z3py.py:8064
Z3_solver_get_help
Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s)
Return a string describing all solver available parameters.
z3py.FuncEntry.__del__
def __del__(self)
Definition: z3py.py:5784
z3py.FuncInterp.translate
def translate(self, other_ctx)
Definition: z3py.py:5970
Z3_fixedpoint_get_num_levels
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_mk_is_int
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
Z3_func_interp_get_num_entries
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.
z3py.FPRef.__rsub__
def __rsub__(self, other)
Definition: z3py.py:8934
Z3_mk_fpa_nan
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
Z3_global_param_set
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.
z3py.PropClosures
Definition: z3py.py:10508
z3py.prove
def prove(claim, **keywords)
Definition: z3py.py:8515
z3py.is_bv
def is_bv(a)
Definition: z3py.py:3724
z3py.UserPropagateBase.final
final
Definition: z3py.py:10605
Z3_is_string_sort
bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s)
Check if s is a string sort.
z3py.fpMin
def fpMin(a, b, ctx=None)
Definition: z3py.py:9595
Z3_mk_bvsdiv_no_overflow
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.
Z3_mk_bvuge
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
Z3_mk_array_sort_n
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.
z3py.is_expr
def is_expr(a)
Definition: z3py.py:1135
z3py.Fixedpoint.statistics
def statistics(self)
Definition: z3py.py:7233
z3py.AstRef.__eq__
def __eq__(self, other)
Definition: z3py.py:326
z3py.Datatype.declare
def declare(self, name, *args)
Definition: z3py.py:4766
z3py.Sqrt
def Sqrt(a, ctx=None)
Definition: z3py.py:3197
z3py.SetComplement
def SetComplement(s)
Definition: z3py.py:4673
z3py.is_app_of
def is_app_of(a, k)
Definition: z3py.py:1256
z3py.Solver.solver
solver
Definition: z3py.py:6484
z3py.ModelRef.__getitem__
def __getitem__(self, idx)
Definition: z3py.py:6200
z3py.BVMulNoOverflow
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4243
Z3_get_sort
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.
z3py.Repeat
def Repeat(t, max=4294967295, ctx=None)
Definition: z3py.py:7917
z3py.ApplyResult
Definition: z3py.py:7608
z3py.AstVector.__getitem__
def __getitem__(self, i)
Definition: z3py.py:5530
z3py.fpToReal
def fpToReal(x, ctx=None)
Definition: z3py.py:9957
z3py.Optimize.check
def check(self, *assumptions)
Definition: z3py.py:7527
z3py.FuncInterp.else_value
def else_value(self)
Definition: z3py.py:5897
Z3_goal_convert_model
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,...
z3py.Update
def Update(a, i, v)
Definition: z3py.py:4457
z3py.FPRef.__pos__
def __pos__(self)
Definition: z3py.py:8972
z3py.Z3PPObject.use_pp
def use_pp(self)
Definition: z3py.py:294
z3py.describe_tactics
def describe_tactics()
Definition: z3py.py:7962
z3py.is_bool
def is_bool(a)
Definition: z3py.py:1442
z3py.get_full_version
def get_full_version()
Definition: z3py.py:89
z3py.FuncDeclRef.get_id
def get_id(self)
Definition: z3py.py:671
Z3_get_quantifier_body
Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a)
Return body of quantifier.
z3py.UserPropagateBase.fixed
fixed
Definition: z3py.py:10604
z3py.FuncEntry.__repr__
def __repr__(self)
Definition: z3py.py:5878
Z3_mk_seq_at
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_mk_atmost
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
z3py.FiniteDomainRef.sort
def sort(self)
Definition: z3py.py:7299
z3py.is_lt
def is_lt(a)
Definition: z3py.py:2699
z3py.ExprRef.as_ast
def as_ast(self)
Definition: z3py.py:903
Z3_mk_bvsrem
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
z3py.Solver.unsat_core
def unsat_core(self)
Definition: z3py.py:6723
z3py.PatternRef.as_ast
def as_ast(self)
Definition: z3py.py:1774
Z3_mk_uninterpreted_sort
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
z3py.FloatHalf
def FloatHalf(ctx=None)
Definition: z3py.py:8791
z3py.BitVecRef.__lshift__
def __lshift__(self, other)
Definition: z3py.py:3639
z3py.ArrayRef.sort
def sort(self)
Definition: z3py.py:4288
z3py.ArithRef.__add__
def __add__(self, other)
Definition: z3py.py:2252
Z3_mk_mod
Z3_ast Z3_API Z3_mk_mod(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 mod arg2.
z3py.AlgebraicNumRef.as_decimal
def as_decimal(self, prec)
Definition: z3py.py:2913
Z3_stats_get_key
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_fixedpoint_add_cover
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...
z3py.Optimize.upper_values
def upper_values(self, obj)
Definition: z3py.py:7565
Z3_optimize_get_unsat_core
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 ...
z3py.Fixedpoint.get_num_levels
def get_num_levels(self, predicate)
Definition: z3py.py:7171
z3py.ModelRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:6274
Z3_mk_str_le
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.
z3py.Fixedpoint.param_descrs
def param_descrs(self)
Definition: z3py.py:7037
Z3_optimize_get_model
Z3_model Z3_API Z3_optimize_get_model(Z3_context c, Z3_optimize o)
Retrieve the model for the last Z3_optimize_check.
z3py.BitVecRef.__rmod__
def __rmod__(self, other)
Definition: z3py.py:3527
z3py.AstMap
Definition: z3py.py:5649
z3py.Context.__del__
def __del__(self)
Definition: z3py.py:191
z3py.fpIsSubnormal
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9669
z3py.Goal.__getitem__
def __getitem__(self, arg)
Definition: z3py.py:5317
z3py.FiniteDomainNumRef
Definition: z3py.py:7320
z3py.Probe.__del__
def __del__(self)
Definition: z3py.py:8008
z3py.SetAdd
def SetAdd(s, e)
Definition: z3py.py:4653
z3py.ParamsRef.__del__
def __del__(self)
Definition: z3py.py:5083
z3py.Ext
def Ext(a, b)
Definition: z3py.py:4563
z3py.ApplyResult.sexpr
def sexpr(self)
Definition: z3py.py:7662
z3py.FPNumRef.isNegative
def isNegative(self)
Definition: z3py.py:9199
z3py.Goal.append
def append(self, *args)
Definition: z3py.py:5347
Z3_mk_lambda_const
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.
z3py.UserPropagateBase.add
def add(self, e)
Definition: z3py.py:10668
z3py.fpIsNegative
def fpIsNegative(a, ctx=None)
Definition: z3py.py:9674
z3py.Fixedpoint.declare_var
def declare_var(self, *vars)
Definition: z3py.py:7243
z3py.fpFPToFP
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9836
z3py.fpNEQ
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9743
z3py.OptimizeObjective.upper
def upper(self)
Definition: z3py.py:7392
z3py.Statistics.__repr__
def __repr__(self)
Definition: z3py.py:6311
z3py.CheckSatResult
Definition: z3py.py:6427
z3py.UserPropagateBase.fresh
def fresh(self)
Definition: z3py.py:10665
z3py.Statistics.__del__
def __del__(self)
Definition: z3py.py:6307
z3py.SeqSort
def SeqSort(s)
Definition: z3py.py:10037
Z3_tactic_and_then
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_fpa_get_numeral_sign
bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int *sgn)
Retrieves the sign of a floating-point literal.
z3py.PatternRef
Patterns.
Definition: z3py.py:1770
z3py.Fixedpoint.vars
vars
Definition: z3py.py:7018
z3py.BitVecRef.__invert__
def __invert__(self)
Definition: z3py.py:3452
z3py.BitVecRef.__truediv__
def __truediv__(self, other)
Definition: z3py.py:3482
z3py.Context.ctx
ctx
Definition: z3py.py:186
z3py.SeqSortRef.basis
def basis(self)
Definition: z3py.py:10023
Z3_func_entry_get_num_args
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.
z3py.Map
def Map(f, *args)
Definition: z3py.py:4520
z3py.RatNumRef
Definition: z3py.py:2803
Z3_tactic_or_else
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...
z3py.BVSubNoUnderflow
def BVSubNoUnderflow(a, b, signed)
Definition: z3py.py:4225
Z3_mk_set_subset
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
Z3_solver_get_consequences
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_mk_le
Z3_ast Z3_API Z3_mk_le(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than or equal to.
Z3_mk_bvsgt
Z3_ast Z3_API Z3_mk_bvsgt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than.
z3py.ParThen
def ParThen(t1, t2, ctx=None)
Definition: z3py.py:7873
Z3_mk_bvlshr
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
z3py.args2params
def args2params(arguments, keywords, ctx=None)
Definition: z3py.py:5111
z3py.FuncInterp.entry
def entry(self, idx)
Definition: z3py.py:5950
z3py.Tactic.help
def help(self)
Definition: z3py.py:7768
Z3_mk_pbge
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.
z3py.is_false
def is_false(a)
Definition: z3py.py:1476
z3py.Store
def Store(a, i, v)
Definition: z3py.py:4489
z3py.Probe.__ge__
def __ge__(self, other)
Definition: z3py.py:8051
z3py.FloatSingle
def FloatSingle(ctx=None)
Definition: z3py.py:8801
z3py.ULE
def ULE(a, b)
Definition: z3py.py:3926
z3py.Solver
Definition: z3py.py:6477
Z3_mk_real_sort
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
Z3_get_symbol_string
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.
z3py.FailIf
def FailIf(p, ctx=None)
Definition: z3py.py:8186
Z3_benchmark_to_smtlib_string
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_mk_fpa_sort_single
Z3_sort Z3_API Z3_mk_fpa_sort_single(Z3_context c)
Create the single-precision (32-bit) FloatingPoint sort.
z3py.Optimize.__iadd__
def __iadd__(self, fml)
Definition: z3py.py:7459
Z3_mk_re_empty
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
z3py.Solver.pop
def pop(self, num=1)
Definition: z3py.py:6531
z3py.ExprRef.children
def children(self)
Definition: z3py.py:1026
z3py.ParamDescrsRef.__del__
def __del__(self)
Definition: z3py.py:5145
Z3_fpa_is_numeral_normal
bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t)
Checks whether a given floating-point numeral is normal.
z3py.BoolSort
def BoolSort(ctx=None)
Definition: z3py.py:1553
z3py.get_param
def get_param(name)
Definition: z3py.py:273
Z3_fpa_is_numeral_zero
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.
z3py.ModelRef.decls
def decls(self)
Definition: z3py.py:6244
z3py.AstRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:317
Z3_func_entry_get_value
Z3_ast Z3_API Z3_func_entry_get_value(Z3_context c, Z3_func_entry e)
Return the value of this point.
Z3_fixedpoint_get_rules
Z3_ast_vector Z3_API Z3_fixedpoint_get_rules(Z3_context c, Z3_fixedpoint f)
Retrieve set of rules from fixedpoint context.
z3py.AstVector.__del__
def __del__(self)
Definition: z3py.py:5513
z3py.fpRealToFP
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9855
Z3_mk_seq_nth
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...
z3py.SeqRef.__getitem__
def __getitem__(self, i)
Definition: z3py.py:10057
z3py.Complement
def Complement(re)
Definition: z3py.py:10446
z3py.RealVector
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3120
z3py.UserPropagateBase.eq
eq
Definition: z3py.py:10606
z3py.Optimize.assertions
def assertions(self)
Definition: z3py.py:7578
z3py.Fixedpoint
Fixedpoint.
Definition: z3py.py:7006
z3py.Empty
def Empty(s)
Definition: z3py.py:10175
z3py.QuantifierRef.children
def children(self)
Definition: z3py.py:2007
z3py.Option
def Option(re)
Definition: z3py.py:10434
z3py.ArrayRef.__getitem__
def __getitem__(self, arg)
Definition: z3py.py:4315
Z3_goal_inconsistent
bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g)
Return true if the given goal contains the formula false.
Z3_solver_get_model
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.
Z3_tactic_when
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...
z3py.AstRef.eq
def eq(self, other)
Definition: z3py.py:366
z3py.Statistics.stats
stats
Definition: z3py.py:6300
z3py.Fixedpoint.fixedpoint
fixedpoint
Definition: z3py.py:7012
z3py.fpIsPositive
def fpIsPositive(a, ctx=None)
Definition: z3py.py:9679
Z3_mk_re_concat
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_optimize_get_help
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.
z3py.ReSort
def ReSort(s)
Definition: z3py.py:10354
Z3_mk_mul
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].
z3py.BitVecNumRef.as_string
def as_string(self)
Definition: z3py.py:3717
z3py.RTZ
def RTZ(ctx=None)
Definition: z3py.py:9073
z3py.is_sub
def is_sub(a)
Definition: z3py.py:2639
Z3_fpa_get_numeral_significand_bv
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_mk_seq_extract
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_optimize_minimize
unsigned Z3_API Z3_optimize_minimize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a minimization constraint.
z3py.set_option
def set_option(*args, **kws)
Definition: z3py.py:268
Z3_solver_inc_ref
void Z3_API Z3_solver_inc_ref(Z3_context c, Z3_solver s)
Increment the reference counter of the given solver.
z3py.PropClosures.get
def get(self, ctx)
Definition: z3py.py:10518
z3py.Solver.import_model_converter
def import_model_converter(self, other)
Definition: z3py.py:6719
z3py.ArithRef.__pow__
def __pow__(self, other)
Definition: z3py.py:2323
z3py.BitVecRef.__pos__
def __pos__(self)
Definition: z3py.py:3432
z3py.SubString
def SubString(s, offset, length)
Definition: z3py.py:10160
z3py.When
def When(p, t, ctx=None)
Definition: z3py.py:8205
z3py.Goal.__del__
def __del__(self)
Definition: z3py.py:5209
z3py.is_seq
def is_seq(a)
Definition: z3py.py:10114
Z3_fixedpoint_get_cover_delta
Z3_ast Z3_API Z3_fixedpoint_get_cover_delta(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred)
z3py.ArithRef.__mul__
def __mul__(self, other)
Definition: z3py.py:2275
z3py.FuncEntry.value
def value(self)
Definition: z3py.py:5837
Z3_mk_transitive_closure
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
Z3_mk_int_symbol
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
z3py.SortRef.name
def name(self)
Definition: z3py.py:558
Z3_fixedpoint_add_rule
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:
Z3_optimize_inc_ref
void Z3_API Z3_optimize_inc_ref(Z3_context c, Z3_optimize d)
Increment the reference counter of the given optimize context.
z3py.Fixedpoint.get_rules
def get_rules(self)
Definition: z3py.py:7208
z3py.Probe.__call__
def __call__(self, goal)
Definition: z3py.py:8091
z3py.fpToIEEEBV
def fpToIEEEBV(x, ctx=None)
Definition: z3py.py:9976
Z3_param_descrs_get_documentation
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.
z3py.Q
def Q(a, b, ctx=None)
Definition: z3py.py:3033
z3py.ArithRef.__div__
def __div__(self, other)
Definition: z3py.py:2351
z3py.String
def String(name, ctx=None)
Definition: z3py.py:10145
Z3_mk_bvor
Z3_ast Z3_API Z3_mk_bvor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise or.
Z3_mk_partial_order
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_mk_fpa_round_nearest_ties_to_away
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.
z3py.BitVecRef.__ror__
def __ror__(self, other)
Definition: z3py.py:3376
Z3_mk_piecewise_linear_order
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.
z3py.FiniteDomainNumRef.as_string
def as_string(self)
Definition: z3py.py:7335