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 
2796  """Rational values."""
2797 
2798  def numerator(self):
2799  """ Return the numerator of a Z3 rational numeral.
2800 
2801  >>> is_rational_value(RealVal("3/5"))
2802  True
2803  >>> n = RealVal("3/5")
2804  >>> n.numerator()
2805  3
2806  >>> is_rational_value(Q(3,5))
2807  True
2808  >>> Q(3,5).numerator()
2809  3
2810  """
2811  return IntNumRef(Z3_get_numerator(self.ctx_ref(), self.as_ast()), self.ctx)
2812 
2813  def denominator(self):
2814  """ Return the denominator of a Z3 rational numeral.
2815 
2816  >>> is_rational_value(Q(3,5))
2817  True
2818  >>> n = Q(3,5)
2819  >>> n.denominator()
2820  5
2821  """
2822  return IntNumRef(Z3_get_denominator(self.ctx_ref(), self.as_ast()), self.ctx)
2823 
2825  """ Return the numerator as a Python long.
2826 
2827  >>> v = RealVal(10000000000)
2828  >>> v
2829  10000000000
2830  >>> v + 1
2831  10000000000 + 1
2832  >>> v.numerator_as_long() + 1 == 10000000001
2833  True
2834  """
2835  return self.numerator().as_long()
2836 
2838  """ Return the denominator as a Python long.
2839 
2840  >>> v = RealVal("1/3")
2841  >>> v
2842  1/3
2843  >>> v.denominator_as_long()
2844  3
2845  """
2846  return self.denominator().as_long()
2847 
2848  def is_int(self):
2849  return False
2850 
2851  def is_real(self):
2852  return True
2853 
2854  def is_int_value(self):
2855  return self.denominator().is_int() and self.denominator_as_long() == 1
2856 
2857  def as_long(self):
2858  _z3_assert(self.is_int_value(), "Expected integer fraction")
2859  return self.numerator_as_long()
2860 
2861  def as_decimal(self, prec):
2862  """ Return a Z3 rational value as a string in decimal notation using at most `prec` decimal places.
2863 
2864  >>> v = RealVal("1/5")
2865  >>> v.as_decimal(3)
2866  '0.2'
2867  >>> v = RealVal("1/3")
2868  >>> v.as_decimal(3)
2869  '0.333?'
2870  """
2871  return Z3_get_numeral_decimal_string(self.ctx_ref(), self.as_ast(), prec)
2872 
2873  def as_string(self):
2874  """Return a Z3 rational numeral as a Python string.
2875 
2876  >>> v = Q(3,6)
2877  >>> v.as_string()
2878  '1/2'
2879  """
2880  return Z3_get_numeral_string(self.ctx_ref(), self.as_ast())
2881 
2882  def as_fraction(self):
2883  """Return a Z3 rational as a Python Fraction object.
2884 
2885  >>> v = RealVal("1/5")
2886  >>> v.as_fraction()
2887  Fraction(1, 5)
2888  """
2889  return Fraction(self.numerator_as_long(), self.denominator_as_long())
2890 
2892  """Algebraic irrational values."""
2893 
2894  def approx(self, precision=10):
2895  """Return a Z3 rational number that approximates the algebraic number `self`.
2896  The result `r` is such that |r - self| <= 1/10^precision
2897 
2898  >>> x = simplify(Sqrt(2))
2899  >>> x.approx(20)
2900  6838717160008073720548335/4835703278458516698824704
2901  >>> x.approx(5)
2902  2965821/2097152
2903  """
2904  return RatNumRef(Z3_get_algebraic_number_upper(self.ctx_ref(), self.as_ast(), precision), self.ctx)
2905  def as_decimal(self, prec):
2906  """Return a string representation of the algebraic number `self` in decimal notation using `prec` decimal places
2907 
2908  >>> x = simplify(Sqrt(2))
2909  >>> x.as_decimal(10)
2910  '1.4142135623?'
2911  >>> x.as_decimal(20)
2912  '1.41421356237309504880?'
2913  """
2914  return Z3_get_numeral_decimal_string(self.ctx_ref(), self.as_ast(), prec)
2915 
2916 def _py2expr(a, ctx=None):
2917  if isinstance(a, bool):
2918  return BoolVal(a, ctx)
2919  if _is_int(a):
2920  return IntVal(a, ctx)
2921  if isinstance(a, float):
2922  return RealVal(a, ctx)
2923  if is_expr(a):
2924  return a
2925  if z3_debug():
2926  _z3_assert(False, "Python bool, int, long or float expected")
2927 
2928 def IntSort(ctx=None):
2929  """Return the integer sort in the given context. If `ctx=None`, then the global context is used.
2930 
2931  >>> IntSort()
2932  Int
2933  >>> x = Const('x', IntSort())
2934  >>> is_int(x)
2935  True
2936  >>> x.sort() == IntSort()
2937  True
2938  >>> x.sort() == BoolSort()
2939  False
2940  """
2941  ctx = _get_ctx(ctx)
2942  return ArithSortRef(Z3_mk_int_sort(ctx.ref()), ctx)
2943 
2944 def RealSort(ctx=None):
2945  """Return the real sort in the given context. If `ctx=None`, then the global context is used.
2946 
2947  >>> RealSort()
2948  Real
2949  >>> x = Const('x', RealSort())
2950  >>> is_real(x)
2951  True
2952  >>> is_int(x)
2953  False
2954  >>> x.sort() == RealSort()
2955  True
2956  """
2957  ctx = _get_ctx(ctx)
2958  return ArithSortRef(Z3_mk_real_sort(ctx.ref()), ctx)
2959 
2960 def _to_int_str(val):
2961  if isinstance(val, float):
2962  return str(int(val))
2963  elif isinstance(val, bool):
2964  if val:
2965  return "1"
2966  else:
2967  return "0"
2968  elif _is_int(val):
2969  return str(val)
2970  elif isinstance(val, str):
2971  return val
2972  if z3_debug():
2973  _z3_assert(False, "Python value cannot be used as a Z3 integer")
2974 
2975 def IntVal(val, ctx=None):
2976  """Return a Z3 integer value. If `ctx=None`, then the global context is used.
2977 
2978  >>> IntVal(1)
2979  1
2980  >>> IntVal("100")
2981  100
2982  """
2983  ctx = _get_ctx(ctx)
2984  return IntNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), IntSort(ctx).ast), ctx)
2985 
2986 def RealVal(val, ctx=None):
2987  """Return a Z3 real value.
2988 
2989  `val` may be a Python int, long, float or string representing a number in decimal or rational notation.
2990  If `ctx=None`, then the global context is used.
2991 
2992  >>> RealVal(1)
2993  1
2994  >>> RealVal(1).sort()
2995  Real
2996  >>> RealVal("3/5")
2997  3/5
2998  >>> RealVal("1.5")
2999  3/2
3000  """
3001  ctx = _get_ctx(ctx)
3002  return RatNumRef(Z3_mk_numeral(ctx.ref(), str(val), RealSort(ctx).ast), ctx)
3003 
3004 def RatVal(a, b, ctx=None):
3005  """Return a Z3 rational a/b.
3006 
3007  If `ctx=None`, then the global context is used.
3008 
3009  >>> RatVal(3,5)
3010  3/5
3011  >>> RatVal(3,5).sort()
3012  Real
3013  """
3014  if z3_debug():
3015  _z3_assert(_is_int(a) or isinstance(a, str), "First argument cannot be converted into an integer")
3016  _z3_assert(_is_int(b) or isinstance(b, str), "Second argument cannot be converted into an integer")
3017  return simplify(RealVal(a, ctx)/RealVal(b, ctx))
3018 
3019 def Q(a, b, ctx=None):
3020  """Return a Z3 rational a/b.
3021 
3022  If `ctx=None`, then the global context is used.
3023 
3024  >>> Q(3,5)
3025  3/5
3026  >>> Q(3,5).sort()
3027  Real
3028  """
3029  return simplify(RatVal(a, b))
3030 
3031 def Int(name, ctx=None):
3032  """Return an integer constant named `name`. If `ctx=None`, then the global context is used.
3033 
3034  >>> x = Int('x')
3035  >>> is_int(x)
3036  True
3037  >>> is_int(x + 1)
3038  True
3039  """
3040  ctx = _get_ctx(ctx)
3041  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), IntSort(ctx).ast), ctx)
3042 
3043 def Ints(names, ctx=None):
3044  """Return a tuple of Integer constants.
3045 
3046  >>> x, y, z = Ints('x y z')
3047  >>> Sum(x, y, z)
3048  x + y + z
3049  """
3050  ctx = _get_ctx(ctx)
3051  if isinstance(names, str):
3052  names = names.split(" ")
3053  return [Int(name, ctx) for name in names]
3054 
3055 def IntVector(prefix, sz, ctx=None):
3056  """Return a list of integer constants of size `sz`.
3057 
3058  >>> X = IntVector('x', 3)
3059  >>> X
3060  [x__0, x__1, x__2]
3061  >>> Sum(X)
3062  x__0 + x__1 + x__2
3063  """
3064  ctx = _get_ctx(ctx)
3065  return [ Int('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3066 
3067 def FreshInt(prefix='x', ctx=None):
3068  """Return a fresh integer constant in the given context using the given prefix.
3069 
3070  >>> x = FreshInt()
3071  >>> y = FreshInt()
3072  >>> eq(x, y)
3073  False
3074  >>> x.sort()
3075  Int
3076  """
3077  ctx = _get_ctx(ctx)
3078  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, IntSort(ctx).ast), ctx)
3079 
3080 def Real(name, ctx=None):
3081  """Return a real constant named `name`. If `ctx=None`, then the global context is used.
3082 
3083  >>> x = Real('x')
3084  >>> is_real(x)
3085  True
3086  >>> is_real(x + 1)
3087  True
3088  """
3089  ctx = _get_ctx(ctx)
3090  return ArithRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), RealSort(ctx).ast), ctx)
3091 
3092 def Reals(names, ctx=None):
3093  """Return a tuple of real constants.
3094 
3095  >>> x, y, z = Reals('x y z')
3096  >>> Sum(x, y, z)
3097  x + y + z
3098  >>> Sum(x, y, z).sort()
3099  Real
3100  """
3101  ctx = _get_ctx(ctx)
3102  if isinstance(names, str):
3103  names = names.split(" ")
3104  return [Real(name, ctx) for name in names]
3105 
3106 def RealVector(prefix, sz, ctx=None):
3107  """Return a list of real constants of size `sz`.
3108 
3109  >>> X = RealVector('x', 3)
3110  >>> X
3111  [x__0, x__1, x__2]
3112  >>> Sum(X)
3113  x__0 + x__1 + x__2
3114  >>> Sum(X).sort()
3115  Real
3116  """
3117  ctx = _get_ctx(ctx)
3118  return [ Real('%s__%s' % (prefix, i), ctx) for i in range(sz) ]
3119 
3120 def FreshReal(prefix='b', ctx=None):
3121  """Return a fresh real constant in the given context using the given prefix.
3122 
3123  >>> x = FreshReal()
3124  >>> y = FreshReal()
3125  >>> eq(x, y)
3126  False
3127  >>> x.sort()
3128  Real
3129  """
3130  ctx = _get_ctx(ctx)
3131  return ArithRef(Z3_mk_fresh_const(ctx.ref(), prefix, RealSort(ctx).ast), ctx)
3132 
3133 def ToReal(a):
3134  """ Return the Z3 expression ToReal(a).
3135 
3136  >>> x = Int('x')
3137  >>> x.sort()
3138  Int
3139  >>> n = ToReal(x)
3140  >>> n
3141  ToReal(x)
3142  >>> n.sort()
3143  Real
3144  """
3145  if z3_debug():
3146  _z3_assert(a.is_int(), "Z3 integer expression expected.")
3147  ctx = a.ctx
3148  return ArithRef(Z3_mk_int2real(ctx.ref(), a.as_ast()), ctx)
3149 
3150 def ToInt(a):
3151  """ Return the Z3 expression ToInt(a).
3152 
3153  >>> x = Real('x')
3154  >>> x.sort()
3155  Real
3156  >>> n = ToInt(x)
3157  >>> n
3158  ToInt(x)
3159  >>> n.sort()
3160  Int
3161  """
3162  if z3_debug():
3163  _z3_assert(a.is_real(), "Z3 real expression expected.")
3164  ctx = a.ctx
3165  return ArithRef(Z3_mk_real2int(ctx.ref(), a.as_ast()), ctx)
3166 
3167 def IsInt(a):
3168  """ Return the Z3 predicate IsInt(a).
3169 
3170  >>> x = Real('x')
3171  >>> IsInt(x + "1/2")
3172  IsInt(x + 1/2)
3173  >>> solve(IsInt(x + "1/2"), x > 0, x < 1)
3174  [x = 1/2]
3175  >>> solve(IsInt(x + "1/2"), x > 0, x < 1, x != "1/2")
3176  no solution
3177  """
3178  if z3_debug():
3179  _z3_assert(a.is_real(), "Z3 real expression expected.")
3180  ctx = a.ctx
3181  return BoolRef(Z3_mk_is_int(ctx.ref(), a.as_ast()), ctx)
3182 
3183 def Sqrt(a, ctx=None):
3184  """ Return a Z3 expression which represents the square root of a.
3185 
3186  >>> x = Real('x')
3187  >>> Sqrt(x)
3188  x**(1/2)
3189  """
3190  if not is_expr(a):
3191  ctx = _get_ctx(ctx)
3192  a = RealVal(a, ctx)
3193  return a ** "1/2"
3194 
3195 def Cbrt(a, ctx=None):
3196  """ Return a Z3 expression which represents the cubic root of a.
3197 
3198  >>> x = Real('x')
3199  >>> Cbrt(x)
3200  x**(1/3)
3201  """
3202  if not is_expr(a):
3203  ctx = _get_ctx(ctx)
3204  a = RealVal(a, ctx)
3205  return a ** "1/3"
3206 
3207 
3212 
3214  """Bit-vector sort."""
3215 
3216  def size(self):
3217  """Return the size (number of bits) of the bit-vector sort `self`.
3218 
3219  >>> b = BitVecSort(32)
3220  >>> b.size()
3221  32
3222  """
3223  return int(Z3_get_bv_sort_size(self.ctx_ref(), self.ast))
3224 
3225  def subsort(self, other):
3226  return is_bv_sort(other) and self.size() < other.size()
3227 
3228  def cast(self, val):
3229  """Try to cast `val` as a Bit-Vector.
3230 
3231  >>> b = BitVecSort(32)
3232  >>> b.cast(10)
3233  10
3234  >>> b.cast(10).sexpr()
3235  '#x0000000a'
3236  """
3237  if is_expr(val):
3238  if z3_debug():
3239  _z3_assert(self.ctx == val.ctx, "Context mismatch")
3240  # Idea: use sign_extend if sort of val is a bitvector of smaller size
3241  return val
3242  else:
3243  return BitVecVal(val, self)
3244 
3245 def is_bv_sort(s):
3246  """Return True if `s` is a Z3 bit-vector sort.
3247 
3248  >>> is_bv_sort(BitVecSort(32))
3249  True
3250  >>> is_bv_sort(IntSort())
3251  False
3252  """
3253  return isinstance(s, BitVecSortRef)
3254 
3256  """Bit-vector expressions."""
3257 
3258  def sort(self):
3259  """Return the sort of the bit-vector expression `self`.
3260 
3261  >>> x = BitVec('x', 32)
3262  >>> x.sort()
3263  BitVec(32)
3264  >>> x.sort() == BitVecSort(32)
3265  True
3266  """
3267  return BitVecSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
3268 
3269  def size(self):
3270  """Return the number of bits of the bit-vector expression `self`.
3271 
3272  >>> x = BitVec('x', 32)
3273  >>> (x + 1).size()
3274  32
3275  >>> Concat(x, x).size()
3276  64
3277  """
3278  return self.sort().size()
3279 
3280  def __add__(self, other):
3281  """Create the Z3 expression `self + other`.
3282 
3283  >>> x = BitVec('x', 32)
3284  >>> y = BitVec('y', 32)
3285  >>> x + y
3286  x + y
3287  >>> (x + y).sort()
3288  BitVec(32)
3289  """
3290  a, b = _coerce_exprs(self, other)
3291  return BitVecRef(Z3_mk_bvadd(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3292 
3293  def __radd__(self, other):
3294  """Create the Z3 expression `other + self`.
3295 
3296  >>> x = BitVec('x', 32)
3297  >>> 10 + x
3298  10 + x
3299  """
3300  a, b = _coerce_exprs(self, other)
3301  return BitVecRef(Z3_mk_bvadd(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3302 
3303  def __mul__(self, other):
3304  """Create the Z3 expression `self * other`.
3305 
3306  >>> x = BitVec('x', 32)
3307  >>> y = BitVec('y', 32)
3308  >>> x * y
3309  x*y
3310  >>> (x * y).sort()
3311  BitVec(32)
3312  """
3313  a, b = _coerce_exprs(self, other)
3314  return BitVecRef(Z3_mk_bvmul(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3315 
3316  def __rmul__(self, other):
3317  """Create the Z3 expression `other * self`.
3318 
3319  >>> x = BitVec('x', 32)
3320  >>> 10 * x
3321  10*x
3322  """
3323  a, b = _coerce_exprs(self, other)
3324  return BitVecRef(Z3_mk_bvmul(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3325 
3326  def __sub__(self, other):
3327  """Create the Z3 expression `self - other`.
3328 
3329  >>> x = BitVec('x', 32)
3330  >>> y = BitVec('y', 32)
3331  >>> x - y
3332  x - y
3333  >>> (x - y).sort()
3334  BitVec(32)
3335  """
3336  a, b = _coerce_exprs(self, other)
3337  return BitVecRef(Z3_mk_bvsub(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3338 
3339  def __rsub__(self, other):
3340  """Create the Z3 expression `other - self`.
3341 
3342  >>> x = BitVec('x', 32)
3343  >>> 10 - x
3344  10 - x
3345  """
3346  a, b = _coerce_exprs(self, other)
3347  return BitVecRef(Z3_mk_bvsub(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3348 
3349  def __or__(self, other):
3350  """Create the Z3 expression bitwise-or `self | other`.
3351 
3352  >>> x = BitVec('x', 32)
3353  >>> y = BitVec('y', 32)
3354  >>> x | y
3355  x | y
3356  >>> (x | y).sort()
3357  BitVec(32)
3358  """
3359  a, b = _coerce_exprs(self, other)
3360  return BitVecRef(Z3_mk_bvor(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3361 
3362  def __ror__(self, other):
3363  """Create the Z3 expression bitwise-or `other | self`.
3364 
3365  >>> x = BitVec('x', 32)
3366  >>> 10 | x
3367  10 | x
3368  """
3369  a, b = _coerce_exprs(self, other)
3370  return BitVecRef(Z3_mk_bvor(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3371 
3372  def __and__(self, other):
3373  """Create the Z3 expression bitwise-and `self & other`.
3374 
3375  >>> x = BitVec('x', 32)
3376  >>> y = BitVec('y', 32)
3377  >>> x & y
3378  x & y
3379  >>> (x & y).sort()
3380  BitVec(32)
3381  """
3382  a, b = _coerce_exprs(self, other)
3383  return BitVecRef(Z3_mk_bvand(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3384 
3385  def __rand__(self, other):
3386  """Create the Z3 expression bitwise-or `other & self`.
3387 
3388  >>> x = BitVec('x', 32)
3389  >>> 10 & x
3390  10 & x
3391  """
3392  a, b = _coerce_exprs(self, other)
3393  return BitVecRef(Z3_mk_bvand(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3394 
3395  def __xor__(self, other):
3396  """Create the Z3 expression bitwise-xor `self ^ other`.
3397 
3398  >>> x = BitVec('x', 32)
3399  >>> y = BitVec('y', 32)
3400  >>> x ^ y
3401  x ^ y
3402  >>> (x ^ y).sort()
3403  BitVec(32)
3404  """
3405  a, b = _coerce_exprs(self, other)
3406  return BitVecRef(Z3_mk_bvxor(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3407 
3408  def __rxor__(self, other):
3409  """Create the Z3 expression bitwise-xor `other ^ self`.
3410 
3411  >>> x = BitVec('x', 32)
3412  >>> 10 ^ x
3413  10 ^ x
3414  """
3415  a, b = _coerce_exprs(self, other)
3416  return BitVecRef(Z3_mk_bvxor(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3417 
3418  def __pos__(self):
3419  """Return `self`.
3420 
3421  >>> x = BitVec('x', 32)
3422  >>> +x
3423  x
3424  """
3425  return self
3426 
3427  def __neg__(self):
3428  """Return an expression representing `-self`.
3429 
3430  >>> x = BitVec('x', 32)
3431  >>> -x
3432  -x
3433  >>> simplify(-(-x))
3434  x
3435  """
3436  return BitVecRef(Z3_mk_bvneg(self.ctx_ref(), self.as_ast()), self.ctx)
3437 
3438  def __invert__(self):
3439  """Create the Z3 expression bitwise-not `~self`.
3440 
3441  >>> x = BitVec('x', 32)
3442  >>> ~x
3443  ~x
3444  >>> simplify(~(~x))
3445  x
3446  """
3447  return BitVecRef(Z3_mk_bvnot(self.ctx_ref(), self.as_ast()), self.ctx)
3448 
3449  def __div__(self, other):
3450  """Create the Z3 expression (signed) division `self / other`.
3451 
3452  Use the function UDiv() for unsigned division.
3453 
3454  >>> x = BitVec('x', 32)
3455  >>> y = BitVec('y', 32)
3456  >>> x / y
3457  x/y
3458  >>> (x / y).sort()
3459  BitVec(32)
3460  >>> (x / y).sexpr()
3461  '(bvsdiv x y)'
3462  >>> UDiv(x, y).sexpr()
3463  '(bvudiv x y)'
3464  """
3465  a, b = _coerce_exprs(self, other)
3466  return BitVecRef(Z3_mk_bvsdiv(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3467 
3468  def __truediv__(self, other):
3469  """Create the Z3 expression (signed) division `self / other`."""
3470  return self.__div__(other)
3471 
3472  def __rdiv__(self, other):
3473  """Create the Z3 expression (signed) division `other / self`.
3474 
3475  Use the function UDiv() for unsigned division.
3476 
3477  >>> x = BitVec('x', 32)
3478  >>> 10 / x
3479  10/x
3480  >>> (10 / x).sexpr()
3481  '(bvsdiv #x0000000a x)'
3482  >>> UDiv(10, x).sexpr()
3483  '(bvudiv #x0000000a x)'
3484  """
3485  a, b = _coerce_exprs(self, other)
3486  return BitVecRef(Z3_mk_bvsdiv(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3487 
3488  def __rtruediv__(self, other):
3489  """Create the Z3 expression (signed) division `other / self`."""
3490  return self.__rdiv__(other)
3491 
3492  def __mod__(self, other):
3493  """Create the Z3 expression (signed) mod `self % other`.
3494 
3495  Use the function URem() for unsigned remainder, and SRem() for signed remainder.
3496 
3497  >>> x = BitVec('x', 32)
3498  >>> y = BitVec('y', 32)
3499  >>> x % y
3500  x%y
3501  >>> (x % y).sort()
3502  BitVec(32)
3503  >>> (x % y).sexpr()
3504  '(bvsmod x y)'
3505  >>> URem(x, y).sexpr()
3506  '(bvurem x y)'
3507  >>> SRem(x, y).sexpr()
3508  '(bvsrem x y)'
3509  """
3510  a, b = _coerce_exprs(self, other)
3511  return BitVecRef(Z3_mk_bvsmod(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3512 
3513  def __rmod__(self, other):
3514  """Create the Z3 expression (signed) mod `other % self`.
3515 
3516  Use the function URem() for unsigned remainder, and SRem() for signed remainder.
3517 
3518  >>> x = BitVec('x', 32)
3519  >>> 10 % x
3520  10%x
3521  >>> (10 % x).sexpr()
3522  '(bvsmod #x0000000a x)'
3523  >>> URem(10, x).sexpr()
3524  '(bvurem #x0000000a x)'
3525  >>> SRem(10, x).sexpr()
3526  '(bvsrem #x0000000a x)'
3527  """
3528  a, b = _coerce_exprs(self, other)
3529  return BitVecRef(Z3_mk_bvsmod(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3530 
3531  def __le__(self, other):
3532  """Create the Z3 expression (signed) `other <= self`.
3533 
3534  Use the function ULE() for unsigned less than or equal to.
3535 
3536  >>> x, y = BitVecs('x y', 32)
3537  >>> x <= y
3538  x <= y
3539  >>> (x <= y).sexpr()
3540  '(bvsle x y)'
3541  >>> ULE(x, y).sexpr()
3542  '(bvule x y)'
3543  """
3544  a, b = _coerce_exprs(self, other)
3545  return BoolRef(Z3_mk_bvsle(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3546 
3547  def __lt__(self, other):
3548  """Create the Z3 expression (signed) `other < self`.
3549 
3550  Use the function ULT() for unsigned less than.
3551 
3552  >>> x, y = BitVecs('x y', 32)
3553  >>> x < y
3554  x < y
3555  >>> (x < y).sexpr()
3556  '(bvslt x y)'
3557  >>> ULT(x, y).sexpr()
3558  '(bvult x y)'
3559  """
3560  a, b = _coerce_exprs(self, other)
3561  return BoolRef(Z3_mk_bvslt(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3562 
3563  def __gt__(self, other):
3564  """Create the Z3 expression (signed) `other > self`.
3565 
3566  Use the function UGT() for unsigned greater than.
3567 
3568  >>> x, y = BitVecs('x y', 32)
3569  >>> x > y
3570  x > y
3571  >>> (x > y).sexpr()
3572  '(bvsgt x y)'
3573  >>> UGT(x, y).sexpr()
3574  '(bvugt x y)'
3575  """
3576  a, b = _coerce_exprs(self, other)
3577  return BoolRef(Z3_mk_bvsgt(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3578 
3579  def __ge__(self, other):
3580  """Create the Z3 expression (signed) `other >= self`.
3581 
3582  Use the function UGE() for unsigned greater than or equal to.
3583 
3584  >>> x, y = BitVecs('x y', 32)
3585  >>> x >= y
3586  x >= y
3587  >>> (x >= y).sexpr()
3588  '(bvsge x y)'
3589  >>> UGE(x, y).sexpr()
3590  '(bvuge x y)'
3591  """
3592  a, b = _coerce_exprs(self, other)
3593  return BoolRef(Z3_mk_bvsge(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3594 
3595  def __rshift__(self, other):
3596  """Create the Z3 expression (arithmetical) right shift `self >> other`
3597 
3598  Use the function LShR() for the right logical shift
3599 
3600  >>> x, y = BitVecs('x y', 32)
3601  >>> x >> y
3602  x >> y
3603  >>> (x >> y).sexpr()
3604  '(bvashr x y)'
3605  >>> LShR(x, y).sexpr()
3606  '(bvlshr x y)'
3607  >>> BitVecVal(4, 3)
3608  4
3609  >>> BitVecVal(4, 3).as_signed_long()
3610  -4
3611  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
3612  -2
3613  >>> simplify(BitVecVal(4, 3) >> 1)
3614  6
3615  >>> simplify(LShR(BitVecVal(4, 3), 1))
3616  2
3617  >>> simplify(BitVecVal(2, 3) >> 1)
3618  1
3619  >>> simplify(LShR(BitVecVal(2, 3), 1))
3620  1
3621  """
3622  a, b = _coerce_exprs(self, other)
3623  return BitVecRef(Z3_mk_bvashr(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3624 
3625  def __lshift__(self, other):
3626  """Create the Z3 expression left shift `self << other`
3627 
3628  >>> x, y = BitVecs('x y', 32)
3629  >>> x << y
3630  x << y
3631  >>> (x << y).sexpr()
3632  '(bvshl x y)'
3633  >>> simplify(BitVecVal(2, 3) << 1)
3634  4
3635  """
3636  a, b = _coerce_exprs(self, other)
3637  return BitVecRef(Z3_mk_bvshl(self.ctx_ref(), a.as_ast(), b.as_ast()), self.ctx)
3638 
3639  def __rrshift__(self, other):
3640  """Create the Z3 expression (arithmetical) right shift `other` >> `self`.
3641 
3642  Use the function LShR() for the right logical shift
3643 
3644  >>> x = BitVec('x', 32)
3645  >>> 10 >> x
3646  10 >> x
3647  >>> (10 >> x).sexpr()
3648  '(bvashr #x0000000a x)'
3649  """
3650  a, b = _coerce_exprs(self, other)
3651  return BitVecRef(Z3_mk_bvashr(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3652 
3653  def __rlshift__(self, other):
3654  """Create the Z3 expression left 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  '(bvshl #x0000000a x)'
3663  """
3664  a, b = _coerce_exprs(self, other)
3665  return BitVecRef(Z3_mk_bvshl(self.ctx_ref(), b.as_ast(), a.as_ast()), self.ctx)
3666 
3668  """Bit-vector values."""
3669 
3670  def as_long(self):
3671  """Return a Z3 bit-vector numeral as a Python long (bignum) numeral.
3672 
3673  >>> v = BitVecVal(0xbadc0de, 32)
3674  >>> v
3675  195936478
3676  >>> print("0x%.8x" % v.as_long())
3677  0x0badc0de
3678  """
3679  return int(self.as_string())
3680 
3681  def as_signed_long(self):
3682  """Return a Z3 bit-vector numeral as a Python long (bignum) numeral. The most significant bit is assumed to be the sign.
3683 
3684  >>> BitVecVal(4, 3).as_signed_long()
3685  -4
3686  >>> BitVecVal(7, 3).as_signed_long()
3687  -1
3688  >>> BitVecVal(3, 3).as_signed_long()
3689  3
3690  >>> BitVecVal(2**32 - 1, 32).as_signed_long()
3691  -1
3692  >>> BitVecVal(2**64 - 1, 64).as_signed_long()
3693  -1
3694  """
3695  sz = self.size()
3696  val = self.as_long()
3697  if val >= 2**(sz - 1):
3698  val = val - 2**sz
3699  if val < -2**(sz - 1):
3700  val = val + 2**sz
3701  return int(val)
3702 
3703  def as_string(self):
3704  return Z3_get_numeral_string(self.ctx_ref(), self.as_ast())
3705 
3706 def is_bv(a):
3707  """Return `True` if `a` is a Z3 bit-vector expression.
3708 
3709  >>> b = BitVec('b', 32)
3710  >>> is_bv(b)
3711  True
3712  >>> is_bv(b + 10)
3713  True
3714  >>> is_bv(Int('x'))
3715  False
3716  """
3717  return isinstance(a, BitVecRef)
3718 
3720  """Return `True` if `a` is a Z3 bit-vector numeral value.
3721 
3722  >>> b = BitVec('b', 32)
3723  >>> is_bv_value(b)
3724  False
3725  >>> b = BitVecVal(10, 32)
3726  >>> b
3727  10
3728  >>> is_bv_value(b)
3729  True
3730  """
3731  return is_bv(a) and _is_numeral(a.ctx, a.as_ast())
3732 
3733 def BV2Int(a, is_signed=False):
3734  """Return the Z3 expression BV2Int(a).
3735 
3736  >>> b = BitVec('b', 3)
3737  >>> BV2Int(b).sort()
3738  Int
3739  >>> x = Int('x')
3740  >>> x > BV2Int(b)
3741  x > BV2Int(b)
3742  >>> x > BV2Int(b, is_signed=False)
3743  x > BV2Int(b)
3744  >>> x > BV2Int(b, is_signed=True)
3745  x > If(b < 0, BV2Int(b) - 8, BV2Int(b))
3746  >>> solve(x > BV2Int(b), b == 1, x < 3)
3747  [x = 2, b = 1]
3748  """
3749  if z3_debug():
3750  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
3751  ctx = a.ctx
3752 
3753  return ArithRef(Z3_mk_bv2int(ctx.ref(), a.as_ast(), is_signed), ctx)
3754 
3755 def Int2BV(a, num_bits):
3756  """Return the z3 expression Int2BV(a, num_bits).
3757  It is a bit-vector of width num_bits and represents the
3758  modulo of a by 2^num_bits
3759  """
3760  ctx = a.ctx
3761  return BitVecRef(Z3_mk_int2bv(ctx.ref(), num_bits, a.as_ast()), ctx)
3762 
3763 def BitVecSort(sz, ctx=None):
3764  """Return a Z3 bit-vector sort of the given size. If `ctx=None`, then the global context is used.
3765 
3766  >>> Byte = BitVecSort(8)
3767  >>> Word = BitVecSort(16)
3768  >>> Byte
3769  BitVec(8)
3770  >>> x = Const('x', Byte)
3771  >>> eq(x, BitVec('x', 8))
3772  True
3773  """
3774  ctx = _get_ctx(ctx)
3775  return BitVecSortRef(Z3_mk_bv_sort(ctx.ref(), sz), ctx)
3776 
3777 def BitVecVal(val, bv, ctx=None):
3778  """Return a bit-vector value with the given number of bits. If `ctx=None`, then the global context is used.
3779 
3780  >>> v = BitVecVal(10, 32)
3781  >>> v
3782  10
3783  >>> print("0x%.8x" % v.as_long())
3784  0x0000000a
3785  """
3786  if is_bv_sort(bv):
3787  ctx = bv.ctx
3788  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), bv.ast), ctx)
3789  else:
3790  ctx = _get_ctx(ctx)
3791  return BitVecNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), BitVecSort(bv, ctx).ast), ctx)
3792 
3793 def BitVec(name, bv, ctx=None):
3794  """Return a bit-vector constant named `name`. `bv` may be the number of bits of a bit-vector sort.
3795  If `ctx=None`, then the global context is used.
3796 
3797  >>> x = BitVec('x', 16)
3798  >>> is_bv(x)
3799  True
3800  >>> x.size()
3801  16
3802  >>> x.sort()
3803  BitVec(16)
3804  >>> word = BitVecSort(16)
3805  >>> x2 = BitVec('x', word)
3806  >>> eq(x, x2)
3807  True
3808  """
3809  if isinstance(bv, BitVecSortRef):
3810  ctx = bv.ctx
3811  else:
3812  ctx = _get_ctx(ctx)
3813  bv = BitVecSort(bv, ctx)
3814  return BitVecRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), bv.ast), ctx)
3815 
3816 def BitVecs(names, bv, ctx=None):
3817  """Return a tuple of bit-vector constants of size bv.
3818 
3819  >>> x, y, z = BitVecs('x y z', 16)
3820  >>> x.size()
3821  16
3822  >>> x.sort()
3823  BitVec(16)
3824  >>> Sum(x, y, z)
3825  0 + x + y + z
3826  >>> Product(x, y, z)
3827  1*x*y*z
3828  >>> simplify(Product(x, y, z))
3829  x*y*z
3830  """
3831  ctx = _get_ctx(ctx)
3832  if isinstance(names, str):
3833  names = names.split(" ")
3834  return [BitVec(name, bv, ctx) for name in names]
3835 
3836 def Concat(*args):
3837  """Create a Z3 bit-vector concatenation expression.
3838 
3839  >>> v = BitVecVal(1, 4)
3840  >>> Concat(v, v+1, v)
3841  Concat(Concat(1, 1 + 1), 1)
3842  >>> simplify(Concat(v, v+1, v))
3843  289
3844  >>> print("%.3x" % simplify(Concat(v, v+1, v)).as_long())
3845  121
3846  """
3847  args = _get_args(args)
3848  sz = len(args)
3849  if z3_debug():
3850  _z3_assert(sz >= 2, "At least two arguments expected.")
3851 
3852  ctx = None
3853  for a in args:
3854  if is_expr(a):
3855  ctx = a.ctx
3856  break
3857  if is_seq(args[0]) or isinstance(args[0], str):
3858  args = [_coerce_seq(s, ctx) for s in args]
3859  if z3_debug():
3860  _z3_assert(all([is_seq(a) for a in args]), "All arguments must be sequence expressions.")
3861  v = (Ast * sz)()
3862  for i in range(sz):
3863  v[i] = args[i].as_ast()
3864  return SeqRef(Z3_mk_seq_concat(ctx.ref(), sz, v), ctx)
3865 
3866  if is_re(args[0]):
3867  if z3_debug():
3868  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
3869  v = (Ast * sz)()
3870  for i in range(sz):
3871  v[i] = args[i].as_ast()
3872  return ReRef(Z3_mk_re_concat(ctx.ref(), sz, v), ctx)
3873 
3874  if z3_debug():
3875  _z3_assert(all([is_bv(a) for a in args]), "All arguments must be Z3 bit-vector expressions.")
3876  r = args[0]
3877  for i in range(sz - 1):
3878  r = BitVecRef(Z3_mk_concat(ctx.ref(), r.as_ast(), args[i+1].as_ast()), ctx)
3879  return r
3880 
3881 def Extract(high, low, a):
3882  """Create a Z3 bit-vector extraction expression, or create a string extraction expression.
3883 
3884  >>> x = BitVec('x', 8)
3885  >>> Extract(6, 2, x)
3886  Extract(6, 2, x)
3887  >>> Extract(6, 2, x).sort()
3888  BitVec(5)
3889  >>> simplify(Extract(StringVal("abcd"),2,1))
3890  "c"
3891  """
3892  if isinstance(high, str):
3893  high = StringVal(high)
3894  if is_seq(high):
3895  s = high
3896  offset, length = _coerce_exprs(low, a, s.ctx)
3897  return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
3898  if z3_debug():
3899  _z3_assert(low <= high, "First argument must be greater than or equal to second argument")
3900  _z3_assert(_is_int(high) and high >= 0 and _is_int(low) and low >= 0, "First and second arguments must be non negative integers")
3901  _z3_assert(is_bv(a), "Third argument must be a Z3 bit-vector expression")
3902  return BitVecRef(Z3_mk_extract(a.ctx_ref(), high, low, a.as_ast()), a.ctx)
3903 
3904 def _check_bv_args(a, b):
3905  if z3_debug():
3906  _z3_assert(is_bv(a) or is_bv(b), "First or second argument must be a Z3 bit-vector expression")
3907 
3908 def ULE(a, b):
3909  """Create the Z3 expression (unsigned) `other <= self`.
3910 
3911  Use the operator <= for signed less than or equal to.
3912 
3913  >>> x, y = BitVecs('x y', 32)
3914  >>> ULE(x, y)
3915  ULE(x, y)
3916  >>> (x <= y).sexpr()
3917  '(bvsle x y)'
3918  >>> ULE(x, y).sexpr()
3919  '(bvule x y)'
3920  """
3921  _check_bv_args(a, b)
3922  a, b = _coerce_exprs(a, b)
3923  return BoolRef(Z3_mk_bvule(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3924 
3925 def ULT(a, b):
3926  """Create the Z3 expression (unsigned) `other < self`.
3927 
3928  Use the operator < for signed less than.
3929 
3930  >>> x, y = BitVecs('x y', 32)
3931  >>> ULT(x, y)
3932  ULT(x, y)
3933  >>> (x < y).sexpr()
3934  '(bvslt x y)'
3935  >>> ULT(x, y).sexpr()
3936  '(bvult x y)'
3937  """
3938  _check_bv_args(a, b)
3939  a, b = _coerce_exprs(a, b)
3940  return BoolRef(Z3_mk_bvult(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3941 
3942 def UGE(a, b):
3943  """Create the Z3 expression (unsigned) `other >= self`.
3944 
3945  Use the operator >= for signed greater than or equal to.
3946 
3947  >>> x, y = BitVecs('x y', 32)
3948  >>> UGE(x, y)
3949  UGE(x, y)
3950  >>> (x >= y).sexpr()
3951  '(bvsge x y)'
3952  >>> UGE(x, y).sexpr()
3953  '(bvuge x y)'
3954  """
3955  _check_bv_args(a, b)
3956  a, b = _coerce_exprs(a, b)
3957  return BoolRef(Z3_mk_bvuge(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3958 
3959 def UGT(a, b):
3960  """Create the Z3 expression (unsigned) `other > self`.
3961 
3962  Use the operator > for signed greater than.
3963 
3964  >>> x, y = BitVecs('x y', 32)
3965  >>> UGT(x, y)
3966  UGT(x, y)
3967  >>> (x > y).sexpr()
3968  '(bvsgt x y)'
3969  >>> UGT(x, y).sexpr()
3970  '(bvugt x y)'
3971  """
3972  _check_bv_args(a, b)
3973  a, b = _coerce_exprs(a, b)
3974  return BoolRef(Z3_mk_bvugt(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3975 
3976 def UDiv(a, b):
3977  """Create the Z3 expression (unsigned) division `self / other`.
3978 
3979  Use the operator / for signed division.
3980 
3981  >>> x = BitVec('x', 32)
3982  >>> y = BitVec('y', 32)
3983  >>> UDiv(x, y)
3984  UDiv(x, y)
3985  >>> UDiv(x, y).sort()
3986  BitVec(32)
3987  >>> (x / y).sexpr()
3988  '(bvsdiv x y)'
3989  >>> UDiv(x, y).sexpr()
3990  '(bvudiv x y)'
3991  """
3992  _check_bv_args(a, b)
3993  a, b = _coerce_exprs(a, b)
3994  return BitVecRef(Z3_mk_bvudiv(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
3995 
3996 def URem(a, b):
3997  """Create the Z3 expression (unsigned) remainder `self % other`.
3998 
3999  Use the operator % for signed modulus, and SRem() for signed remainder.
4000 
4001  >>> x = BitVec('x', 32)
4002  >>> y = BitVec('y', 32)
4003  >>> URem(x, y)
4004  URem(x, y)
4005  >>> URem(x, y).sort()
4006  BitVec(32)
4007  >>> (x % y).sexpr()
4008  '(bvsmod x y)'
4009  >>> URem(x, y).sexpr()
4010  '(bvurem x y)'
4011  """
4012  _check_bv_args(a, b)
4013  a, b = _coerce_exprs(a, b)
4014  return BitVecRef(Z3_mk_bvurem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4015 
4016 def SRem(a, b):
4017  """Create the Z3 expression signed remainder.
4018 
4019  Use the operator % for signed modulus, and URem() for unsigned remainder.
4020 
4021  >>> x = BitVec('x', 32)
4022  >>> y = BitVec('y', 32)
4023  >>> SRem(x, y)
4024  SRem(x, y)
4025  >>> SRem(x, y).sort()
4026  BitVec(32)
4027  >>> (x % y).sexpr()
4028  '(bvsmod x y)'
4029  >>> SRem(x, y).sexpr()
4030  '(bvsrem x y)'
4031  """
4032  _check_bv_args(a, b)
4033  a, b = _coerce_exprs(a, b)
4034  return BitVecRef(Z3_mk_bvsrem(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4035 
4036 def LShR(a, b):
4037  """Create the Z3 expression logical right shift.
4038 
4039  Use the operator >> for the arithmetical right shift.
4040 
4041  >>> x, y = BitVecs('x y', 32)
4042  >>> LShR(x, y)
4043  LShR(x, y)
4044  >>> (x >> y).sexpr()
4045  '(bvashr x y)'
4046  >>> LShR(x, y).sexpr()
4047  '(bvlshr x y)'
4048  >>> BitVecVal(4, 3)
4049  4
4050  >>> BitVecVal(4, 3).as_signed_long()
4051  -4
4052  >>> simplify(BitVecVal(4, 3) >> 1).as_signed_long()
4053  -2
4054  >>> simplify(BitVecVal(4, 3) >> 1)
4055  6
4056  >>> simplify(LShR(BitVecVal(4, 3), 1))
4057  2
4058  >>> simplify(BitVecVal(2, 3) >> 1)
4059  1
4060  >>> simplify(LShR(BitVecVal(2, 3), 1))
4061  1
4062  """
4063  _check_bv_args(a, b)
4064  a, b = _coerce_exprs(a, b)
4065  return BitVecRef(Z3_mk_bvlshr(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4066 
4067 def RotateLeft(a, b):
4068  """Return an expression representing `a` rotated to the left `b` times.
4069 
4070  >>> a, b = BitVecs('a b', 16)
4071  >>> RotateLeft(a, b)
4072  RotateLeft(a, b)
4073  >>> simplify(RotateLeft(a, 0))
4074  a
4075  >>> simplify(RotateLeft(a, 16))
4076  a
4077  """
4078  _check_bv_args(a, b)
4079  a, b = _coerce_exprs(a, b)
4080  return BitVecRef(Z3_mk_ext_rotate_left(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4081 
4082 def RotateRight(a, b):
4083  """Return an expression representing `a` rotated to the right `b` times.
4084 
4085  >>> a, b = BitVecs('a b', 16)
4086  >>> RotateRight(a, b)
4087  RotateRight(a, b)
4088  >>> simplify(RotateRight(a, 0))
4089  a
4090  >>> simplify(RotateRight(a, 16))
4091  a
4092  """
4093  _check_bv_args(a, b)
4094  a, b = _coerce_exprs(a, b)
4095  return BitVecRef(Z3_mk_ext_rotate_right(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4096 
4097 def SignExt(n, a):
4098  """Return a bit-vector expression with `n` extra sign-bits.
4099 
4100  >>> x = BitVec('x', 16)
4101  >>> n = SignExt(8, x)
4102  >>> n.size()
4103  24
4104  >>> n
4105  SignExt(8, x)
4106  >>> n.sort()
4107  BitVec(24)
4108  >>> v0 = BitVecVal(2, 2)
4109  >>> v0
4110  2
4111  >>> v0.size()
4112  2
4113  >>> v = simplify(SignExt(6, v0))
4114  >>> v
4115  254
4116  >>> v.size()
4117  8
4118  >>> print("%.x" % v.as_long())
4119  fe
4120  """
4121  if z3_debug():
4122  _z3_assert(_is_int(n), "First argument must be an integer")
4123  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4124  return BitVecRef(Z3_mk_sign_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4125 
4126 def ZeroExt(n, a):
4127  """Return a bit-vector expression with `n` extra zero-bits.
4128 
4129  >>> x = BitVec('x', 16)
4130  >>> n = ZeroExt(8, x)
4131  >>> n.size()
4132  24
4133  >>> n
4134  ZeroExt(8, x)
4135  >>> n.sort()
4136  BitVec(24)
4137  >>> v0 = BitVecVal(2, 2)
4138  >>> v0
4139  2
4140  >>> v0.size()
4141  2
4142  >>> v = simplify(ZeroExt(6, v0))
4143  >>> v
4144  2
4145  >>> v.size()
4146  8
4147  """
4148  if z3_debug():
4149  _z3_assert(_is_int(n), "First argument must be an integer")
4150  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4151  return BitVecRef(Z3_mk_zero_ext(a.ctx_ref(), n, a.as_ast()), a.ctx)
4152 
4153 def RepeatBitVec(n, a):
4154  """Return an expression representing `n` copies of `a`.
4155 
4156  >>> x = BitVec('x', 8)
4157  >>> n = RepeatBitVec(4, x)
4158  >>> n
4159  RepeatBitVec(4, x)
4160  >>> n.size()
4161  32
4162  >>> v0 = BitVecVal(10, 4)
4163  >>> print("%.x" % v0.as_long())
4164  a
4165  >>> v = simplify(RepeatBitVec(4, v0))
4166  >>> v.size()
4167  16
4168  >>> print("%.x" % v.as_long())
4169  aaaa
4170  """
4171  if z3_debug():
4172  _z3_assert(_is_int(n), "First argument must be an integer")
4173  _z3_assert(is_bv(a), "Second argument must be a Z3 bit-vector expression")
4174  return BitVecRef(Z3_mk_repeat(a.ctx_ref(), n, a.as_ast()), a.ctx)
4175 
4176 def BVRedAnd(a):
4177  """Return the reduction-and expression of `a`."""
4178  if z3_debug():
4179  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4180  return BitVecRef(Z3_mk_bvredand(a.ctx_ref(), a.as_ast()), a.ctx)
4181 
4182 def BVRedOr(a):
4183  """Return the reduction-or expression of `a`."""
4184  if z3_debug():
4185  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4186  return BitVecRef(Z3_mk_bvredor(a.ctx_ref(), a.as_ast()), a.ctx)
4187 
4188 def BVAddNoOverflow(a, b, signed):
4189  """A predicate the determines that bit-vector addition does not overflow"""
4190  _check_bv_args(a, b)
4191  a, b = _coerce_exprs(a, b)
4192  return BoolRef(Z3_mk_bvadd_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4193 
4195  """A predicate the determines that signed bit-vector addition does not underflow"""
4196  _check_bv_args(a, b)
4197  a, b = _coerce_exprs(a, b)
4198  return BoolRef(Z3_mk_bvadd_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4199 
4201  """A predicate the determines that bit-vector subtraction does not overflow"""
4202  _check_bv_args(a, b)
4203  a, b = _coerce_exprs(a, b)
4204  return BoolRef(Z3_mk_bvsub_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4205 
4206 
4207 def BVSubNoUnderflow(a, b, signed):
4208  """A predicate the determines that bit-vector subtraction does not underflow"""
4209  _check_bv_args(a, b)
4210  a, b = _coerce_exprs(a, b)
4211  return BoolRef(Z3_mk_bvsub_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4212 
4214  """A predicate the determines that bit-vector signed division does not overflow"""
4215  _check_bv_args(a, b)
4216  a, b = _coerce_exprs(a, b)
4217  return BoolRef(Z3_mk_bvsdiv_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4218 
4220  """A predicate the determines that bit-vector unary negation does not overflow"""
4221  if z3_debug():
4222  _z3_assert(is_bv(a), "First argument must be a Z3 bit-vector expression")
4223  return BoolRef(Z3_mk_bvneg_no_overflow(a.ctx_ref(), a.as_ast()), a.ctx)
4224 
4225 def BVMulNoOverflow(a, b, signed):
4226  """A predicate the determines that bit-vector multiplication does not overflow"""
4227  _check_bv_args(a, b)
4228  a, b = _coerce_exprs(a, b)
4229  return BoolRef(Z3_mk_bvmul_no_overflow(a.ctx_ref(), a.as_ast(), b.as_ast(), signed), a.ctx)
4230 
4231 
4233  """A predicate the determines that bit-vector signed multiplication does not underflow"""
4234  _check_bv_args(a, b)
4235  a, b = _coerce_exprs(a, b)
4236  return BoolRef(Z3_mk_bvmul_no_underflow(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
4237 
4238 
4239 
4240 
4245 
4247  """Array sorts."""
4248 
4249  def domain(self):
4250  """Return the domain of the array sort `self`.
4251 
4252  >>> A = ArraySort(IntSort(), BoolSort())
4253  >>> A.domain()
4254  Int
4255  """
4256  return _to_sort_ref(Z3_get_array_sort_domain(self.ctx_ref(), self.ast), self.ctx)
4257 
4258  def range(self):
4259  """Return the range of the array sort `self`.
4260 
4261  >>> A = ArraySort(IntSort(), BoolSort())
4262  >>> A.range()
4263  Bool
4264  """
4265  return _to_sort_ref(Z3_get_array_sort_range(self.ctx_ref(), self.ast), self.ctx)
4266 
4268  """Array expressions. """
4269 
4270  def sort(self):
4271  """Return the array sort of the array expression `self`.
4272 
4273  >>> a = Array('a', IntSort(), BoolSort())
4274  >>> a.sort()
4275  Array(Int, Bool)
4276  """
4277  return ArraySortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
4278 
4279  def domain(self):
4280  """Shorthand for `self.sort().domain()`.
4281 
4282  >>> a = Array('a', IntSort(), BoolSort())
4283  >>> a.domain()
4284  Int
4285  """
4286  return self.sort().domain()
4287 
4288  def range(self):
4289  """Shorthand for `self.sort().range()`.
4290 
4291  >>> a = Array('a', IntSort(), BoolSort())
4292  >>> a.range()
4293  Bool
4294  """
4295  return self.sort().range()
4296 
4297  def __getitem__(self, arg):
4298  """Return the Z3 expression `self[arg]`.
4299 
4300  >>> a = Array('a', IntSort(), BoolSort())
4301  >>> i = Int('i')
4302  >>> a[i]
4303  a[i]
4304  >>> a[i].sexpr()
4305  '(select a i)'
4306  """
4307  arg = self.domain().cast(arg)
4308  return _to_expr_ref(Z3_mk_select(self.ctx_ref(), self.as_ast(), arg.as_ast()), self.ctx)
4309 
4310  def default(self):
4311  return _to_expr_ref(Z3_mk_array_default(self.ctx_ref(), self.as_ast()), self.ctx)
4312 
4314  return Z3_get_sort_kind(a.ctx.ref(), Z3_get_sort(a.ctx.ref(), a.ast)) == Z3_ARRAY_SORT
4315 
4316 
4317 def is_array(a):
4318  """Return `True` if `a` is a Z3 array expression.
4319 
4320  >>> a = Array('a', IntSort(), IntSort())
4321  >>> is_array(a)
4322  True
4323  >>> is_array(Store(a, 0, 1))
4324  True
4325  >>> is_array(a[0])
4326  False
4327  """
4328  return isinstance(a, ArrayRef)
4329 
4331  """Return `True` if `a` is a Z3 constant array.
4332 
4333  >>> a = K(IntSort(), 10)
4334  >>> is_const_array(a)
4335  True
4336  >>> a = Array('a', IntSort(), IntSort())
4337  >>> is_const_array(a)
4338  False
4339  """
4340  return is_app_of(a, Z3_OP_CONST_ARRAY)
4341 
4342 def is_K(a):
4343  """Return `True` if `a` is a Z3 constant array.
4344 
4345  >>> a = K(IntSort(), 10)
4346  >>> is_K(a)
4347  True
4348  >>> a = Array('a', IntSort(), IntSort())
4349  >>> is_K(a)
4350  False
4351  """
4352  return is_app_of(a, Z3_OP_CONST_ARRAY)
4353 
4354 def is_map(a):
4355  """Return `True` if `a` is a Z3 map array expression.
4356 
4357  >>> f = Function('f', IntSort(), IntSort())
4358  >>> b = Array('b', IntSort(), IntSort())
4359  >>> a = Map(f, b)
4360  >>> a
4361  Map(f, b)
4362  >>> is_map(a)
4363  True
4364  >>> is_map(b)
4365  False
4366  """
4367  return is_app_of(a, Z3_OP_ARRAY_MAP)
4368 
4369 def is_default(a):
4370  """Return `True` if `a` is a Z3 default array expression.
4371  >>> d = Default(K(IntSort(), 10))
4372  >>> is_default(d)
4373  True
4374  """
4375  return is_app_of(a, Z3_OP_ARRAY_DEFAULT)
4376 
4378  """Return the function declaration associated with a Z3 map array expression.
4379 
4380  >>> f = Function('f', IntSort(), IntSort())
4381  >>> b = Array('b', IntSort(), IntSort())
4382  >>> a = Map(f, b)
4383  >>> eq(f, get_map_func(a))
4384  True
4385  >>> get_map_func(a)
4386  f
4387  >>> get_map_func(a)(0)
4388  f(0)
4389  """
4390  if z3_debug():
4391  _z3_assert(is_map(a), "Z3 array map expression expected.")
4392  return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx)
4393 
4394 def ArraySort(*sig):
4395  """Return the Z3 array sort with the given domain and range sorts.
4396 
4397  >>> A = ArraySort(IntSort(), BoolSort())
4398  >>> A
4399  Array(Int, Bool)
4400  >>> A.domain()
4401  Int
4402  >>> A.range()
4403  Bool
4404  >>> AA = ArraySort(IntSort(), A)
4405  >>> AA
4406  Array(Int, Array(Int, Bool))
4407  """
4408  sig = _get_args(sig)
4409  if z3_debug():
4410  _z3_assert(len(sig) > 1, "At least two arguments expected")
4411  arity = len(sig) - 1
4412  r = sig[arity]
4413  d = sig[0]
4414  if z3_debug():
4415  for s in sig:
4416  _z3_assert(is_sort(s), "Z3 sort expected")
4417  _z3_assert(s.ctx == r.ctx, "Context mismatch")
4418  ctx = d.ctx
4419  if len(sig) == 2:
4420  return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx)
4421  dom = (Sort * arity)()
4422  for i in range(arity):
4423  dom[i] = sig[i].ast
4424  return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx)
4425 
4426 def Array(name, dom, rng):
4427  """Return an array constant named `name` with the given domain and range sorts.
4428 
4429  >>> a = Array('a', IntSort(), IntSort())
4430  >>> a.sort()
4431  Array(Int, Int)
4432  >>> a[0]
4433  a[0]
4434  """
4435  s = ArraySort(dom, rng)
4436  ctx = s.ctx
4437  return ArrayRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), s.ast), ctx)
4438 
4439 def Update(a, i, v):
4440  """Return a Z3 store array expression.
4441 
4442  >>> a = Array('a', IntSort(), IntSort())
4443  >>> i, v = Ints('i v')
4444  >>> s = Update(a, i, v)
4445  >>> s.sort()
4446  Array(Int, Int)
4447  >>> prove(s[i] == v)
4448  proved
4449  >>> j = Int('j')
4450  >>> prove(Implies(i != j, s[j] == a[j]))
4451  proved
4452  """
4453  if z3_debug():
4454  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4455  i = a.sort().domain().cast(i)
4456  v = a.sort().range().cast(v)
4457  ctx = a.ctx
4458  return _to_expr_ref(Z3_mk_store(ctx.ref(), a.as_ast(), i.as_ast(), v.as_ast()), ctx)
4459 
4460 def Default(a):
4461  """ Return a default value for array expression.
4462  >>> b = K(IntSort(), 1)
4463  >>> prove(Default(b) == 1)
4464  proved
4465  """
4466  if z3_debug():
4467  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4468  return a.default()
4469 
4470 
4471 def Store(a, i, v):
4472  """Return a Z3 store array expression.
4473 
4474  >>> a = Array('a', IntSort(), IntSort())
4475  >>> i, v = Ints('i v')
4476  >>> s = Store(a, i, v)
4477  >>> s.sort()
4478  Array(Int, Int)
4479  >>> prove(s[i] == v)
4480  proved
4481  >>> j = Int('j')
4482  >>> prove(Implies(i != j, s[j] == a[j]))
4483  proved
4484  """
4485  return Update(a, i, v)
4486 
4487 def Select(a, i):
4488  """Return a Z3 select array expression.
4489 
4490  >>> a = Array('a', IntSort(), IntSort())
4491  >>> i = Int('i')
4492  >>> Select(a, i)
4493  a[i]
4494  >>> eq(Select(a, i), a[i])
4495  True
4496  """
4497  if z3_debug():
4498  _z3_assert(is_array_sort(a), "First argument must be a Z3 array expression")
4499  return a[i]
4500 
4501 
4502 def Map(f, *args):
4503  """Return a Z3 map array expression.
4504 
4505  >>> f = Function('f', IntSort(), IntSort(), IntSort())
4506  >>> a1 = Array('a1', IntSort(), IntSort())
4507  >>> a2 = Array('a2', IntSort(), IntSort())
4508  >>> b = Map(f, a1, a2)
4509  >>> b
4510  Map(f, a1, a2)
4511  >>> prove(b[0] == f(a1[0], a2[0]))
4512  proved
4513  """
4514  args = _get_args(args)
4515  if z3_debug():
4516  _z3_assert(len(args) > 0, "At least one Z3 array expression expected")
4517  _z3_assert(is_func_decl(f), "First argument must be a Z3 function declaration")
4518  _z3_assert(all([is_array(a) for a in args]), "Z3 array expected expected")
4519  _z3_assert(len(args) == f.arity(), "Number of arguments mismatch")
4520  _args, sz = _to_ast_array(args)
4521  ctx = f.ctx
4522  return ArrayRef(Z3_mk_map(ctx.ref(), f.ast, sz, _args), ctx)
4523 
4524 def K(dom, v):
4525  """Return a Z3 constant array expression.
4526 
4527  >>> a = K(IntSort(), 10)
4528  >>> a
4529  K(Int, 10)
4530  >>> a.sort()
4531  Array(Int, Int)
4532  >>> i = Int('i')
4533  >>> a[i]
4534  K(Int, 10)[i]
4535  >>> simplify(a[i])
4536  10
4537  """
4538  if z3_debug():
4539  _z3_assert(is_sort(dom), "Z3 sort expected")
4540  ctx = dom.ctx
4541  if not is_expr(v):
4542  v = _py2expr(v, ctx)
4543  return ArrayRef(Z3_mk_const_array(ctx.ref(), dom.ast, v.as_ast()), ctx)
4544 
4545 def Ext(a, b):
4546  """Return extensionality index for one-dimensional arrays.
4547  >> a, b = Consts('a b', SetSort(IntSort()))
4548  >> Ext(a, b)
4549  Ext(a, b)
4550  """
4551  ctx = a.ctx
4552  if z3_debug():
4553  _z3_assert(is_array_sort(a) and is_array(b), "arguments must be arrays")
4554  return _to_expr_ref(Z3_mk_array_ext(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4555 
4556 def SetHasSize(a, k):
4557  ctx = a.ctx
4558  k = _py2expr(k, ctx)
4559  return _to_expr_ref(Z3_mk_set_has_size(ctx.ref(), a.as_ast(), k.as_ast()), ctx)
4560 
4561 def is_select(a):
4562  """Return `True` if `a` is a Z3 array select application.
4563 
4564  >>> a = Array('a', IntSort(), IntSort())
4565  >>> is_select(a)
4566  False
4567  >>> i = Int('i')
4568  >>> is_select(a[i])
4569  True
4570  """
4571  return is_app_of(a, Z3_OP_SELECT)
4572 
4573 def is_store(a):
4574  """Return `True` if `a` is a Z3 array store application.
4575 
4576  >>> a = Array('a', IntSort(), IntSort())
4577  >>> is_store(a)
4578  False
4579  >>> is_store(Store(a, 0, 1))
4580  True
4581  """
4582  return is_app_of(a, Z3_OP_STORE)
4583 
4584 
4589 
4590 
4591 def SetSort(s):
4592  """ Create a set sort over element sort s"""
4593  return ArraySort(s, BoolSort())
4594 
4595 def EmptySet(s):
4596  """Create the empty set
4597  >>> EmptySet(IntSort())
4598  K(Int, False)
4599  """
4600  ctx = s.ctx
4601  return ArrayRef(Z3_mk_empty_set(ctx.ref(), s.ast), ctx)
4602 
4603 def FullSet(s):
4604  """Create the full set
4605  >>> FullSet(IntSort())
4606  K(Int, True)
4607  """
4608  ctx = s.ctx
4609  return ArrayRef(Z3_mk_full_set(ctx.ref(), s.ast), ctx)
4610 
4611 def SetUnion(*args):
4612  """ Take the union of sets
4613  >>> a = Const('a', SetSort(IntSort()))
4614  >>> b = Const('b', SetSort(IntSort()))
4615  >>> SetUnion(a, b)
4616  union(a, b)
4617  """
4618  args = _get_args(args)
4619  ctx = _ctx_from_ast_arg_list(args)
4620  _args, sz = _to_ast_array(args)
4621  return ArrayRef(Z3_mk_set_union(ctx.ref(), sz, _args), ctx)
4622 
4623 def SetIntersect(*args):
4624  """ Take the union of sets
4625  >>> a = Const('a', SetSort(IntSort()))
4626  >>> b = Const('b', SetSort(IntSort()))
4627  >>> SetIntersect(a, b)
4628  intersection(a, b)
4629  """
4630  args = _get_args(args)
4631  ctx = _ctx_from_ast_arg_list(args)
4632  _args, sz = _to_ast_array(args)
4633  return ArrayRef(Z3_mk_set_intersect(ctx.ref(), sz, _args), ctx)
4634 
4635 def SetAdd(s, e):
4636  """ Add element e to set s
4637  >>> a = Const('a', SetSort(IntSort()))
4638  >>> SetAdd(a, 1)
4639  Store(a, 1, True)
4640  """
4641  ctx = _ctx_from_ast_arg_list([s,e])
4642  e = _py2expr(e, ctx)
4643  return ArrayRef(Z3_mk_set_add(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4644 
4645 def SetDel(s, e):
4646  """ Remove element e to set s
4647  >>> a = Const('a', SetSort(IntSort()))
4648  >>> SetDel(a, 1)
4649  Store(a, 1, False)
4650  """
4651  ctx = _ctx_from_ast_arg_list([s,e])
4652  e = _py2expr(e, ctx)
4653  return ArrayRef(Z3_mk_set_del(ctx.ref(), s.as_ast(), e.as_ast()), ctx)
4654 
4656  """ The complement of set s
4657  >>> a = Const('a', SetSort(IntSort()))
4658  >>> SetComplement(a)
4659  complement(a)
4660  """
4661  ctx = s.ctx
4662  return ArrayRef(Z3_mk_set_complement(ctx.ref(), s.as_ast()), ctx)
4663 
4664 def SetDifference(a, b):
4665  """ The set difference of a and b
4666  >>> a = Const('a', SetSort(IntSort()))
4667  >>> b = Const('b', SetSort(IntSort()))
4668  >>> SetDifference(a, b)
4669  setminus(a, b)
4670  """
4671  ctx = _ctx_from_ast_arg_list([a, b])
4672  return ArrayRef(Z3_mk_set_difference(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4673 
4674 def IsMember(e, s):
4675  """ Check if e is a member of set s
4676  >>> a = Const('a', SetSort(IntSort()))
4677  >>> IsMember(1, a)
4678  a[1]
4679  """
4680  ctx = _ctx_from_ast_arg_list([s,e])
4681  e = _py2expr(e, ctx)
4682  return BoolRef(Z3_mk_set_member(ctx.ref(), e.as_ast(), s.as_ast()), ctx)
4683 
4684 def IsSubset(a, b):
4685  """ Check if a is a subset of b
4686  >>> a = Const('a', SetSort(IntSort()))
4687  >>> b = Const('b', SetSort(IntSort()))
4688  >>> IsSubset(a, b)
4689  subset(a, b)
4690  """
4691  ctx = _ctx_from_ast_arg_list([a, b])
4692  return BoolRef(Z3_mk_set_subset(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
4693 
4694 
4695 
4700 
4701 def _valid_accessor(acc):
4702  """Return `True` if acc is pair of the form (String, Datatype or Sort). """
4703  return isinstance(acc, tuple) and len(acc) == 2 and isinstance(acc[0], str) and (isinstance(acc[1], Datatype) or is_sort(acc[1]))
4704 
4705 class Datatype:
4706  """Helper class for declaring Z3 datatypes.
4707 
4708  >>> List = Datatype('List')
4709  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4710  >>> List.declare('nil')
4711  >>> List = List.create()
4712  >>> # List is now a Z3 declaration
4713  >>> List.nil
4714  nil
4715  >>> List.cons(10, List.nil)
4716  cons(10, nil)
4717  >>> List.cons(10, List.nil).sort()
4718  List
4719  >>> cons = List.cons
4720  >>> nil = List.nil
4721  >>> car = List.car
4722  >>> cdr = List.cdr
4723  >>> n = cons(1, cons(0, nil))
4724  >>> n
4725  cons(1, cons(0, nil))
4726  >>> simplify(cdr(n))
4727  cons(0, nil)
4728  >>> simplify(car(n))
4729  1
4730  """
4731  def __init__(self, name, ctx=None):
4732  self.ctx = _get_ctx(ctx)
4733  self.name = name
4734  self.constructors = []
4735 
4736  def __deepcopy__(self, memo={}):
4737  r = Datatype(self.name, self.ctx)
4738  r.constructors = copy.deepcopy(self.constructors)
4739  return r
4740 
4741  def declare_core(self, name, rec_name, *args):
4742  if z3_debug():
4743  _z3_assert(isinstance(name, str), "String expected")
4744  _z3_assert(isinstance(rec_name, str), "String expected")
4745  _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)")
4746  self.constructors.append((name, rec_name, args))
4747 
4748  def declare(self, name, *args):
4749  """Declare constructor named `name` with the given accessors `args`.
4750  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.
4751 
4752  In the following example `List.declare('cons', ('car', IntSort()), ('cdr', List))`
4753  declares the constructor named `cons` that builds a new List using an integer and a List.
4754  It also declares the accessors `car` and `cdr`. The accessor `car` extracts the integer of a `cons` cell,
4755  and `cdr` the list of a `cons` cell. After all constructors were declared, we use the method create() to create
4756  the actual datatype in Z3.
4757 
4758  >>> List = Datatype('List')
4759  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4760  >>> List.declare('nil')
4761  >>> List = List.create()
4762  """
4763  if z3_debug():
4764  _z3_assert(isinstance(name, str), "String expected")
4765  _z3_assert(name != "", "Constructor name cannot be empty")
4766  return self.declare_core(name, "is-" + name, *args)
4767 
4768  def __repr__(self):
4769  return "Datatype(%s, %s)" % (self.name, self.constructors)
4770 
4771  def create(self):
4772  """Create a Z3 datatype based on the constructors declared using the method `declare()`.
4773 
4774  The function `CreateDatatypes()` must be used to define mutually recursive datatypes.
4775 
4776  >>> List = Datatype('List')
4777  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4778  >>> List.declare('nil')
4779  >>> List = List.create()
4780  >>> List.nil
4781  nil
4782  >>> List.cons(10, List.nil)
4783  cons(10, nil)
4784  """
4785  return CreateDatatypes([self])[0]
4786 
4788  """Auxiliary object used to create Z3 datatypes."""
4789  def __init__(self, c, ctx):
4790  self.c = c
4791  self.ctx = ctx
4792  def __del__(self):
4793  if self.ctx.ref() is not None:
4794  Z3_del_constructor(self.ctx.ref(), self.c)
4795 
4797  """Auxiliary object used to create Z3 datatypes."""
4798  def __init__(self, c, ctx):
4799  self.c = c
4800  self.ctx = ctx
4801  def __del__(self):
4802  if self.ctx.ref() is not None:
4803  Z3_del_constructor_list(self.ctx.ref(), self.c)
4804 
4806  """Create mutually recursive Z3 datatypes using 1 or more Datatype helper objects.
4807 
4808  In the following example we define a Tree-List using two mutually recursive datatypes.
4809 
4810  >>> TreeList = Datatype('TreeList')
4811  >>> Tree = Datatype('Tree')
4812  >>> # Tree has two constructors: leaf and node
4813  >>> Tree.declare('leaf', ('val', IntSort()))
4814  >>> # a node contains a list of trees
4815  >>> Tree.declare('node', ('children', TreeList))
4816  >>> TreeList.declare('nil')
4817  >>> TreeList.declare('cons', ('car', Tree), ('cdr', TreeList))
4818  >>> Tree, TreeList = CreateDatatypes(Tree, TreeList)
4819  >>> Tree.val(Tree.leaf(10))
4820  val(leaf(10))
4821  >>> simplify(Tree.val(Tree.leaf(10)))
4822  10
4823  >>> n1 = Tree.node(TreeList.cons(Tree.leaf(10), TreeList.cons(Tree.leaf(20), TreeList.nil)))
4824  >>> n1
4825  node(cons(leaf(10), cons(leaf(20), nil)))
4826  >>> n2 = Tree.node(TreeList.cons(n1, TreeList.nil))
4827  >>> simplify(n2 == n1)
4828  False
4829  >>> simplify(TreeList.car(Tree.children(n2)) == n1)
4830  True
4831  """
4832  ds = _get_args(ds)
4833  if z3_debug():
4834  _z3_assert(len(ds) > 0, "At least one Datatype must be specified")
4835  _z3_assert(all([isinstance(d, Datatype) for d in ds]), "Arguments must be Datatypes")
4836  _z3_assert(all([d.ctx == ds[0].ctx for d in ds]), "Context mismatch")
4837  _z3_assert(all([d.constructors != [] for d in ds]), "Non-empty Datatypes expected")
4838  ctx = ds[0].ctx
4839  num = len(ds)
4840  names = (Symbol * num)()
4841  out = (Sort * num)()
4842  clists = (ConstructorList * num)()
4843  to_delete = []
4844  for i in range(num):
4845  d = ds[i]
4846  names[i] = to_symbol(d.name, ctx)
4847  num_cs = len(d.constructors)
4848  cs = (Constructor * num_cs)()
4849  for j in range(num_cs):
4850  c = d.constructors[j]
4851  cname = to_symbol(c[0], ctx)
4852  rname = to_symbol(c[1], ctx)
4853  fs = c[2]
4854  num_fs = len(fs)
4855  fnames = (Symbol * num_fs)()
4856  sorts = (Sort * num_fs)()
4857  refs = (ctypes.c_uint * num_fs)()
4858  for k in range(num_fs):
4859  fname = fs[k][0]
4860  ftype = fs[k][1]
4861  fnames[k] = to_symbol(fname, ctx)
4862  if isinstance(ftype, Datatype):
4863  if z3_debug():
4864  _z3_assert(ds.count(ftype) == 1, "One and only one occurrence of each datatype is expected")
4865  sorts[k] = None
4866  refs[k] = ds.index(ftype)
4867  else:
4868  if z3_debug():
4869  _z3_assert(is_sort(ftype), "Z3 sort expected")
4870  sorts[k] = ftype.ast
4871  refs[k] = 0
4872  cs[j] = Z3_mk_constructor(ctx.ref(), cname, rname, num_fs, fnames, sorts, refs)
4873  to_delete.append(ScopedConstructor(cs[j], ctx))
4874  clists[i] = Z3_mk_constructor_list(ctx.ref(), num_cs, cs)
4875  to_delete.append(ScopedConstructorList(clists[i], ctx))
4876  Z3_mk_datatypes(ctx.ref(), num, names, out, clists)
4877  result = []
4878 
4879  for i in range(num):
4880  dref = DatatypeSortRef(out[i], ctx)
4881  num_cs = dref.num_constructors()
4882  for j in range(num_cs):
4883  cref = dref.constructor(j)
4884  cref_name = cref.name()
4885  cref_arity = cref.arity()
4886  if cref.arity() == 0:
4887  cref = cref()
4888  setattr(dref, cref_name, cref)
4889  rref = dref.recognizer(j)
4890  setattr(dref, "is_" + cref_name, rref)
4891  for k in range(cref_arity):
4892  aref = dref.accessor(j, k)
4893  setattr(dref, aref.name(), aref)
4894  result.append(dref)
4895  return tuple(result)
4896 
4898  """Datatype sorts."""
4899  def num_constructors(self):
4900  """Return the number of constructors in the given Z3 datatype.
4901 
4902  >>> List = Datatype('List')
4903  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4904  >>> List.declare('nil')
4905  >>> List = List.create()
4906  >>> # List is now a Z3 declaration
4907  >>> List.num_constructors()
4908  2
4909  """
4910  return int(Z3_get_datatype_sort_num_constructors(self.ctx_ref(), self.ast))
4911 
4912  def constructor(self, idx):
4913  """Return a constructor of the datatype `self`.
4914 
4915  >>> List = Datatype('List')
4916  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4917  >>> List.declare('nil')
4918  >>> List = List.create()
4919  >>> # List is now a Z3 declaration
4920  >>> List.num_constructors()
4921  2
4922  >>> List.constructor(0)
4923  cons
4924  >>> List.constructor(1)
4925  nil
4926  """
4927  if z3_debug():
4928  _z3_assert(idx < self.num_constructors(), "Invalid constructor index")
4929  return FuncDeclRef(Z3_get_datatype_sort_constructor(self.ctx_ref(), self.ast, idx), self.ctx)
4930 
4931  def recognizer(self, idx):
4932  """In Z3, each constructor has an associated recognizer predicate.
4933 
4934  If the constructor is named `name`, then the recognizer `is_name`.
4935 
4936  >>> List = Datatype('List')
4937  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4938  >>> List.declare('nil')
4939  >>> List = List.create()
4940  >>> # List is now a Z3 declaration
4941  >>> List.num_constructors()
4942  2
4943  >>> List.recognizer(0)
4944  is(cons)
4945  >>> List.recognizer(1)
4946  is(nil)
4947  >>> simplify(List.is_nil(List.cons(10, List.nil)))
4948  False
4949  >>> simplify(List.is_cons(List.cons(10, List.nil)))
4950  True
4951  >>> l = Const('l', List)
4952  >>> simplify(List.is_cons(l))
4953  is(cons, l)
4954  """
4955  if z3_debug():
4956  _z3_assert(idx < self.num_constructors(), "Invalid recognizer index")
4957  return FuncDeclRef(Z3_get_datatype_sort_recognizer(self.ctx_ref(), self.ast, idx), self.ctx)
4958 
4959  def accessor(self, i, j):
4960  """In Z3, each constructor has 0 or more accessor. The number of accessors is equal to the arity of the constructor.
4961 
4962  >>> List = Datatype('List')
4963  >>> List.declare('cons', ('car', IntSort()), ('cdr', List))
4964  >>> List.declare('nil')
4965  >>> List = List.create()
4966  >>> List.num_constructors()
4967  2
4968  >>> List.constructor(0)
4969  cons
4970  >>> num_accs = List.constructor(0).arity()
4971  >>> num_accs
4972  2
4973  >>> List.accessor(0, 0)
4974  car
4975  >>> List.accessor(0, 1)
4976  cdr
4977  >>> List.constructor(1)
4978  nil
4979  >>> num_accs = List.constructor(1).arity()
4980  >>> num_accs
4981  0
4982  """
4983  if z3_debug():
4984  _z3_assert(i < self.num_constructors(), "Invalid constructor index")
4985  _z3_assert(j < self.constructor(i).arity(), "Invalid accessor index")
4986  return FuncDeclRef(Z3_get_datatype_sort_constructor_accessor(self.ctx_ref(), self.ast, i, j), self.ctx)
4987 
4989  """Datatype expressions."""
4990  def sort(self):
4991  """Return the datatype sort of the datatype expression `self`."""
4992  return DatatypeSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
4993 
4994 def TupleSort(name, sorts, ctx = None):
4995  """Create a named tuple sort base on a set of underlying sorts
4996  Example:
4997  >>> pair, mk_pair, (first, second) = TupleSort("pair", [IntSort(), StringSort()])
4998  """
4999  tuple = Datatype(name, ctx)
5000  projects = [ ('project%d' % i, sorts[i]) for i in range(len(sorts)) ]
5001  tuple.declare(name, *projects)
5002  tuple = tuple.create()
5003  return tuple, tuple.constructor(0), [tuple.accessor(0, i) for i in range(len(sorts))]
5004 
5005 def DisjointSum(name, sorts, ctx=None):
5006  """Create a named tagged union sort base on a set of underlying sorts
5007  Example:
5008  >>> sum, ((inject0, extract0), (inject1, extract1)) = DisjointSum("+", [IntSort(), StringSort()])
5009  """
5010  sum = Datatype(name, ctx)
5011  for i in range(len(sorts)):
5012  sum.declare("inject%d" % i, ("project%d" % i, sorts[i]))
5013  sum = sum.create()
5014  return sum, [(sum.constructor(i), sum.accessor(i, 0)) for i in range(len(sorts))]
5015 
5016 
5017 def EnumSort(name, values, ctx=None):
5018  """Return a new enumeration sort named `name` containing the given values.
5019 
5020  The result is a pair (sort, list of constants).
5021  Example:
5022  >>> Color, (red, green, blue) = EnumSort('Color', ['red', 'green', 'blue'])
5023  """
5024  if z3_debug():
5025  _z3_assert(isinstance(name, str), "Name must be a string")
5026  _z3_assert(all([isinstance(v, str) for v in values]), "Eumeration sort values must be strings")
5027  _z3_assert(len(values) > 0, "At least one value expected")
5028  ctx = _get_ctx(ctx)
5029  num = len(values)
5030  _val_names = (Symbol * num)()
5031  for i in range(num):
5032  _val_names[i] = to_symbol(values[i])
5033  _values = (FuncDecl * num)()
5034  _testers = (FuncDecl * num)()
5035  name = to_symbol(name)
5036  S = DatatypeSortRef(Z3_mk_enumeration_sort(ctx.ref(), name, num, _val_names, _values, _testers), ctx)
5037  V = []
5038  for i in range(num):
5039  V.append(FuncDeclRef(_values[i], ctx))
5040  V = [a() for a in V]
5041  return S, V
5042 
5043 
5048 
5050  """Set of parameters used to configure Solvers, Tactics and Simplifiers in Z3.
5051 
5052  Consider using the function `args2params` to create instances of this object.
5053  """
5054  def __init__(self, ctx=None, params=None):
5055  self.ctx = _get_ctx(ctx)
5056  if params is None:
5057  self.params = Z3_mk_params(self.ctx.ref())
5058  else:
5059  self.params = params
5060  Z3_params_inc_ref(self.ctx.ref(), self.params)
5061 
5062  def __deepcopy__(self, memo={}):
5063  return ParamsRef(self.ctx, self.params)
5064 
5065  def __del__(self):
5066  if self.ctx.ref() is not None:
5067  Z3_params_dec_ref(self.ctx.ref(), self.params)
5068 
5069  def set(self, name, val):
5070  """Set parameter name with value val."""
5071  if z3_debug():
5072  _z3_assert(isinstance(name, str), "parameter name must be a string")
5073  name_sym = to_symbol(name, self.ctx)
5074  if isinstance(val, bool):
5075  Z3_params_set_bool(self.ctx.ref(), self.params, name_sym, val)
5076  elif _is_int(val):
5077  Z3_params_set_uint(self.ctx.ref(), self.params, name_sym, val)
5078  elif isinstance(val, float):
5079  Z3_params_set_double(self.ctx.ref(), self.params, name_sym, val)
5080  elif isinstance(val, str):
5081  Z3_params_set_symbol(self.ctx.ref(), self.params, name_sym, to_symbol(val, self.ctx))
5082  else:
5083  if z3_debug():
5084  _z3_assert(False, "invalid parameter value")
5085 
5086  def __repr__(self):
5087  return Z3_params_to_string(self.ctx.ref(), self.params)
5088 
5089  def validate(self, ds):
5090  _z3_assert(isinstance(ds, ParamDescrsRef), "parameter description set expected")
5091  Z3_params_validate(self.ctx.ref(), self.params, ds.descr)
5092 
5093 def args2params(arguments, keywords, ctx=None):
5094  """Convert python arguments into a Z3_params object.
5095  A ':' is added to the keywords, and '_' is replaced with '-'
5096 
5097  >>> args2params(['model', True, 'relevancy', 2], {'elim_and' : True})
5098  (params model true relevancy 2 elim_and true)
5099  """
5100  if z3_debug():
5101  _z3_assert(len(arguments) % 2 == 0, "Argument list must have an even number of elements.")
5102  prev = None
5103  r = ParamsRef(ctx)
5104  for a in arguments:
5105  if prev is None:
5106  prev = a
5107  else:
5108  r.set(prev, a)
5109  prev = None
5110  for k in keywords:
5111  v = keywords[k]
5112  r.set(k, v)
5113  return r
5114 
5116  """Set of parameter descriptions for Solvers, Tactics and Simplifiers in Z3.
5117  """
5118  def __init__(self, descr, ctx=None):
5119  _z3_assert(isinstance(descr, ParamDescrs), "parameter description object expected")
5120  self.ctx = _get_ctx(ctx)
5121  self.descr = descr
5122  Z3_param_descrs_inc_ref(self.ctx.ref(), self.descr)
5123 
5124  def __deepcopy__(self, memo={}):
5125  return ParamsDescrsRef(self.descr, self.ctx)
5126 
5127  def __del__(self):
5128  if self.ctx.ref() is not None:
5129  Z3_param_descrs_dec_ref(self.ctx.ref(), self.descr)
5130 
5131  def size(self):
5132  """Return the size of in the parameter description `self`.
5133  """
5134  return int(Z3_param_descrs_size(self.ctx.ref(), self.descr))
5135 
5136  def __len__(self):
5137  """Return the size of in the parameter description `self`.
5138  """
5139  return self.size()
5140 
5141  def get_name(self, i):
5142  """Return the i-th parameter name in the parameter description `self`.
5143  """
5144  return _symbol2py(self.ctx, Z3_param_descrs_get_name(self.ctx.ref(), self.descr, i))
5145 
5146  def get_kind(self, n):
5147  """Return the kind of the parameter named `n`.
5148  """
5149  return Z3_param_descrs_get_kind(self.ctx.ref(), self.descr, to_symbol(n, self.ctx))
5150 
5151  def get_documentation(self, n):
5152  """Return the documentation string of the parameter named `n`.
5153  """
5154  return Z3_param_descrs_get_documentation(self.ctx.ref(), self.descr, to_symbol(n, self.ctx))
5155 
5156  def __getitem__(self, arg):
5157  if _is_int(arg):
5158  return self.get_name(arg)
5159  else:
5160  return self.get_kind(arg)
5161 
5162  def __repr__(self):
5163  return Z3_param_descrs_to_string(self.ctx.ref(), self.descr)
5164 
5165 
5170 
5172  """Goal is a collection of constraints we want to find a solution or show to be unsatisfiable (infeasible).
5173 
5174  Goals are processed using Tactics. A Tactic transforms a goal into a set of subgoals.
5175  A goal has a solution if one of its subgoals has a solution.
5176  A goal is unsatisfiable if all subgoals are unsatisfiable.
5177  """
5178 
5179  def __init__(self, models=True, unsat_cores=False, proofs=False, ctx=None, goal=None):
5180  if z3_debug():
5181  _z3_assert(goal is None or ctx is not None, "If goal is different from None, then ctx must be also different from None")
5182  self.ctx = _get_ctx(ctx)
5183  self.goal = goal
5184  if self.goal is None:
5185  self.goal = Z3_mk_goal(self.ctx.ref(), models, unsat_cores, proofs)
5186  Z3_goal_inc_ref(self.ctx.ref(), self.goal)
5187 
5188  def __deepcopy__(self, memo={}):
5189  return Goal(False, False, False, self.ctx, self.goal)
5190 
5191  def __del__(self):
5192  if self.goal is not None and self.ctx.ref() is not None:
5193  Z3_goal_dec_ref(self.ctx.ref(), self.goal)
5194 
5195  def depth(self):
5196  """Return the depth of the goal `self`. The depth corresponds to the number of tactics applied to `self`.
5197 
5198  >>> x, y = Ints('x y')
5199  >>> g = Goal()
5200  >>> g.add(x == 0, y >= x + 1)
5201  >>> g.depth()
5202  0
5203  >>> r = Then('simplify', 'solve-eqs')(g)
5204  >>> # r has 1 subgoal
5205  >>> len(r)
5206  1
5207  >>> r[0].depth()
5208  2
5209  """
5210  return int(Z3_goal_depth(self.ctx.ref(), self.goal))
5211 
5212  def inconsistent(self):
5213  """Return `True` if `self` contains the `False` constraints.
5214 
5215  >>> x, y = Ints('x y')
5216  >>> g = Goal()
5217  >>> g.inconsistent()
5218  False
5219  >>> g.add(x == 0, x == 1)
5220  >>> g
5221  [x == 0, x == 1]
5222  >>> g.inconsistent()
5223  False
5224  >>> g2 = Tactic('propagate-values')(g)[0]
5225  >>> g2.inconsistent()
5226  True
5227  """
5228  return Z3_goal_inconsistent(self.ctx.ref(), self.goal)
5229 
5230  def prec(self):
5231  """Return the precision (under-approximation, over-approximation, or precise) of the goal `self`.
5232 
5233  >>> g = Goal()
5234  >>> g.prec() == Z3_GOAL_PRECISE
5235  True
5236  >>> x, y = Ints('x y')
5237  >>> g.add(x == y + 1)
5238  >>> g.prec() == Z3_GOAL_PRECISE
5239  True
5240  >>> t = With(Tactic('add-bounds'), add_bound_lower=0, add_bound_upper=10)
5241  >>> g2 = t(g)[0]
5242  >>> g2
5243  [x == y + 1, x <= 10, x >= 0, y <= 10, y >= 0]
5244  >>> g2.prec() == Z3_GOAL_PRECISE
5245  False
5246  >>> g2.prec() == Z3_GOAL_UNDER
5247  True
5248  """
5249  return Z3_goal_precision(self.ctx.ref(), self.goal)
5250 
5251  def precision(self):
5252  """Alias for `prec()`.
5253 
5254  >>> g = Goal()
5255  >>> g.precision() == Z3_GOAL_PRECISE
5256  True
5257  """
5258  return self.prec()
5259 
5260  def size(self):
5261  """Return the number of constraints in the goal `self`.
5262 
5263  >>> g = Goal()
5264  >>> g.size()
5265  0
5266  >>> x, y = Ints('x y')
5267  >>> g.add(x == 0, y > x)
5268  >>> g.size()
5269  2
5270  """
5271  return int(Z3_goal_size(self.ctx.ref(), self.goal))
5272 
5273  def __len__(self):
5274  """Return the number of constraints in the goal `self`.
5275 
5276  >>> g = Goal()
5277  >>> len(g)
5278  0
5279  >>> x, y = Ints('x y')
5280  >>> g.add(x == 0, y > x)
5281  >>> len(g)
5282  2
5283  """
5284  return self.size()
5285 
5286  def get(self, i):
5287  """Return a constraint in the goal `self`.
5288 
5289  >>> g = Goal()
5290  >>> x, y = Ints('x y')
5291  >>> g.add(x == 0, y > x)
5292  >>> g.get(0)
5293  x == 0
5294  >>> g.get(1)
5295  y > x
5296  """
5297  return _to_expr_ref(Z3_goal_formula(self.ctx.ref(), self.goal, i), self.ctx)
5298 
5299  def __getitem__(self, arg):
5300  """Return a constraint in the goal `self`.
5301 
5302  >>> g = Goal()
5303  >>> x, y = Ints('x y')
5304  >>> g.add(x == 0, y > x)
5305  >>> g[0]
5306  x == 0
5307  >>> g[1]
5308  y > x
5309  """
5310  if arg >= len(self):
5311  raise IndexError
5312  return self.get(arg)
5313 
5314  def assert_exprs(self, *args):
5315  """Assert constraints into the goal.
5316 
5317  >>> x = Int('x')
5318  >>> g = Goal()
5319  >>> g.assert_exprs(x > 0, x < 2)
5320  >>> g
5321  [x > 0, x < 2]
5322  """
5323  args = _get_args(args)
5324  s = BoolSort(self.ctx)
5325  for arg in args:
5326  arg = s.cast(arg)
5327  Z3_goal_assert(self.ctx.ref(), self.goal, arg.as_ast())
5328 
5329  def append(self, *args):
5330  """Add constraints.
5331 
5332  >>> x = Int('x')
5333  >>> g = Goal()
5334  >>> g.append(x > 0, x < 2)
5335  >>> g
5336  [x > 0, x < 2]
5337  """
5338  self.assert_exprs(*args)
5339 
5340  def insert(self, *args):
5341  """Add constraints.
5342 
5343  >>> x = Int('x')
5344  >>> g = Goal()
5345  >>> g.insert(x > 0, x < 2)
5346  >>> g
5347  [x > 0, x < 2]
5348  """
5349  self.assert_exprs(*args)
5350 
5351  def add(self, *args):
5352  """Add constraints.
5353 
5354  >>> x = Int('x')
5355  >>> g = Goal()
5356  >>> g.add(x > 0, x < 2)
5357  >>> g
5358  [x > 0, x < 2]
5359  """
5360  self.assert_exprs(*args)
5361 
5362  def convert_model(self, model):
5363  """Retrieve model from a satisfiable goal
5364  >>> a, b = Ints('a b')
5365  >>> g = Goal()
5366  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
5367  >>> t = Then(Tactic('split-clause'), Tactic('solve-eqs'))
5368  >>> r = t(g)
5369  >>> r[0]
5370  [Or(b == 0, b == 1), Not(0 <= b)]
5371  >>> r[1]
5372  [Or(b == 0, b == 1), Not(1 <= b)]
5373  >>> # Remark: the subgoal r[0] is unsatisfiable
5374  >>> # Creating a solver for solving the second subgoal
5375  >>> s = Solver()
5376  >>> s.add(r[1])
5377  >>> s.check()
5378  sat
5379  >>> s.model()
5380  [b = 0]
5381  >>> # Model s.model() does not assign a value to `a`
5382  >>> # It is a model for subgoal `r[1]`, but not for goal `g`
5383  >>> # The method convert_model creates a model for `g` from a model for `r[1]`.
5384  >>> r[1].convert_model(s.model())
5385  [b = 0, a = 1]
5386  """
5387  if z3_debug():
5388  _z3_assert(isinstance(model, ModelRef), "Z3 Model expected")
5389  return ModelRef(Z3_goal_convert_model(self.ctx.ref(), self.goal, model.model), self.ctx)
5390 
5391  def __repr__(self):
5392  return obj_to_string(self)
5393 
5394  def sexpr(self):
5395  """Return a textual representation of the s-expression representing the goal."""
5396  return Z3_goal_to_string(self.ctx.ref(), self.goal)
5397 
5398  def dimacs(self):
5399  """Return a textual representation of the goal in DIMACS format."""
5400  return Z3_goal_to_dimacs_string(self.ctx.ref(), self.goal)
5401 
5402  def translate(self, target):
5403  """Copy goal `self` to context `target`.
5404 
5405  >>> x = Int('x')
5406  >>> g = Goal()
5407  >>> g.add(x > 10)
5408  >>> g
5409  [x > 10]
5410  >>> c2 = Context()
5411  >>> g2 = g.translate(c2)
5412  >>> g2
5413  [x > 10]
5414  >>> g.ctx == main_ctx()
5415  True
5416  >>> g2.ctx == c2
5417  True
5418  >>> g2.ctx == main_ctx()
5419  False
5420  """
5421  if z3_debug():
5422  _z3_assert(isinstance(target, Context), "target must be a context")
5423  return Goal(goal=Z3_goal_translate(self.ctx.ref(), self.goal, target.ref()), ctx=target)
5424 
5425  def __copy__(self):
5426  return self.translate(self.ctx)
5427 
5428  def __deepcopy__(self, memo={}):
5429  return self.translate(self.ctx)
5430 
5431  def simplify(self, *arguments, **keywords):
5432  """Return a new simplified goal.
5433 
5434  This method is essentially invoking the simplify tactic.
5435 
5436  >>> g = Goal()
5437  >>> x = Int('x')
5438  >>> g.add(x + 1 >= 2)
5439  >>> g
5440  [x + 1 >= 2]
5441  >>> g2 = g.simplify()
5442  >>> g2
5443  [x >= 1]
5444  >>> # g was not modified
5445  >>> g
5446  [x + 1 >= 2]
5447  """
5448  t = Tactic('simplify')
5449  return t.apply(self, *arguments, **keywords)[0]
5450 
5451  def as_expr(self):
5452  """Return goal `self` as a single Z3 expression.
5453 
5454  >>> x = Int('x')
5455  >>> g = Goal()
5456  >>> g.as_expr()
5457  True
5458  >>> g.add(x > 1)
5459  >>> g.as_expr()
5460  x > 1
5461  >>> g.add(x < 10)
5462  >>> g.as_expr()
5463  And(x > 1, x < 10)
5464  """
5465  sz = len(self)
5466  if sz == 0:
5467  return BoolVal(True, self.ctx)
5468  elif sz == 1:
5469  return self.get(0)
5470  else:
5471  return And([ self.get(i) for i in range(len(self)) ], self.ctx)
5472 
5473 
5479  """A collection (vector) of ASTs."""
5480 
5481  def __init__(self, v=None, ctx=None):
5482  self.vector = None
5483  if v is None:
5484  self.ctx = _get_ctx(ctx)
5485  self.vector = Z3_mk_ast_vector(self.ctx.ref())
5486  else:
5487  self.vector = v
5488  assert ctx is not None
5489  self.ctx = ctx
5490  Z3_ast_vector_inc_ref(self.ctx.ref(), self.vector)
5491 
5492  def __deepcopy__(self, memo={}):
5493  return AstVector(self.vector, self.ctx)
5494 
5495  def __del__(self):
5496  if self.vector is not None and self.ctx.ref() is not None:
5497  Z3_ast_vector_dec_ref(self.ctx.ref(), self.vector)
5498 
5499  def __len__(self):
5500  """Return the size of the vector `self`.
5501 
5502  >>> A = AstVector()
5503  >>> len(A)
5504  0
5505  >>> A.push(Int('x'))
5506  >>> A.push(Int('x'))
5507  >>> len(A)
5508  2
5509  """
5510  return int(Z3_ast_vector_size(self.ctx.ref(), self.vector))
5511 
5512  def __getitem__(self, i):
5513  """Return the AST at position `i`.
5514 
5515  >>> A = AstVector()
5516  >>> A.push(Int('x') + 1)
5517  >>> A.push(Int('y'))
5518  >>> A[0]
5519  x + 1
5520  >>> A[1]
5521  y
5522  """
5523 
5524  if isinstance(i, int):
5525  if i < 0:
5526  i += self.__len__()
5527 
5528  if i >= self.__len__():
5529  raise IndexError
5530  return _to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, i), self.ctx)
5531 
5532  elif isinstance(i, slice):
5533  return [_to_ast_ref(Z3_ast_vector_get(self.ctx.ref(), self.vector, ii), self.ctx) for ii in range(*i.indices(self.__len__()))]
5534 
5535 
5536  def __setitem__(self, i, v):
5537  """Update AST at position `i`.
5538 
5539  >>> A = AstVector()
5540  >>> A.push(Int('x') + 1)
5541  >>> A.push(Int('y'))
5542  >>> A[0]
5543  x + 1
5544  >>> A[0] = Int('x')
5545  >>> A[0]
5546  x
5547  """
5548  if i >= self.__len__():
5549  raise IndexError
5550  Z3_ast_vector_set(self.ctx.ref(), self.vector, i, v.as_ast())
5551 
5552  def push(self, v):
5553  """Add `v` in the end of the vector.
5554 
5555  >>> A = AstVector()
5556  >>> len(A)
5557  0
5558  >>> A.push(Int('x'))
5559  >>> len(A)
5560  1
5561  """
5562  Z3_ast_vector_push(self.ctx.ref(), self.vector, v.as_ast())
5563 
5564  def resize(self, sz):
5565  """Resize the vector to `sz` elements.
5566 
5567  >>> A = AstVector()
5568  >>> A.resize(10)
5569  >>> len(A)
5570  10
5571  >>> for i in range(10): A[i] = Int('x')
5572  >>> A[5]
5573  x
5574  """
5575  Z3_ast_vector_resize(self.ctx.ref(), self.vector, sz)
5576 
5577  def __contains__(self, item):
5578  """Return `True` if the vector contains `item`.
5579 
5580  >>> x = Int('x')
5581  >>> A = AstVector()
5582  >>> x in A
5583  False
5584  >>> A.push(x)
5585  >>> x in A
5586  True
5587  >>> (x+1) in A
5588  False
5589  >>> A.push(x+1)
5590  >>> (x+1) in A
5591  True
5592  >>> A
5593  [x, x + 1]
5594  """
5595  for elem in self:
5596  if elem.eq(item):
5597  return True
5598  return False
5599 
5600  def translate(self, other_ctx):
5601  """Copy vector `self` to context `other_ctx`.
5602 
5603  >>> x = Int('x')
5604  >>> A = AstVector()
5605  >>> A.push(x)
5606  >>> c2 = Context()
5607  >>> B = A.translate(c2)
5608  >>> B
5609  [x]
5610  """
5611  return AstVector(Z3_ast_vector_translate(self.ctx.ref(), self.vector, other_ctx.ref()), other_ctx)
5612 
5613  def __copy__(self):
5614  return self.translate(self.ctx)
5615 
5616  def __deepcopy__(self, memo={}):
5617  return self.translate(self.ctx)
5618 
5619  def __repr__(self):
5620  return obj_to_string(self)
5621 
5622  def sexpr(self):
5623  """Return a textual representation of the s-expression representing the vector."""
5624  return Z3_ast_vector_to_string(self.ctx.ref(), self.vector)
5625 
5626 
5631 class AstMap:
5632  """A mapping from ASTs to ASTs."""
5633 
5634  def __init__(self, m=None, ctx=None):
5635  self.map = None
5636  if m is None:
5637  self.ctx = _get_ctx(ctx)
5638  self.map = Z3_mk_ast_map(self.ctx.ref())
5639  else:
5640  self.map = m
5641  assert ctx is not None
5642  self.ctx = ctx
5643  Z3_ast_map_inc_ref(self.ctx.ref(), self.map)
5644 
5645  def __deepcopy__(self, memo={}):
5646  return AstMap(self.map, self.ctx)
5647 
5648  def __del__(self):
5649  if self.map is not None and self.ctx.ref() is not None:
5650  Z3_ast_map_dec_ref(self.ctx.ref(), self.map)
5651 
5652  def __len__(self):
5653  """Return the size of the map.
5654 
5655  >>> M = AstMap()
5656  >>> len(M)
5657  0
5658  >>> x = Int('x')
5659  >>> M[x] = IntVal(1)
5660  >>> len(M)
5661  1
5662  """
5663  return int(Z3_ast_map_size(self.ctx.ref(), self.map))
5664 
5665  def __contains__(self, key):
5666  """Return `True` if the map contains key `key`.
5667 
5668  >>> M = AstMap()
5669  >>> x = Int('x')
5670  >>> M[x] = x + 1
5671  >>> x in M
5672  True
5673  >>> x+1 in M
5674  False
5675  """
5676  return Z3_ast_map_contains(self.ctx.ref(), self.map, key.as_ast())
5677 
5678  def __getitem__(self, key):
5679  """Retrieve the value associated with key `key`.
5680 
5681  >>> M = AstMap()
5682  >>> x = Int('x')
5683  >>> M[x] = x + 1
5684  >>> M[x]
5685  x + 1
5686  """
5687  return _to_ast_ref(Z3_ast_map_find(self.ctx.ref(), self.map, key.as_ast()), self.ctx)
5688 
5689  def __setitem__(self, k, v):
5690  """Add/Update key `k` with value `v`.
5691 
5692  >>> M = AstMap()
5693  >>> x = Int('x')
5694  >>> M[x] = x + 1
5695  >>> len(M)
5696  1
5697  >>> M[x]
5698  x + 1
5699  >>> M[x] = IntVal(1)
5700  >>> M[x]
5701  1
5702  """
5703  Z3_ast_map_insert(self.ctx.ref(), self.map, k.as_ast(), v.as_ast())
5704 
5705  def __repr__(self):
5706  return Z3_ast_map_to_string(self.ctx.ref(), self.map)
5707 
5708  def erase(self, k):
5709  """Remove the entry associated with key `k`.
5710 
5711  >>> M = AstMap()
5712  >>> x = Int('x')
5713  >>> M[x] = x + 1
5714  >>> len(M)
5715  1
5716  >>> M.erase(x)
5717  >>> len(M)
5718  0
5719  """
5720  Z3_ast_map_erase(self.ctx.ref(), self.map, k.as_ast())
5721 
5722  def reset(self):
5723  """Remove all entries from the map.
5724 
5725  >>> M = AstMap()
5726  >>> x = Int('x')
5727  >>> M[x] = x + 1
5728  >>> M[x+x] = IntVal(1)
5729  >>> len(M)
5730  2
5731  >>> M.reset()
5732  >>> len(M)
5733  0
5734  """
5735  Z3_ast_map_reset(self.ctx.ref(), self.map)
5736 
5737  def keys(self):
5738  """Return an AstVector containing all keys in the map.
5739 
5740  >>> M = AstMap()
5741  >>> x = Int('x')
5742  >>> M[x] = x + 1
5743  >>> M[x+x] = IntVal(1)
5744  >>> M.keys()
5745  [x, x + x]
5746  """
5747  return AstVector(Z3_ast_map_keys(self.ctx.ref(), self.map), self.ctx)
5748 
5749 
5754 
5756  """Store the value of the interpretation of a function in a particular point."""
5757 
5758  def __init__(self, entry, ctx):
5759  self.entry = entry
5760  self.ctx = ctx
5761  Z3_func_entry_inc_ref(self.ctx.ref(), self.entry)
5762 
5763  def __deepcopy__(self, memo={}):
5764  return FuncEntry(self.entry, self.ctx)
5765 
5766  def __del__(self):
5767  if self.ctx.ref() is not None:
5768  Z3_func_entry_dec_ref(self.ctx.ref(), self.entry)
5769 
5770  def num_args(self):
5771  """Return the number of arguments in the given entry.
5772 
5773  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5774  >>> s = Solver()
5775  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5776  >>> s.check()
5777  sat
5778  >>> m = s.model()
5779  >>> f_i = m[f]
5780  >>> f_i.num_entries()
5781  1
5782  >>> e = f_i.entry(0)
5783  >>> e.num_args()
5784  2
5785  """
5786  return int(Z3_func_entry_get_num_args(self.ctx.ref(), self.entry))
5787 
5788  def arg_value(self, idx):
5789  """Return the value of argument `idx`.
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
5802  [1, 2, 20]
5803  >>> e.num_args()
5804  2
5805  >>> e.arg_value(0)
5806  1
5807  >>> e.arg_value(1)
5808  2
5809  >>> try:
5810  ... e.arg_value(2)
5811  ... except IndexError:
5812  ... print("index error")
5813  index error
5814  """
5815  if idx >= self.num_args():
5816  raise IndexError
5817  return _to_expr_ref(Z3_func_entry_get_arg(self.ctx.ref(), self.entry, idx), self.ctx)
5818 
5819  def value(self):
5820  """Return the value of the function at point `self`.
5821 
5822  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5823  >>> s = Solver()
5824  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5825  >>> s.check()
5826  sat
5827  >>> m = s.model()
5828  >>> f_i = m[f]
5829  >>> f_i.num_entries()
5830  1
5831  >>> e = f_i.entry(0)
5832  >>> e
5833  [1, 2, 20]
5834  >>> e.num_args()
5835  2
5836  >>> e.value()
5837  20
5838  """
5839  return _to_expr_ref(Z3_func_entry_get_value(self.ctx.ref(), self.entry), self.ctx)
5840 
5841  def as_list(self):
5842  """Return entry `self` as a Python list.
5843  >>> f = Function('f', IntSort(), IntSort(), IntSort())
5844  >>> s = Solver()
5845  >>> s.add(f(0, 1) == 10, f(1, 2) == 20, f(1, 0) == 10)
5846  >>> s.check()
5847  sat
5848  >>> m = s.model()
5849  >>> f_i = m[f]
5850  >>> f_i.num_entries()
5851  1
5852  >>> e = f_i.entry(0)
5853  >>> e.as_list()
5854  [1, 2, 20]
5855  """
5856  args = [ self.arg_value(i) for i in range(self.num_args())]
5857  args.append(self.value())
5858  return args
5859 
5860  def __repr__(self):
5861  return repr(self.as_list())
5862 
5864  """Stores the interpretation of a function in a Z3 model."""
5865 
5866  def __init__(self, f, ctx):
5867  self.f = f
5868  self.ctx = ctx
5869  if self.f is not None:
5870  Z3_func_interp_inc_ref(self.ctx.ref(), self.f)
5871 
5872  def __deepcopy__(self, memo={}):
5873  return FuncInterp(self.f, self.ctx)
5874 
5875  def __del__(self):
5876  if self.f is not None and self.ctx.ref() is not None:
5877  Z3_func_interp_dec_ref(self.ctx.ref(), self.f)
5878 
5879  def else_value(self):
5880  """
5881  Return the `else` value for a function interpretation.
5882  Return None if Z3 did not specify the `else` value for
5883  this object.
5884 
5885  >>> f = Function('f', IntSort(), IntSort())
5886  >>> s = Solver()
5887  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5888  >>> s.check()
5889  sat
5890  >>> m = s.model()
5891  >>> m[f]
5892  [2 -> 0, else -> 1]
5893  >>> m[f].else_value()
5894  1
5895  """
5896  r = Z3_func_interp_get_else(self.ctx.ref(), self.f)
5897  if r:
5898  return _to_expr_ref(r, self.ctx)
5899  else:
5900  return None
5901 
5902  def num_entries(self):
5903  """Return the number of entries/points in the function interpretation `self`.
5904 
5905  >>> f = Function('f', IntSort(), IntSort())
5906  >>> s = Solver()
5907  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5908  >>> s.check()
5909  sat
5910  >>> m = s.model()
5911  >>> m[f]
5912  [2 -> 0, else -> 1]
5913  >>> m[f].num_entries()
5914  1
5915  """
5916  return int(Z3_func_interp_get_num_entries(self.ctx.ref(), self.f))
5917 
5918  def arity(self):
5919  """Return the number of arguments for each entry in the function interpretation `self`.
5920 
5921  >>> f = Function('f', IntSort(), IntSort())
5922  >>> s = Solver()
5923  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5924  >>> s.check()
5925  sat
5926  >>> m = s.model()
5927  >>> m[f].arity()
5928  1
5929  """
5930  return int(Z3_func_interp_get_arity(self.ctx.ref(), self.f))
5931 
5932  def entry(self, idx):
5933  """Return an entry at position `idx < self.num_entries()` in the function interpretation `self`.
5934 
5935  >>> f = Function('f', IntSort(), IntSort())
5936  >>> s = Solver()
5937  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5938  >>> s.check()
5939  sat
5940  >>> m = s.model()
5941  >>> m[f]
5942  [2 -> 0, else -> 1]
5943  >>> m[f].num_entries()
5944  1
5945  >>> m[f].entry(0)
5946  [2, 0]
5947  """
5948  if idx >= self.num_entries():
5949  raise IndexError
5950  return FuncEntry(Z3_func_interp_get_entry(self.ctx.ref(), self.f, idx), self.ctx)
5951 
5952  def translate(self, other_ctx):
5953  """Copy model 'self' to context 'other_ctx'.
5954  """
5955  return ModelRef(Z3_model_translate(self.ctx.ref(), self.model, other_ctx.ref()), other_ctx)
5956 
5957  def __copy__(self):
5958  return self.translate(self.ctx)
5959 
5960  def __deepcopy__(self, memo={}):
5961  return self.translate(self.ctx)
5962 
5963  def as_list(self):
5964  """Return the function interpretation as a Python list.
5965  >>> f = Function('f', IntSort(), IntSort())
5966  >>> s = Solver()
5967  >>> s.add(f(0) == 1, f(1) == 1, f(2) == 0)
5968  >>> s.check()
5969  sat
5970  >>> m = s.model()
5971  >>> m[f]
5972  [2 -> 0, else -> 1]
5973  >>> m[f].as_list()
5974  [[2, 0], 1]
5975  """
5976  r = [ self.entry(i).as_list() for i in range(self.num_entries())]
5977  r.append(self.else_value())
5978  return r
5979 
5980  def __repr__(self):
5981  return obj_to_string(self)
5982 
5984  """Model/Solution of a satisfiability problem (aka system of constraints)."""
5985 
5986  def __init__(self, m, ctx):
5987  assert ctx is not None
5988  self.model = m
5989  self.ctx = ctx
5990  Z3_model_inc_ref(self.ctx.ref(), self.model)
5991 
5992  def __del__(self):
5993  if self.ctx.ref() is not None:
5994  Z3_model_dec_ref(self.ctx.ref(), self.model)
5995 
5996  def __repr__(self):
5997  return obj_to_string(self)
5998 
5999  def sexpr(self):
6000  """Return a textual representation of the s-expression representing the model."""
6001  return Z3_model_to_string(self.ctx.ref(), self.model)
6002 
6003  def eval(self, t, model_completion=False):
6004  """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`.
6005 
6006  >>> x = Int('x')
6007  >>> s = Solver()
6008  >>> s.add(x > 0, x < 2)
6009  >>> s.check()
6010  sat
6011  >>> m = s.model()
6012  >>> m.eval(x + 1)
6013  2
6014  >>> m.eval(x == 1)
6015  True
6016  >>> y = Int('y')
6017  >>> m.eval(y + x)
6018  1 + y
6019  >>> m.eval(y)
6020  y
6021  >>> m.eval(y, model_completion=True)
6022  0
6023  >>> # Now, m contains an interpretation for y
6024  >>> m.eval(y + x)
6025  1
6026  """
6027  r = (Ast * 1)()
6028  if Z3_model_eval(self.ctx.ref(), self.model, t.as_ast(), model_completion, r):
6029  return _to_expr_ref(r[0], self.ctx)
6030  raise Z3Exception("failed to evaluate expression in the model")
6031 
6032  def evaluate(self, t, model_completion=False):
6033  """Alias for `eval`.
6034 
6035  >>> x = Int('x')
6036  >>> s = Solver()
6037  >>> s.add(x > 0, x < 2)
6038  >>> s.check()
6039  sat
6040  >>> m = s.model()
6041  >>> m.evaluate(x + 1)
6042  2
6043  >>> m.evaluate(x == 1)
6044  True
6045  >>> y = Int('y')
6046  >>> m.evaluate(y + x)
6047  1 + y
6048  >>> m.evaluate(y)
6049  y
6050  >>> m.evaluate(y, model_completion=True)
6051  0
6052  >>> # Now, m contains an interpretation for y
6053  >>> m.evaluate(y + x)
6054  1
6055  """
6056  return self.eval(t, model_completion)
6057 
6058  def __len__(self):
6059  """Return the number of constant and function declarations in the model `self`.
6060 
6061  >>> f = Function('f', IntSort(), IntSort())
6062  >>> x = Int('x')
6063  >>> s = Solver()
6064  >>> s.add(x > 0, f(x) != x)
6065  >>> s.check()
6066  sat
6067  >>> m = s.model()
6068  >>> len(m)
6069  2
6070  """
6071  return int(Z3_model_get_num_consts(self.ctx.ref(), self.model)) + int(Z3_model_get_num_funcs(self.ctx.ref(), self.model))
6072 
6073  def get_interp(self, decl):
6074  """Return the interpretation for a given declaration or constant.
6075 
6076  >>> f = Function('f', IntSort(), IntSort())
6077  >>> x = Int('x')
6078  >>> s = Solver()
6079  >>> s.add(x > 0, x < 2, f(x) == 0)
6080  >>> s.check()
6081  sat
6082  >>> m = s.model()
6083  >>> m[x]
6084  1
6085  >>> m[f]
6086  [else -> 0]
6087  """
6088  if z3_debug():
6089  _z3_assert(isinstance(decl, FuncDeclRef) or is_const(decl), "Z3 declaration expected")
6090  if is_const(decl):
6091  decl = decl.decl()
6092  try:
6093  if decl.arity() == 0:
6094  _r = Z3_model_get_const_interp(self.ctx.ref(), self.model, decl.ast)
6095  if _r.value is None:
6096  return None
6097  r = _to_expr_ref(_r, self.ctx)
6098  if is_as_array(r):
6099  return self.get_interp(get_as_array_func(r))
6100  else:
6101  return r
6102  else:
6103  return FuncInterp(Z3_model_get_func_interp(self.ctx.ref(), self.model, decl.ast), self.ctx)
6104  except Z3Exception:
6105  return None
6106 
6107  def num_sorts(self):
6108  """Return the number of uninterpreted sorts that contain an interpretation in the model `self`.
6109 
6110  >>> A = DeclareSort('A')
6111  >>> a, b = Consts('a b', A)
6112  >>> s = Solver()
6113  >>> s.add(a != b)
6114  >>> s.check()
6115  sat
6116  >>> m = s.model()
6117  >>> m.num_sorts()
6118  1
6119  """
6120  return int(Z3_model_get_num_sorts(self.ctx.ref(), self.model))
6121 
6122  def get_sort(self, idx):
6123  """Return the uninterpreted sort at position `idx` < self.num_sorts().
6124 
6125  >>> A = DeclareSort('A')
6126  >>> B = DeclareSort('B')
6127  >>> a1, a2 = Consts('a1 a2', A)
6128  >>> b1, b2 = Consts('b1 b2', B)
6129  >>> s = Solver()
6130  >>> s.add(a1 != a2, b1 != b2)
6131  >>> s.check()
6132  sat
6133  >>> m = s.model()
6134  >>> m.num_sorts()
6135  2
6136  >>> m.get_sort(0)
6137  A
6138  >>> m.get_sort(1)
6139  B
6140  """
6141  if idx >= self.num_sorts():
6142  raise IndexError
6143  return _to_sort_ref(Z3_model_get_sort(self.ctx.ref(), self.model, idx), self.ctx)
6144 
6145  def sorts(self):
6146  """Return all uninterpreted sorts that have an interpretation in the model `self`.
6147 
6148  >>> A = DeclareSort('A')
6149  >>> B = DeclareSort('B')
6150  >>> a1, a2 = Consts('a1 a2', A)
6151  >>> b1, b2 = Consts('b1 b2', B)
6152  >>> s = Solver()
6153  >>> s.add(a1 != a2, b1 != b2)
6154  >>> s.check()
6155  sat
6156  >>> m = s.model()
6157  >>> m.sorts()
6158  [A, B]
6159  """
6160  return [ self.get_sort(i) for i in range(self.num_sorts()) ]
6161 
6162  def get_universe(self, s):
6163  """Return the interpretation for the uninterpreted sort `s` in the model `self`.
6164 
6165  >>> A = DeclareSort('A')
6166  >>> a, b = Consts('a b', A)
6167  >>> s = Solver()
6168  >>> s.add(a != b)
6169  >>> s.check()
6170  sat
6171  >>> m = s.model()
6172  >>> m.get_universe(A)
6173  [A!val!0, A!val!1]
6174  """
6175  if z3_debug():
6176  _z3_assert(isinstance(s, SortRef), "Z3 sort expected")
6177  try:
6178  return AstVector(Z3_model_get_sort_universe(self.ctx.ref(), self.model, s.ast), self.ctx)
6179  except Z3Exception:
6180  return None
6181 
6182  def __getitem__(self, idx):
6183  """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.
6184 
6185  The elements can be retrieved using position or the actual declaration.
6186 
6187  >>> f = Function('f', IntSort(), IntSort())
6188  >>> x = Int('x')
6189  >>> s = Solver()
6190  >>> s.add(x > 0, x < 2, f(x) == 0)
6191  >>> s.check()
6192  sat
6193  >>> m = s.model()
6194  >>> len(m)
6195  2
6196  >>> m[0]
6197  x
6198  >>> m[1]
6199  f
6200  >>> m[x]
6201  1
6202  >>> m[f]
6203  [else -> 0]
6204  >>> for d in m: print("%s -> %s" % (d, m[d]))
6205  x -> 1
6206  f -> [else -> 0]
6207  """
6208  if _is_int(idx):
6209  if idx >= len(self):
6210  raise IndexError
6211  num_consts = Z3_model_get_num_consts(self.ctx.ref(), self.model)
6212  if (idx < num_consts):
6213  return FuncDeclRef(Z3_model_get_const_decl(self.ctx.ref(), self.model, idx), self.ctx)
6214  else:
6215  return FuncDeclRef(Z3_model_get_func_decl(self.ctx.ref(), self.model, idx - num_consts), self.ctx)
6216  if isinstance(idx, FuncDeclRef):
6217  return self.get_interp(idx)
6218  if is_const(idx):
6219  return self.get_interp(idx.decl())
6220  if isinstance(idx, SortRef):
6221  return self.get_universe(idx)
6222  if z3_debug():
6223  _z3_assert(False, "Integer, Z3 declaration, or Z3 constant expected")
6224  return None
6225 
6226  def decls(self):
6227  """Return a list with all symbols that have an interpretation in the model `self`.
6228  >>> f = Function('f', IntSort(), IntSort())
6229  >>> x = Int('x')
6230  >>> s = Solver()
6231  >>> s.add(x > 0, x < 2, f(x) == 0)
6232  >>> s.check()
6233  sat
6234  >>> m = s.model()
6235  >>> m.decls()
6236  [x, f]
6237  """
6238  r = []
6239  for i in range(Z3_model_get_num_consts(self.ctx.ref(), self.model)):
6240  r.append(FuncDeclRef(Z3_model_get_const_decl(self.ctx.ref(), self.model, i), self.ctx))
6241  for i in range(Z3_model_get_num_funcs(self.ctx.ref(), self.model)):
6242  r.append(FuncDeclRef(Z3_model_get_func_decl(self.ctx.ref(), self.model, i), self.ctx))
6243  return r
6244 
6245  def translate(self, target):
6246  """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
6247  """
6248  if z3_debug():
6249  _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
6250  model = Z3_model_translate(self.ctx.ref(), self.model, target.ref())
6251  return Model(model, target)
6252 
6253  def __copy__(self):
6254  return self.translate(self.ctx)
6255 
6256  def __deepcopy__(self, memo={}):
6257  return self.translate(self.ctx)
6258 
6259 def Model(ctx = None):
6260  ctx = _get_ctx(ctx)
6261  return ModelRef(Z3_mk_model(ctx.ref()), ctx)
6262 
6264  """Return true if n is a Z3 expression of the form (_ as-array f)."""
6265  return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast())
6266 
6268  """Return the function declaration f associated with a Z3 expression of the form (_ as-array f)."""
6269  if z3_debug():
6270  _z3_assert(is_as_array(n), "as-array Z3 expression expected.")
6271  return FuncDeclRef(Z3_get_as_array_func_decl(n.ctx.ref(), n.as_ast()), n.ctx)
6272 
6273 
6279  """Statistics for `Solver.check()`."""
6280 
6281  def __init__(self, stats, ctx):
6282  self.stats = stats
6283  self.ctx = ctx
6284  Z3_stats_inc_ref(self.ctx.ref(), self.stats)
6285 
6286  def __deepcopy__(self, memo={}):
6287  return Statistics(self.stats, self.ctx)
6288 
6289  def __del__(self):
6290  if self.ctx.ref() is not None:
6291  Z3_stats_dec_ref(self.ctx.ref(), self.stats)
6292 
6293  def __repr__(self):
6294  if in_html_mode():
6295  out = io.StringIO()
6296  even = True
6297  out.write(u('<table border="1" cellpadding="2" cellspacing="0">'))
6298  for k, v in self:
6299  if even:
6300  out.write(u('<tr style="background-color:#CFCFCF">'))
6301  even = False
6302  else:
6303  out.write(u('<tr>'))
6304  even = True
6305  out.write(u('<td>%s</td><td>%s</td></tr>' % (k, v)))
6306  out.write(u('</table>'))
6307  return out.getvalue()
6308  else:
6309  return Z3_stats_to_string(self.ctx.ref(), self.stats)
6310 
6311  def __len__(self):
6312  """Return the number of statistical counters.
6313 
6314  >>> x = Int('x')
6315  >>> s = Then('simplify', 'nlsat').solver()
6316  >>> s.add(x > 0)
6317  >>> s.check()
6318  sat
6319  >>> st = s.statistics()
6320  >>> len(st)
6321  6
6322  """
6323  return int(Z3_stats_size(self.ctx.ref(), self.stats))
6324 
6325  def __getitem__(self, idx):
6326  """Return the value of statistical counter at position `idx`. The result is a pair (key, value).
6327 
6328  >>> x = Int('x')
6329  >>> s = Then('simplify', 'nlsat').solver()
6330  >>> s.add(x > 0)
6331  >>> s.check()
6332  sat
6333  >>> st = s.statistics()
6334  >>> len(st)
6335  6
6336  >>> st[0]
6337  ('nlsat propagations', 2)
6338  >>> st[1]
6339  ('nlsat stages', 2)
6340  """
6341  if idx >= len(self):
6342  raise IndexError
6343  if Z3_stats_is_uint(self.ctx.ref(), self.stats, idx):
6344  val = int(Z3_stats_get_uint_value(self.ctx.ref(), self.stats, idx))
6345  else:
6346  val = Z3_stats_get_double_value(self.ctx.ref(), self.stats, idx)
6347  return (Z3_stats_get_key(self.ctx.ref(), self.stats, idx), val)
6348 
6349  def keys(self):
6350  """Return the list of statistical counters.
6351 
6352  >>> x = Int('x')
6353  >>> s = Then('simplify', 'nlsat').solver()
6354  >>> s.add(x > 0)
6355  >>> s.check()
6356  sat
6357  >>> st = s.statistics()
6358  """
6359  return [Z3_stats_get_key(self.ctx.ref(), self.stats, idx) for idx in range(len(self))]
6360 
6361  def get_key_value(self, key):
6362  """Return the value of a particular statistical counter.
6363 
6364  >>> x = Int('x')
6365  >>> s = Then('simplify', 'nlsat').solver()
6366  >>> s.add(x > 0)
6367  >>> s.check()
6368  sat
6369  >>> st = s.statistics()
6370  >>> st.get_key_value('nlsat propagations')
6371  2
6372  """
6373  for idx in range(len(self)):
6374  if key == Z3_stats_get_key(self.ctx.ref(), self.stats, idx):
6375  if Z3_stats_is_uint(self.ctx.ref(), self.stats, idx):
6376  return int(Z3_stats_get_uint_value(self.ctx.ref(), self.stats, idx))
6377  else:
6378  return Z3_stats_get_double_value(self.ctx.ref(), self.stats, idx)
6379  raise Z3Exception("unknown key")
6380 
6381  def __getattr__(self, name):
6382  """Access the value of statistical using attributes.
6383 
6384  Remark: to access a counter containing blank spaces (e.g., 'nlsat propagations'),
6385  we should use '_' (e.g., 'nlsat_propagations').
6386 
6387  >>> x = Int('x')
6388  >>> s = Then('simplify', 'nlsat').solver()
6389  >>> s.add(x > 0)
6390  >>> s.check()
6391  sat
6392  >>> st = s.statistics()
6393  >>> st.nlsat_propagations
6394  2
6395  >>> st.nlsat_stages
6396  2
6397  """
6398  key = name.replace('_', ' ')
6399  try:
6400  return self.get_key_value(key)
6401  except Z3Exception:
6402  raise AttributeError
6403 
6404 
6410  """Represents the result of a satisfiability check: sat, unsat, unknown.
6411 
6412  >>> s = Solver()
6413  >>> s.check()
6414  sat
6415  >>> r = s.check()
6416  >>> isinstance(r, CheckSatResult)
6417  True
6418  """
6419 
6420  def __init__(self, r):
6421  self.r = r
6422 
6423  def __deepcopy__(self, memo={}):
6424  return CheckSatResult(self.r)
6425 
6426  def __eq__(self, other):
6427  return isinstance(other, CheckSatResult) and self.r == other.r
6428 
6429  def __ne__(self, other):
6430  return not self.__eq__(other)
6431 
6432  def __repr__(self):
6433  if in_html_mode():
6434  if self.r == Z3_L_TRUE:
6435  return "<b>sat</b>"
6436  elif self.r == Z3_L_FALSE:
6437  return "<b>unsat</b>"
6438  else:
6439  return "<b>unknown</b>"
6440  else:
6441  if self.r == Z3_L_TRUE:
6442  return "sat"
6443  elif self.r == Z3_L_FALSE:
6444  return "unsat"
6445  else:
6446  return "unknown"
6447 
6448  def _repr_html_(self):
6449  in_html = in_html_mode()
6450  set_html_mode(True)
6451  res = repr(self)
6452  set_html_mode(in_html)
6453  return res
6454 
6455 sat = CheckSatResult(Z3_L_TRUE)
6456 unsat = CheckSatResult(Z3_L_FALSE)
6457 unknown = CheckSatResult(Z3_L_UNDEF)
6458 
6460  """Solver API provides methods for implementing the main SMT 2.0 commands: push, pop, check, get-model, etc."""
6461 
6462  def __init__(self, solver=None, ctx=None, logFile=None):
6463  assert solver is None or ctx is not None
6464  self.ctx = _get_ctx(ctx)
6465  self.backtrack_level = 4000000000
6466  self.solver = None
6467  if solver is None:
6468  self.solver = Z3_mk_solver(self.ctx.ref())
6469  else:
6470  self.solver = solver
6471  Z3_solver_inc_ref(self.ctx.ref(), self.solver)
6472  if logFile is not None:
6473  self.set("solver.smtlib2_log", logFile)
6474 
6475  def __del__(self):
6476  if self.solver is not None and self.ctx.ref() is not None:
6477  Z3_solver_dec_ref(self.ctx.ref(), self.solver)
6478 
6479  def set(self, *args, **keys):
6480  """Set a configuration option. The method `help()` return a string containing all available options.
6481 
6482  >>> s = Solver()
6483  >>> # The option MBQI can be set using three different approaches.
6484  >>> s.set(mbqi=True)
6485  >>> s.set('MBQI', True)
6486  >>> s.set(':mbqi', True)
6487  """
6488  p = args2params(args, keys, self.ctx)
6489  Z3_solver_set_params(self.ctx.ref(), self.solver, p.params)
6490 
6491  def push(self):
6492  """Create a backtracking point.
6493 
6494  >>> x = Int('x')
6495  >>> s = Solver()
6496  >>> s.add(x > 0)
6497  >>> s
6498  [x > 0]
6499  >>> s.push()
6500  >>> s.add(x < 1)
6501  >>> s
6502  [x > 0, x < 1]
6503  >>> s.check()
6504  unsat
6505  >>> s.pop()
6506  >>> s.check()
6507  sat
6508  >>> s
6509  [x > 0]
6510  """
6511  Z3_solver_push(self.ctx.ref(), self.solver)
6512 
6513  def pop(self, num=1):
6514  """Backtrack \c num backtracking points.
6515 
6516  >>> x = Int('x')
6517  >>> s = Solver()
6518  >>> s.add(x > 0)
6519  >>> s
6520  [x > 0]
6521  >>> s.push()
6522  >>> s.add(x < 1)
6523  >>> s
6524  [x > 0, x < 1]
6525  >>> s.check()
6526  unsat
6527  >>> s.pop()
6528  >>> s.check()
6529  sat
6530  >>> s
6531  [x > 0]
6532  """
6533  Z3_solver_pop(self.ctx.ref(), self.solver, num)
6534 
6535  def num_scopes(self):
6536  """Return the current number of backtracking points.
6537 
6538  >>> s = Solver()
6539  >>> s.num_scopes()
6540  0L
6541  >>> s.push()
6542  >>> s.num_scopes()
6543  1L
6544  >>> s.push()
6545  >>> s.num_scopes()
6546  2L
6547  >>> s.pop()
6548  >>> s.num_scopes()
6549  1L
6550  """
6551  return Z3_solver_get_num_scopes(self.ctx.ref(), self.solver)
6552 
6553  def reset(self):
6554  """Remove all asserted constraints and backtracking points created using `push()`.
6555 
6556  >>> x = Int('x')
6557  >>> s = Solver()
6558  >>> s.add(x > 0)
6559  >>> s
6560  [x > 0]
6561  >>> s.reset()
6562  >>> s
6563  []
6564  """
6565  Z3_solver_reset(self.ctx.ref(), self.solver)
6566 
6567  def assert_exprs(self, *args):
6568  """Assert constraints into the solver.
6569 
6570  >>> x = Int('x')
6571  >>> s = Solver()
6572  >>> s.assert_exprs(x > 0, x < 2)
6573  >>> s
6574  [x > 0, x < 2]
6575  """
6576  args = _get_args(args)
6577  s = BoolSort(self.ctx)
6578  for arg in args:
6579  if isinstance(arg, Goal) or isinstance(arg, AstVector):
6580  for f in arg:
6581  Z3_solver_assert(self.ctx.ref(), self.solver, f.as_ast())
6582  else:
6583  arg = s.cast(arg)
6584  Z3_solver_assert(self.ctx.ref(), self.solver, arg.as_ast())
6585 
6586  def add(self, *args):
6587  """Assert constraints into the solver.
6588 
6589  >>> x = Int('x')
6590  >>> s = Solver()
6591  >>> s.add(x > 0, x < 2)
6592  >>> s
6593  [x > 0, x < 2]
6594  """
6595  self.assert_exprs(*args)
6596 
6597  def __iadd__(self, fml):
6598  self.add(fml)
6599  return self
6600 
6601  def append(self, *args):
6602  """Assert constraints into the solver.
6603 
6604  >>> x = Int('x')
6605  >>> s = Solver()
6606  >>> s.append(x > 0, x < 2)
6607  >>> s
6608  [x > 0, x < 2]
6609  """
6610  self.assert_exprs(*args)
6611 
6612  def insert(self, *args):
6613  """Assert constraints into the solver.
6614 
6615  >>> x = Int('x')
6616  >>> s = Solver()
6617  >>> s.insert(x > 0, x < 2)
6618  >>> s
6619  [x > 0, x < 2]
6620  """
6621  self.assert_exprs(*args)
6622 
6623  def assert_and_track(self, a, p):
6624  """Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.
6625 
6626  If `p` is a string, it will be automatically converted into a Boolean constant.
6627 
6628  >>> x = Int('x')
6629  >>> p3 = Bool('p3')
6630  >>> s = Solver()
6631  >>> s.set(unsat_core=True)
6632  >>> s.assert_and_track(x > 0, 'p1')
6633  >>> s.assert_and_track(x != 1, 'p2')
6634  >>> s.assert_and_track(x < 0, p3)
6635  >>> print(s.check())
6636  unsat
6637  >>> c = s.unsat_core()
6638  >>> len(c)
6639  2
6640  >>> Bool('p1') in c
6641  True
6642  >>> Bool('p2') in c
6643  False
6644  >>> p3 in c
6645  True
6646  """
6647  if isinstance(p, str):
6648  p = Bool(p, self.ctx)
6649  _z3_assert(isinstance(a, BoolRef), "Boolean expression expected")
6650  _z3_assert(isinstance(p, BoolRef) and is_const(p), "Boolean expression expected")
6651  Z3_solver_assert_and_track(self.ctx.ref(), self.solver, a.as_ast(), p.as_ast())
6652 
6653  def check(self, *assumptions):
6654  """Check whether the assertions in the given solver plus the optional assumptions are consistent or not.
6655 
6656  >>> x = Int('x')
6657  >>> s = Solver()
6658  >>> s.check()
6659  sat
6660  >>> s.add(x > 0, x < 2)
6661  >>> s.check()
6662  sat
6663  >>> s.model().eval(x)
6664  1
6665  >>> s.add(x < 1)
6666  >>> s.check()
6667  unsat
6668  >>> s.reset()
6669  >>> s.add(2**x == 4)
6670  >>> s.check()
6671  unknown
6672  """
6673  assumptions = _get_args(assumptions)
6674  num = len(assumptions)
6675  _assumptions = (Ast * num)()
6676  for i in range(num):
6677  _assumptions[i] = assumptions[i].as_ast()
6678  r = Z3_solver_check_assumptions(self.ctx.ref(), self.solver, num, _assumptions)
6679  return CheckSatResult(r)
6680 
6681  def model(self):
6682  """Return a model for the last `check()`.
6683 
6684  This function raises an exception if
6685  a model is not available (e.g., last `check()` returned unsat).
6686 
6687  >>> s = Solver()
6688  >>> a = Int('a')
6689  >>> s.add(a + 2 == 0)
6690  >>> s.check()
6691  sat
6692  >>> s.model()
6693  [a = -2]
6694  """
6695  try:
6696  return ModelRef(Z3_solver_get_model(self.ctx.ref(), self.solver), self.ctx)
6697  except Z3Exception:
6698  raise Z3Exception("model is not available")
6699 
6700  def import_model_converter(self, other):
6701  """Import model converter from other into the current solver"""
6702  Z3_solver_import_model_converter(self.ctx.ref(), other.solver, self.solver)
6703 
6704  def unsat_core(self):
6705  """Return a subset (as an AST vector) of the assumptions provided to the last check().
6706 
6707  These are the assumptions Z3 used in the unsatisfiability proof.
6708  Assumptions are available in Z3. They are used to extract unsatisfiable cores.
6709  They may be also used to "retract" assumptions. Note that, assumptions are not really
6710  "soft constraints", but they can be used to implement them.
6711 
6712  >>> p1, p2, p3 = Bools('p1 p2 p3')
6713  >>> x, y = Ints('x y')
6714  >>> s = Solver()
6715  >>> s.add(Implies(p1, x > 0))
6716  >>> s.add(Implies(p2, y > x))
6717  >>> s.add(Implies(p2, y < 1))
6718  >>> s.add(Implies(p3, y > -3))
6719  >>> s.check(p1, p2, p3)
6720  unsat
6721  >>> core = s.unsat_core()
6722  >>> len(core)
6723  2
6724  >>> p1 in core
6725  True
6726  >>> p2 in core
6727  True
6728  >>> p3 in core
6729  False
6730  >>> # "Retracting" p2
6731  >>> s.check(p1, p3)
6732  sat
6733  """
6734  return AstVector(Z3_solver_get_unsat_core(self.ctx.ref(), self.solver), self.ctx)
6735 
6736  def consequences(self, assumptions, variables):
6737  """Determine fixed values for the variables based on the solver state and assumptions.
6738  >>> s = Solver()
6739  >>> a, b, c, d = Bools('a b c d')
6740  >>> s.add(Implies(a,b), Implies(b, c))
6741  >>> s.consequences([a],[b,c,d])
6742  (sat, [Implies(a, b), Implies(a, c)])
6743  >>> s.consequences([Not(c),d],[a,b,c,d])
6744  (sat, [Implies(d, d), Implies(Not(c), Not(c)), Implies(Not(c), Not(b)), Implies(Not(c), Not(a))])
6745  """
6746  if isinstance(assumptions, list):
6747  _asms = AstVector(None, self.ctx)
6748  for a in assumptions:
6749  _asms.push(a)
6750  assumptions = _asms
6751  if isinstance(variables, list):
6752  _vars = AstVector(None, self.ctx)
6753  for a in variables:
6754  _vars.push(a)
6755  variables = _vars
6756  _z3_assert(isinstance(assumptions, AstVector), "ast vector expected")
6757  _z3_assert(isinstance(variables, AstVector), "ast vector expected")
6758  consequences = AstVector(None, self.ctx)
6759  r = Z3_solver_get_consequences(self.ctx.ref(), self.solver, assumptions.vector, variables.vector, consequences.vector)
6760  sz = len(consequences)
6761  consequences = [ consequences[i] for i in range(sz) ]
6762  return CheckSatResult(r), consequences
6763 
6764  def from_file(self, filename):
6765  """Parse assertions from a file"""
6766  Z3_solver_from_file(self.ctx.ref(), self.solver, filename)
6767 
6768  def from_string(self, s):
6769  """Parse assertions from a string"""
6770  Z3_solver_from_string(self.ctx.ref(), self.solver, s)
6771 
6772  def cube(self, vars = None):
6773  """Get set of cubes
6774  The method takes an optional set of variables that restrict which
6775  variables may be used as a starting point for cubing.
6776  If vars is not None, then the first case split is based on a variable in
6777  this set.
6778  """
6779  self.cube_vs = AstVector(None, self.ctx)
6780  if vars is not None:
6781  for v in vars:
6782  self.cube_vs.push(v)
6783  while True:
6784  lvl = self.backtrack_level
6785  self.backtrack_level = 4000000000
6786  r = AstVector(Z3_solver_cube(self.ctx.ref(), self.solver, self.cube_vs.vector, lvl), self.ctx)
6787  if (len(r) == 1 and is_false(r[0])):
6788  return
6789  yield r
6790  if (len(r) == 0):
6791  return
6792 
6793  def cube_vars(self):
6794  """Access the set of variables that were touched by the most recently generated cube.
6795  This set of variables can be used as a starting point for additional cubes.
6796  The idea is that variables that appear in clauses that are reduced by the most recent
6797  cube are likely more useful to cube on."""
6798  return self.cube_vs
6799 
6800  def proof(self):
6801  """Return a proof for the last `check()`. Proof construction must be enabled."""
6802  return _to_expr_ref(Z3_solver_get_proof(self.ctx.ref(), self.solver), self.ctx)
6803 
6804  def assertions(self):
6805  """Return an AST vector containing all added constraints.
6806 
6807  >>> s = Solver()
6808  >>> s.assertions()
6809  []
6810  >>> a = Int('a')
6811  >>> s.add(a > 0)
6812  >>> s.add(a < 10)
6813  >>> s.assertions()
6814  [a > 0, a < 10]
6815  """
6816  return AstVector(Z3_solver_get_assertions(self.ctx.ref(), self.solver), self.ctx)
6817 
6818  def units(self):
6819  """Return an AST vector containing all currently inferred units.
6820  """
6821  return AstVector(Z3_solver_get_units(self.ctx.ref(), self.solver), self.ctx)
6822 
6823  def non_units(self):
6824  """Return an AST vector containing all atomic formulas in solver state that are not units.
6825  """
6826  return AstVector(Z3_solver_get_non_units(self.ctx.ref(), self.solver), self.ctx)
6827 
6828  def trail_levels(self):
6829  """Return trail and decision levels of the solver state after a check() call.
6830  """
6831  trail = self.trail()
6832  levels = (ctypes.c_uint * len(trail))()
6833  Z3_solver_get_levels(self.ctx.ref(), self.solver, trail.vector, len(trail), levels)
6834  return trail, levels
6835 
6836  def trail(self):
6837  """Return trail of the solver state after a check() call.
6838  """
6839  return AstVector(Z3_solver_get_trail(self.ctx.ref(), self.solver), self.ctx)
6840 
6841  def statistics(self):
6842  """Return statistics for the last `check()`.
6843 
6844  >>> s = SimpleSolver()
6845  >>> x = Int('x')
6846  >>> s.add(x > 0)
6847  >>> s.check()
6848  sat
6849  >>> st = s.statistics()
6850  >>> st.get_key_value('final checks')
6851  1
6852  >>> len(st) > 0
6853  True
6854  >>> st[0] != 0
6855  True
6856  """
6857  return Statistics(Z3_solver_get_statistics(self.ctx.ref(), self.solver), self.ctx)
6858 
6859  def reason_unknown(self):
6860  """Return a string describing why the last `check()` returned `unknown`.
6861 
6862  >>> x = Int('x')
6863  >>> s = SimpleSolver()
6864  >>> s.add(2**x == 4)
6865  >>> s.check()
6866  unknown
6867  >>> s.reason_unknown()
6868  '(incomplete (theory arithmetic))'
6869  """
6870  return Z3_solver_get_reason_unknown(self.ctx.ref(), self.solver)
6871 
6872  def help(self):
6873  """Display a string describing all available options."""
6874  print(Z3_solver_get_help(self.ctx.ref(), self.solver))
6875 
6876  def param_descrs(self):
6877  """Return the parameter description set."""
6878  return ParamDescrsRef(Z3_solver_get_param_descrs(self.ctx.ref(), self.solver), self.ctx)
6879 
6880  def __repr__(self):
6881  """Return a formatted string with all added constraints."""
6882  return obj_to_string(self)
6883 
6884  def translate(self, target):
6885  """Translate `self` to the context `target`. That is, return a copy of `self` in the context `target`.
6886 
6887  >>> c1 = Context()
6888  >>> c2 = Context()
6889  >>> s1 = Solver(ctx=c1)
6890  >>> s2 = s1.translate(c2)
6891  """
6892  if z3_debug():
6893  _z3_assert(isinstance(target, Context), "argument must be a Z3 context")
6894  solver = Z3_solver_translate(self.ctx.ref(), self.solver, target.ref())
6895  return Solver(solver, target)
6896 
6897  def __copy__(self):
6898  return self.translate(self.ctx)
6899 
6900  def __deepcopy__(self, memo={}):
6901  return self.translate(self.ctx)
6902 
6903  def sexpr(self):
6904  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
6905 
6906  >>> x = Int('x')
6907  >>> s = Solver()
6908  >>> s.add(x > 0)
6909  >>> s.add(x < 2)
6910  >>> r = s.sexpr()
6911  """
6912  return Z3_solver_to_string(self.ctx.ref(), self.solver)
6913 
6914  def dimacs(self, include_names=True):
6915  """Return a textual representation of the solver in DIMACS format."""
6916  return Z3_solver_to_dimacs_string(self.ctx.ref(), self.solver, include_names)
6917 
6918  def to_smt2(self):
6919  """return SMTLIB2 formatted benchmark for solver's assertions"""
6920  es = self.assertions()
6921  sz = len(es)
6922  sz1 = sz
6923  if sz1 > 0:
6924  sz1 -= 1
6925  v = (Ast * sz1)()
6926  for i in range(sz1):
6927  v[i] = es[i].as_ast()
6928  if sz > 0:
6929  e = es[sz1].as_ast()
6930  else:
6931  e = BoolVal(True, self.ctx).as_ast()
6932  return Z3_benchmark_to_smtlib_string(self.ctx.ref(), "benchmark generated from python API", "", "unknown", "", sz1, v, e)
6933 
6934 def SolverFor(logic, ctx=None, logFile=None):
6935  """Create a solver customized for the given logic.
6936 
6937  The parameter `logic` is a string. It should be contains
6938  the name of a SMT-LIB logic.
6939  See http://www.smtlib.org/ for the name of all available logics.
6940 
6941  >>> s = SolverFor("QF_LIA")
6942  >>> x = Int('x')
6943  >>> s.add(x > 0)
6944  >>> s.add(x < 2)
6945  >>> s.check()
6946  sat
6947  >>> s.model()
6948  [x = 1]
6949  """
6950  ctx = _get_ctx(ctx)
6951  logic = to_symbol(logic)
6952  return Solver(Z3_mk_solver_for_logic(ctx.ref(), logic), ctx, logFile)
6953 
6954 def SimpleSolver(ctx=None, logFile=None):
6955  """Return a simple general purpose solver with limited amount of preprocessing.
6956 
6957  >>> s = SimpleSolver()
6958  >>> x = Int('x')
6959  >>> s.add(x > 0)
6960  >>> s.check()
6961  sat
6962  """
6963  ctx = _get_ctx(ctx)
6964  return Solver(Z3_mk_simple_solver(ctx.ref()), ctx, logFile)
6965 
6966 
6971 
6973  """Fixedpoint API provides methods for solving with recursive predicates"""
6974 
6975  def __init__(self, fixedpoint=None, ctx=None):
6976  assert fixedpoint is None or ctx is not None
6977  self.ctx = _get_ctx(ctx)
6978  self.fixedpoint = None
6979  if fixedpoint is None:
6980  self.fixedpoint = Z3_mk_fixedpoint(self.ctx.ref())
6981  else:
6982  self.fixedpoint = fixedpoint
6983  Z3_fixedpoint_inc_ref(self.ctx.ref(), self.fixedpoint)
6984  self.vars = []
6985 
6986  def __deepcopy__(self, memo={}):
6987  return FixedPoint(self.fixedpoint, self.ctx)
6988 
6989  def __del__(self):
6990  if self.fixedpoint is not None and self.ctx.ref() is not None:
6991  Z3_fixedpoint_dec_ref(self.ctx.ref(), self.fixedpoint)
6992 
6993  def set(self, *args, **keys):
6994  """Set a configuration option. The method `help()` return a string containing all available options.
6995  """
6996  p = args2params(args, keys, self.ctx)
6997  Z3_fixedpoint_set_params(self.ctx.ref(), self.fixedpoint, p.params)
6998 
6999  def help(self):
7000  """Display a string describing all available options."""
7001  print(Z3_fixedpoint_get_help(self.ctx.ref(), self.fixedpoint))
7002 
7003  def param_descrs(self):
7004  """Return the parameter description set."""
7005  return ParamDescrsRef(Z3_fixedpoint_get_param_descrs(self.ctx.ref(), self.fixedpoint), self.ctx)
7006 
7007  def assert_exprs(self, *args):
7008  """Assert constraints as background axioms for the fixedpoint solver."""
7009  args = _get_args(args)
7010  s = BoolSort(self.ctx)
7011  for arg in args:
7012  if isinstance(arg, Goal) or isinstance(arg, AstVector):
7013  for f in arg:
7014  f = self.abstract(f)
7015  Z3_fixedpoint_assert(self.ctx.ref(), self.fixedpoint, f.as_ast())
7016  else:
7017  arg = s.cast(arg)
7018  arg = self.abstract(arg)
7019  Z3_fixedpoint_assert(self.ctx.ref(), self.fixedpoint, arg.as_ast())
7020 
7021  def add(self, *args):
7022  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7023  self.assert_exprs(*args)
7024 
7025  def __iadd__(self, fml):
7026  self.add(fml)
7027  return self
7028 
7029  def append(self, *args):
7030  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7031  self.assert_exprs(*args)
7032 
7033  def insert(self, *args):
7034  """Assert constraints as background axioms for the fixedpoint solver. Alias for assert_expr."""
7035  self.assert_exprs(*args)
7036 
7037  def add_rule(self, head, body = None, name = None):
7038  """Assert rules defining recursive predicates to the fixedpoint solver.
7039  >>> a = Bool('a')
7040  >>> b = Bool('b')
7041  >>> s = Fixedpoint()
7042  >>> s.register_relation(a.decl())
7043  >>> s.register_relation(b.decl())
7044  >>> s.fact(a)
7045  >>> s.rule(b, a)
7046  >>> s.query(b)
7047  sat
7048  """
7049  if name is None:
7050  name = ""
7051  name = to_symbol(name, self.ctx)
7052  if body is None:
7053  head = self.abstract(head)
7054  Z3_fixedpoint_add_rule(self.ctx.ref(), self.fixedpoint, head.as_ast(), name)
7055  else:
7056  body = _get_args(body)
7057  f = self.abstract(Implies(And(body, self.ctx),head))
7058  Z3_fixedpoint_add_rule(self.ctx.ref(), self.fixedpoint, f.as_ast(), name)
7059 
7060  def rule(self, head, body = None, name = None):
7061  """Assert rules defining recursive predicates to the fixedpoint solver. Alias for add_rule."""
7062  self.add_rule(head, body, name)
7063 
7064  def fact(self, head, name = None):
7065  """Assert facts defining recursive predicates to the fixedpoint solver. Alias for add_rule."""
7066  self.add_rule(head, None, name)
7067 
7068  def query(self, *query):
7069  """Query the fixedpoint engine whether formula is derivable.
7070  You can also pass an tuple or list of recursive predicates.
7071  """
7072  query = _get_args(query)
7073  sz = len(query)
7074  if sz >= 1 and isinstance(query[0], FuncDeclRef):
7075  _decls = (FuncDecl * sz)()
7076  i = 0
7077  for q in query:
7078  _decls[i] = q.ast
7079  i = i + 1
7080  r = Z3_fixedpoint_query_relations(self.ctx.ref(), self.fixedpoint, sz, _decls)
7081  else:
7082  if sz == 1:
7083  query = query[0]
7084  else:
7085  query = And(query, self.ctx)
7086  query = self.abstract(query, False)
7087  r = Z3_fixedpoint_query(self.ctx.ref(), self.fixedpoint, query.as_ast())
7088  return CheckSatResult(r)
7089 
7090  def query_from_lvl (self, lvl, *query):
7091  """Query the fixedpoint engine whether formula is derivable starting at the given query level.
7092  """
7093  query = _get_args(query)
7094  sz = len(query)
7095  if sz >= 1 and isinstance(query[0], FuncDecl):
7096  _z3_assert (False, "unsupported")
7097  else:
7098  if sz == 1:
7099  query = query[0]
7100  else:
7101  query = And(query)
7102  query = self.abstract(query, False)
7103  r = Z3_fixedpoint_query_from_lvl (self.ctx.ref(), self.fixedpoint, query.as_ast(), lvl)
7104  return CheckSatResult(r)
7105 
7106  def update_rule(self, head, body, name):
7107  """update rule"""
7108  if name is None:
7109  name = ""
7110  name = to_symbol(name, self.ctx)
7111  body = _get_args(body)
7112  f = self.abstract(Implies(And(body, self.ctx),head))
7113  Z3_fixedpoint_update_rule(self.ctx.ref(), self.fixedpoint, f.as_ast(), name)
7114 
7115  def get_answer(self):
7116  """Retrieve answer from last query call."""
7117  r = Z3_fixedpoint_get_answer(self.ctx.ref(), self.fixedpoint)
7118  return _to_expr_ref(r, self.ctx)
7119 
7121  """Retrieve a ground cex from last query call."""
7122  r = Z3_fixedpoint_get_ground_sat_answer(self.ctx.ref(), self.fixedpoint)
7123  return _to_expr_ref(r, self.ctx)
7124 
7126  """retrieve rules along the counterexample trace"""
7127  return AstVector(Z3_fixedpoint_get_rules_along_trace(self.ctx.ref(), self.fixedpoint), self.ctx)
7128 
7130  """retrieve rule names along the counterexample trace"""
7131  # this is a hack as I don't know how to return a list of symbols from C++;
7132  # obtain names as a single string separated by semicolons
7133  names = _symbol2py (self.ctx, Z3_fixedpoint_get_rule_names_along_trace(self.ctx.ref(), self.fixedpoint))
7134  # split into individual names
7135  return names.split (';')
7136 
7137  def get_num_levels(self, predicate):
7138  """Retrieve number of levels used for predicate in PDR engine"""
7139  return Z3_fixedpoint_get_num_levels(self.ctx.ref(), self.fixedpoint, predicate.ast)
7140 
7141  def get_cover_delta(self, level, predicate):
7142  """Retrieve properties known about predicate for the level'th unfolding. -1 is treated as the limit (infinity)"""
7143  r = Z3_fixedpoint_get_cover_delta(self.ctx.ref(), self.fixedpoint, level, predicate.ast)
7144  return _to_expr_ref(r, self.ctx)
7145 
7146  def add_cover(self, level, predicate, property):
7147  """Add property to predicate for the level'th unfolding. -1 is treated as infinity (infinity)"""
7148  Z3_fixedpoint_add_cover(self.ctx.ref(), self.fixedpoint, level, predicate.ast, property.ast)
7149 
7150  def register_relation(self, *relations):
7151  """Register relation as recursive"""
7152  relations = _get_args(relations)
7153  for f in relations:
7154  Z3_fixedpoint_register_relation(self.ctx.ref(), self.fixedpoint, f.ast)
7155 
7156  def set_predicate_representation(self, f, *representations):
7157  """Control how relation is represented"""
7158  representations = _get_args(representations)
7159  representations = [to_symbol(s) for s in representations]
7160  sz = len(representations)
7161  args = (Symbol * sz)()
7162  for i in range(sz):
7163  args[i] = representations[i]
7164  Z3_fixedpoint_set_predicate_representation(self.ctx.ref(), self.fixedpoint, f.ast, sz, args)
7165 
7166  def parse_string(self, s):
7167  """Parse rules and queries from a string"""
7168  return AstVector(Z3_fixedpoint_from_string(self.ctx.ref(), self.fixedpoint, s), self.ctx)
7169 
7170  def parse_file(self, f):
7171  """Parse rules and queries from a file"""
7172  return AstVector(Z3_fixedpoint_from_file(self.ctx.ref(), self.fixedpoint, f), self.ctx)
7173 
7174  def get_rules(self):
7175  """retrieve rules that have been added to fixedpoint context"""
7176  return AstVector(Z3_fixedpoint_get_rules(self.ctx.ref(), self.fixedpoint), self.ctx)
7177 
7178  def get_assertions(self):
7179  """retrieve assertions that have been added to fixedpoint context"""
7180  return AstVector(Z3_fixedpoint_get_assertions(self.ctx.ref(), self.fixedpoint), self.ctx)
7181 
7182  def __repr__(self):
7183  """Return a formatted string with all added rules and constraints."""
7184  return self.sexpr()
7185 
7186  def sexpr(self):
7187  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
7188  """
7189  return Z3_fixedpoint_to_string(self.ctx.ref(), self.fixedpoint, 0, (Ast * 0)())
7190 
7191  def to_string(self, queries):
7192  """Return a formatted string (in Lisp-like format) with all added constraints.
7193  We say the string is in s-expression format.
7194  Include also queries.
7195  """
7196  args, len = _to_ast_array(queries)
7197  return Z3_fixedpoint_to_string(self.ctx.ref(), self.fixedpoint, len, args)
7198 
7199  def statistics(self):
7200  """Return statistics for the last `query()`.
7201  """
7202  return Statistics(Z3_fixedpoint_get_statistics(self.ctx.ref(), self.fixedpoint), self.ctx)
7203 
7204  def reason_unknown(self):
7205  """Return a string describing why the last `query()` returned `unknown`.
7206  """
7207  return Z3_fixedpoint_get_reason_unknown(self.ctx.ref(), self.fixedpoint)
7208 
7209  def declare_var(self, *vars):
7210  """Add variable or several variables.
7211  The added variable or variables will be bound in the rules
7212  and queries
7213  """
7214  vars = _get_args(vars)
7215  for v in vars:
7216  self.vars += [v]
7217 
7218  def abstract(self, fml, is_forall=True):
7219  if self.vars == []:
7220  return fml
7221  if is_forall:
7222  return ForAll(self.vars, fml)
7223  else:
7224  return Exists(self.vars, fml)
7225 
7226 
7227 
7232 
7234  """Finite domain sort."""
7235 
7236  def size(self):
7237  """Return the size of the finite domain sort"""
7238  r = (ctypes.c_ulonglong * 1)()
7239  if Z3_get_finite_domain_sort_size(self.ctx_ref(), self.ast, r):
7240  return r[0]
7241  else:
7242  raise Z3Exception("Failed to retrieve finite domain sort size")
7243 
7244 def FiniteDomainSort(name, sz, ctx=None):
7245  """Create a named finite domain sort of a given size sz"""
7246  if not isinstance(name, Symbol):
7247  name = to_symbol(name)
7248  ctx = _get_ctx(ctx)
7249  return FiniteDomainSortRef(Z3_mk_finite_domain_sort(ctx.ref(), name, sz), ctx)
7250 
7252  """Return True if `s` is a Z3 finite-domain sort.
7253 
7254  >>> is_finite_domain_sort(FiniteDomainSort('S', 100))
7255  True
7256  >>> is_finite_domain_sort(IntSort())
7257  False
7258  """
7259  return isinstance(s, FiniteDomainSortRef)
7260 
7261 
7263  """Finite-domain expressions."""
7264 
7265  def sort(self):
7266  """Return the sort of the finite-domain expression `self`."""
7267  return FiniteDomainSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
7268 
7269  def as_string(self):
7270  """Return a Z3 floating point expression as a Python string."""
7271  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
7272 
7274  """Return `True` if `a` is a Z3 finite-domain expression.
7275 
7276  >>> s = FiniteDomainSort('S', 100)
7277  >>> b = Const('b', s)
7278  >>> is_finite_domain(b)
7279  True
7280  >>> is_finite_domain(Int('x'))
7281  False
7282  """
7283  return isinstance(a, FiniteDomainRef)
7284 
7285 
7287  """Integer values."""
7288 
7289  def as_long(self):
7290  """Return a Z3 finite-domain numeral as a Python long (bignum) numeral.
7291 
7292  >>> s = FiniteDomainSort('S', 100)
7293  >>> v = FiniteDomainVal(3, s)
7294  >>> v
7295  3
7296  >>> v.as_long() + 1
7297  4
7298  """
7299  return int(self.as_string())
7300 
7301  def as_string(self):
7302  """Return a Z3 finite-domain numeral as a Python string.
7303 
7304  >>> s = FiniteDomainSort('S', 100)
7305  >>> v = FiniteDomainVal(42, s)
7306  >>> v.as_string()
7307  '42'
7308  """
7309  return Z3_get_numeral_string(self.ctx_ref(), self.as_ast())
7310 
7311 
7312 def FiniteDomainVal(val, sort, ctx=None):
7313  """Return a Z3 finite-domain value. If `ctx=None`, then the global context is used.
7314 
7315  >>> s = FiniteDomainSort('S', 256)
7316  >>> FiniteDomainVal(255, s)
7317  255
7318  >>> FiniteDomainVal('100', s)
7319  100
7320  """
7321  if z3_debug():
7322  _z3_assert(is_finite_domain_sort(sort), "Expected finite-domain sort" )
7323  ctx = sort.ctx
7324  return FiniteDomainNumRef(Z3_mk_numeral(ctx.ref(), _to_int_str(val), sort.ast), ctx)
7325 
7327  """Return `True` if `a` is a Z3 finite-domain value.
7328 
7329  >>> s = FiniteDomainSort('S', 100)
7330  >>> b = Const('b', s)
7331  >>> is_finite_domain_value(b)
7332  False
7333  >>> b = FiniteDomainVal(10, s)
7334  >>> b
7335  10
7336  >>> is_finite_domain_value(b)
7337  True
7338  """
7339  return is_finite_domain(a) and _is_numeral(a.ctx, a.as_ast())
7340 
7341 
7342 
7347 
7349  def __init__(self, opt, value, is_max):
7350  self._opt = opt
7351  self._value = value
7352  self._is_max = is_max
7353 
7354  def lower(self):
7355  opt = self._opt
7356  return _to_expr_ref(Z3_optimize_get_lower(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7357 
7358  def upper(self):
7359  opt = self._opt
7360  return _to_expr_ref(Z3_optimize_get_upper(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7361 
7362  def lower_values(self):
7363  opt = self._opt
7364  return AstVector(Z3_optimize_get_lower_as_vector(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7365 
7366  def upper_values(self):
7367  opt = self._opt
7368  return AstVector(Z3_optimize_get_upper_as_vector(opt.ctx.ref(), opt.optimize, self._value), opt.ctx)
7369 
7370  def value(self):
7371  if self._is_max:
7372  return self.upper()
7373  else:
7374  return self.lower()
7375 
7376  def __str__(self):
7377  return "%s:%s" % (self._value, self._is_max)
7378 
7379 
7381  """Optimize API provides methods for solving using objective functions and weighted soft constraints"""
7382 
7383  def __init__(self, ctx=None):
7384  self.ctx = _get_ctx(ctx)
7385  self.optimize = Z3_mk_optimize(self.ctx.ref())
7386  Z3_optimize_inc_ref(self.ctx.ref(), self.optimize)
7387 
7388  def __deepcopy__(self, memo={}):
7389  return Optimize(self.optimize, self.ctx)
7390 
7391  def __del__(self):
7392  if self.optimize is not None and self.ctx.ref() is not None:
7393  Z3_optimize_dec_ref(self.ctx.ref(), self.optimize)
7394 
7395  def set(self, *args, **keys):
7396  """Set a configuration option. The method `help()` return a string containing all available options.
7397  """
7398  p = args2params(args, keys, self.ctx)
7399  Z3_optimize_set_params(self.ctx.ref(), self.optimize, p.params)
7400 
7401  def help(self):
7402  """Display a string describing all available options."""
7403  print(Z3_optimize_get_help(self.ctx.ref(), self.optimize))
7404 
7405  def param_descrs(self):
7406  """Return the parameter description set."""
7407  return ParamDescrsRef(Z3_optimize_get_param_descrs(self.ctx.ref(), self.optimize), self.ctx)
7408 
7409  def assert_exprs(self, *args):
7410  """Assert constraints as background axioms for the optimize solver."""
7411  args = _get_args(args)
7412  s = BoolSort(self.ctx)
7413  for arg in args:
7414  if isinstance(arg, Goal) or isinstance(arg, AstVector):
7415  for f in arg:
7416  Z3_optimize_assert(self.ctx.ref(), self.optimize, f.as_ast())
7417  else:
7418  arg = s.cast(arg)
7419  Z3_optimize_assert(self.ctx.ref(), self.optimize, arg.as_ast())
7420 
7421  def add(self, *args):
7422  """Assert constraints as background axioms for the optimize solver. Alias for assert_expr."""
7423  self.assert_exprs(*args)
7424 
7425  def __iadd__(self, fml):
7426  self.add(fml)
7427  return self
7428 
7429  def assert_and_track(self, a, p):
7430  """Assert constraint `a` and track it in the unsat core using the Boolean constant `p`.
7431 
7432  If `p` is a string, it will be automatically converted into a Boolean constant.
7433 
7434  >>> x = Int('x')
7435  >>> p3 = Bool('p3')
7436  >>> s = Optimize()
7437  >>> s.assert_and_track(x > 0, 'p1')
7438  >>> s.assert_and_track(x != 1, 'p2')
7439  >>> s.assert_and_track(x < 0, p3)
7440  >>> print(s.check())
7441  unsat
7442  >>> c = s.unsat_core()
7443  >>> len(c)
7444  2
7445  >>> Bool('p1') in c
7446  True
7447  >>> Bool('p2') in c
7448  False
7449  >>> p3 in c
7450  True
7451  """
7452  if isinstance(p, str):
7453  p = Bool(p, self.ctx)
7454  _z3_assert(isinstance(a, BoolRef), "Boolean expression expected")
7455  _z3_assert(isinstance(p, BoolRef) and is_const(p), "Boolean expression expected")
7456  Z3_optimize_assert_and_track(self.ctx.ref(), self.optimize, a.as_ast(), p.as_ast())
7457 
7458  def add_soft(self, arg, weight = "1", id = None):
7459  """Add soft constraint with optional weight and optional identifier.
7460  If no weight is supplied, then the penalty for violating the soft constraint
7461  is 1.
7462  Soft constraints are grouped by identifiers. Soft constraints that are
7463  added without identifiers are grouped by default.
7464  """
7465  if _is_int(weight):
7466  weight = "%d" % weight
7467  elif isinstance(weight, float):
7468  weight = "%f" % weight
7469  if not isinstance(weight, str):
7470  raise Z3Exception("weight should be a string or an integer")
7471  if id is None:
7472  id = ""
7473  id = to_symbol(id, self.ctx)
7474  v = Z3_optimize_assert_soft(self.ctx.ref(), self.optimize, arg.as_ast(), weight, id)
7475  return OptimizeObjective(self, v, False)
7476 
7477  def maximize(self, arg):
7478  """Add objective function to maximize."""
7479  return OptimizeObjective(self, Z3_optimize_maximize(self.ctx.ref(), self.optimize, arg.as_ast()), True)
7480 
7481  def minimize(self, arg):
7482  """Add objective function to minimize."""
7483  return OptimizeObjective(self, Z3_optimize_minimize(self.ctx.ref(), self.optimize, arg.as_ast()), False)
7484 
7485  def push(self):
7486  """create a backtracking point for added rules, facts and assertions"""
7487  Z3_optimize_push(self.ctx.ref(), self.optimize)
7488 
7489  def pop(self):
7490  """restore to previously created backtracking point"""
7491  Z3_optimize_pop(self.ctx.ref(), self.optimize)
7492 
7493  def check(self, *assumptions):
7494  """Check satisfiability while optimizing objective functions."""
7495  assumptions = _get_args(assumptions)
7496  num = len(assumptions)
7497  _assumptions = (Ast * num)()
7498  for i in range(num):
7499  _assumptions[i] = assumptions[i].as_ast()
7500  return CheckSatResult(Z3_optimize_check(self.ctx.ref(), self.optimize, num, _assumptions))
7501 
7502  def reason_unknown(self):
7503  """Return a string that describes why the last `check()` returned `unknown`."""
7504  return Z3_optimize_get_reason_unknown(self.ctx.ref(), self.optimize)
7505 
7506  def model(self):
7507  """Return a model for the last check()."""
7508  try:
7509  return ModelRef(Z3_optimize_get_model(self.ctx.ref(), self.optimize), self.ctx)
7510  except Z3Exception:
7511  raise Z3Exception("model is not available")
7512 
7513  def unsat_core(self):
7514  return AstVector(Z3_optimize_get_unsat_core(self.ctx.ref(), self.optimize), self.ctx)
7515 
7516  def lower(self, obj):
7517  if not isinstance(obj, OptimizeObjective):
7518  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7519  return obj.lower()
7520 
7521  def upper(self, obj):
7522  if not isinstance(obj, OptimizeObjective):
7523  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7524  return obj.upper()
7525 
7526  def lower_values(self, obj):
7527  if not isinstance(obj, OptimizeObjective):
7528  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7529  return obj.lower_values()
7530 
7531  def upper_values(self, obj):
7532  if not isinstance(obj, OptimizeObjective):
7533  raise Z3Exception("Expecting objective handle returned by maximize/minimize")
7534  return obj.upper_values()
7535 
7536  def from_file(self, filename):
7537  """Parse assertions and objectives from a file"""
7538  Z3_optimize_from_file(self.ctx.ref(), self.optimize, filename)
7539 
7540  def from_string(self, s):
7541  """Parse assertions and objectives from a string"""
7542  Z3_optimize_from_string(self.ctx.ref(), self.optimize, s)
7543 
7544  def assertions(self):
7545  """Return an AST vector containing all added constraints."""
7546  return AstVector(Z3_optimize_get_assertions(self.ctx.ref(), self.optimize), self.ctx)
7547 
7548  def objectives(self):
7549  """returns set of objective functions"""
7550  return AstVector(Z3_optimize_get_objectives(self.ctx.ref(), self.optimize), self.ctx)
7551 
7552  def __repr__(self):
7553  """Return a formatted string with all added rules and constraints."""
7554  return self.sexpr()
7555 
7556  def sexpr(self):
7557  """Return a formatted string (in Lisp-like format) with all added constraints. We say the string is in s-expression format.
7558  """
7559  return Z3_optimize_to_string(self.ctx.ref(), self.optimize)
7560 
7561  def statistics(self):
7562  """Return statistics for the last check`.
7563  """
7564  return Statistics(Z3_optimize_get_statistics(self.ctx.ref(), self.optimize), self.ctx)
7565 
7566 
7567 
7568 
7569 
7575  """An ApplyResult object contains the subgoals produced by a tactic when applied to a goal. It also contains model and proof converters."""
7576 
7577  def __init__(self, result, ctx):
7578  self.result = result
7579  self.ctx = ctx
7580  Z3_apply_result_inc_ref(self.ctx.ref(), self.result)
7581 
7582  def __deepcopy__(self, memo={}):
7583  return ApplyResult(self.result, self.ctx)
7584 
7585  def __del__(self):
7586  if self.ctx.ref() is not None:
7587  Z3_apply_result_dec_ref(self.ctx.ref(), self.result)
7588 
7589  def __len__(self):
7590  """Return the number of subgoals in `self`.
7591 
7592  >>> a, b = Ints('a b')
7593  >>> g = Goal()
7594  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
7595  >>> t = Tactic('split-clause')
7596  >>> r = t(g)
7597  >>> len(r)
7598  2
7599  >>> t = Then(Tactic('split-clause'), Tactic('split-clause'))
7600  >>> len(t(g))
7601  4
7602  >>> t = Then(Tactic('split-clause'), Tactic('split-clause'), Tactic('propagate-values'))
7603  >>> len(t(g))
7604  1
7605  """
7606  return int(Z3_apply_result_get_num_subgoals(self.ctx.ref(), self.result))
7607 
7608  def __getitem__(self, idx):
7609  """Return one of the subgoals stored in ApplyResult object `self`.
7610 
7611  >>> a, b = Ints('a b')
7612  >>> g = Goal()
7613  >>> g.add(Or(a == 0, a == 1), Or(b == 0, b == 1), a > b)
7614  >>> t = Tactic('split-clause')
7615  >>> r = t(g)
7616  >>> r[0]
7617  [a == 0, Or(b == 0, b == 1), a > b]
7618  >>> r[1]
7619  [a == 1, Or(b == 0, b == 1), a > b]
7620  """
7621  if idx >= len(self):
7622  raise IndexError
7623  return Goal(goal=Z3_apply_result_get_subgoal(self.ctx.ref(), self.result, idx), ctx=self.ctx)
7624 
7625  def __repr__(self):
7626  return obj_to_string(self)
7627 
7628  def sexpr(self):
7629  """Return a textual representation of the s-expression representing the set of subgoals in `self`."""
7630  return Z3_apply_result_to_string(self.ctx.ref(), self.result)
7631 
7632 
7633  def as_expr(self):
7634  """Return a Z3 expression consisting of all subgoals.
7635 
7636  >>> x = Int('x')
7637  >>> g = Goal()
7638  >>> g.add(x > 1)
7639  >>> g.add(Or(x == 2, x == 3))
7640  >>> r = Tactic('simplify')(g)
7641  >>> r
7642  [[Not(x <= 1), Or(x == 2, x == 3)]]
7643  >>> r.as_expr()
7644  And(Not(x <= 1), Or(x == 2, x == 3))
7645  >>> r = Tactic('split-clause')(g)
7646  >>> r
7647  [[x > 1, x == 2], [x > 1, x == 3]]
7648  >>> r.as_expr()
7649  Or(And(x > 1, x == 2), And(x > 1, x == 3))
7650  """
7651  sz = len(self)
7652  if sz == 0:
7653  return BoolVal(False, self.ctx)
7654  elif sz == 1:
7655  return self[0].as_expr()
7656  else:
7657  return Or([ self[i].as_expr() for i in range(len(self)) ])
7658 
7659 
7664 class Tactic:
7665  """Tactics transform, solver and/or simplify sets of constraints (Goal). A Tactic can be converted into a Solver using the method solver().
7666 
7667  Several combinators are available for creating new tactics using the built-in ones: Then(), OrElse(), FailIf(), Repeat(), When(), Cond().
7668  """
7669  def __init__(self, tactic, ctx=None):
7670  self.ctx = _get_ctx(ctx)
7671  self.tactic = None
7672  if isinstance(tactic, TacticObj):
7673  self.tactic = tactic
7674  else:
7675  if z3_debug():
7676  _z3_assert(isinstance(tactic, str), "tactic name expected")
7677  try:
7678  self.tactic = Z3_mk_tactic(self.ctx.ref(), str(tactic))
7679  except Z3Exception:
7680  raise Z3Exception("unknown tactic '%s'" % tactic)
7681  Z3_tactic_inc_ref(self.ctx.ref(), self.tactic)
7682 
7683  def __deepcopy__(self, memo={}):
7684  return Tactic(self.tactic, self.ctx)
7685 
7686  def __del__(self):
7687  if self.tactic is not None and self.ctx.ref() is not None:
7688  Z3_tactic_dec_ref(self.ctx.ref(), self.tactic)
7689 
7690  def solver(self, logFile=None):
7691  """Create a solver using the tactic `self`.
7692 
7693  The solver supports the methods `push()` and `pop()`, but it
7694  will always solve each `check()` from scratch.
7695 
7696  >>> t = Then('simplify', 'nlsat')
7697  >>> s = t.solver()
7698  >>> x = Real('x')
7699  >>> s.add(x**2 == 2, x > 0)
7700  >>> s.check()
7701  sat
7702  >>> s.model()
7703  [x = 1.4142135623?]
7704  """
7705  return Solver(Z3_mk_solver_from_tactic(self.ctx.ref(), self.tactic), self.ctx, logFile)
7706 
7707  def apply(self, goal, *arguments, **keywords):
7708  """Apply tactic `self` to the given goal or Z3 Boolean expression using the given options.
7709 
7710  >>> x, y = Ints('x y')
7711  >>> t = Tactic('solve-eqs')
7712  >>> t.apply(And(x == 0, y >= x + 1))
7713  [[y >= 1]]
7714  """
7715  if z3_debug():
7716  _z3_assert(isinstance(goal, Goal) or isinstance(goal, BoolRef), "Z3 Goal or Boolean expressions expected")
7717  goal = _to_goal(goal)
7718  if len(arguments) > 0 or len(keywords) > 0:
7719  p = args2params(arguments, keywords, self.ctx)
7720  return ApplyResult(Z3_tactic_apply_ex(self.ctx.ref(), self.tactic, goal.goal, p.params), self.ctx)
7721  else:
7722  return ApplyResult(Z3_tactic_apply(self.ctx.ref(), self.tactic, goal.goal), self.ctx)
7723 
7724  def __call__(self, goal, *arguments, **keywords):
7725  """Apply tactic `self` to the given goal or Z3 Boolean expression using the given options.
7726 
7727  >>> x, y = Ints('x y')
7728  >>> t = Tactic('solve-eqs')
7729  >>> t(And(x == 0, y >= x + 1))
7730  [[y >= 1]]
7731  """
7732  return self.apply(goal, *arguments, **keywords)
7733 
7734  def help(self):
7735  """Display a string containing a description of the available options for the `self` tactic."""
7736  print(Z3_tactic_get_help(self.ctx.ref(), self.tactic))
7737 
7738  def param_descrs(self):
7739  """Return the parameter description set."""
7740  return ParamDescrsRef(Z3_tactic_get_param_descrs(self.ctx.ref(), self.tactic), self.ctx)
7741 
7742 def _to_goal(a):
7743  if isinstance(a, BoolRef):
7744  goal = Goal(ctx = a.ctx)
7745  goal.add(a)
7746  return goal
7747  else:
7748  return a
7749 
7750 def _to_tactic(t, ctx=None):
7751  if isinstance(t, Tactic):
7752  return t
7753  else:
7754  return Tactic(t, ctx)
7755 
7756 def _and_then(t1, t2, ctx=None):
7757  t1 = _to_tactic(t1, ctx)
7758  t2 = _to_tactic(t2, ctx)
7759  if z3_debug():
7760  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7761  return Tactic(Z3_tactic_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7762 
7763 def _or_else(t1, t2, ctx=None):
7764  t1 = _to_tactic(t1, ctx)
7765  t2 = _to_tactic(t2, ctx)
7766  if z3_debug():
7767  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7768  return Tactic(Z3_tactic_or_else(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7769 
7770 def AndThen(*ts, **ks):
7771  """Return a tactic that applies the tactics in `*ts` in sequence.
7772 
7773  >>> x, y = Ints('x y')
7774  >>> t = AndThen(Tactic('simplify'), Tactic('solve-eqs'))
7775  >>> t(And(x == 0, y > x + 1))
7776  [[Not(y <= 1)]]
7777  >>> t(And(x == 0, y > x + 1)).as_expr()
7778  Not(y <= 1)
7779  """
7780  if z3_debug():
7781  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7782  ctx = ks.get('ctx', None)
7783  num = len(ts)
7784  r = ts[0]
7785  for i in range(num - 1):
7786  r = _and_then(r, ts[i+1], ctx)
7787  return r
7788 
7789 def Then(*ts, **ks):
7790  """Return a tactic that applies the tactics in `*ts` in sequence. Shorthand for AndThen(*ts, **ks).
7791 
7792  >>> x, y = Ints('x y')
7793  >>> t = Then(Tactic('simplify'), Tactic('solve-eqs'))
7794  >>> t(And(x == 0, y > x + 1))
7795  [[Not(y <= 1)]]
7796  >>> t(And(x == 0, y > x + 1)).as_expr()
7797  Not(y <= 1)
7798  """
7799  return AndThen(*ts, **ks)
7800 
7801 def OrElse(*ts, **ks):
7802  """Return a tactic that applies the tactics in `*ts` until one of them succeeds (it doesn't fail).
7803 
7804  >>> x = Int('x')
7805  >>> t = OrElse(Tactic('split-clause'), Tactic('skip'))
7806  >>> # Tactic split-clause fails if there is no clause in the given goal.
7807  >>> t(x == 0)
7808  [[x == 0]]
7809  >>> t(Or(x == 0, x == 1))
7810  [[x == 0], [x == 1]]
7811  """
7812  if z3_debug():
7813  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7814  ctx = ks.get('ctx', None)
7815  num = len(ts)
7816  r = ts[0]
7817  for i in range(num - 1):
7818  r = _or_else(r, ts[i+1], ctx)
7819  return r
7820 
7821 def ParOr(*ts, **ks):
7822  """Return a tactic that applies the tactics in `*ts` in parallel until one of them succeeds (it doesn't fail).
7823 
7824  >>> x = Int('x')
7825  >>> t = ParOr(Tactic('simplify'), Tactic('fail'))
7826  >>> t(x + 1 == 2)
7827  [[x == 1]]
7828  """
7829  if z3_debug():
7830  _z3_assert(len(ts) >= 2, "At least two arguments expected")
7831  ctx = _get_ctx(ks.get('ctx', None))
7832  ts = [ _to_tactic(t, ctx) for t in ts ]
7833  sz = len(ts)
7834  _args = (TacticObj * sz)()
7835  for i in range(sz):
7836  _args[i] = ts[i].tactic
7837  return Tactic(Z3_tactic_par_or(ctx.ref(), sz, _args), ctx)
7838 
7839 def ParThen(t1, t2, ctx=None):
7840  """Return a tactic that applies t1 and then t2 to every subgoal produced by t1. The subgoals are processed in parallel.
7841 
7842  >>> x, y = Ints('x y')
7843  >>> t = ParThen(Tactic('split-clause'), Tactic('propagate-values'))
7844  >>> t(And(Or(x == 1, x == 2), y == x + 1))
7845  [[x == 1, y == 2], [x == 2, y == 3]]
7846  """
7847  t1 = _to_tactic(t1, ctx)
7848  t2 = _to_tactic(t2, ctx)
7849  if z3_debug():
7850  _z3_assert(t1.ctx == t2.ctx, "Context mismatch")
7851  return Tactic(Z3_tactic_par_and_then(t1.ctx.ref(), t1.tactic, t2.tactic), t1.ctx)
7852 
7853 def ParAndThen(t1, t2, ctx=None):
7854  """Alias for ParThen(t1, t2, ctx)."""
7855  return ParThen(t1, t2, ctx)
7856 
7857 def With(t, *args, **keys):
7858  """Return a tactic that applies tactic `t` using the given configuration options.
7859 
7860  >>> x, y = Ints('x y')
7861  >>> t = With(Tactic('simplify'), som=True)
7862  >>> t((x + 1)*(y + 2) == 0)
7863  [[2*x + y + x*y == -2]]
7864  """
7865  ctx = keys.pop('ctx', None)
7866  t = _to_tactic(t, ctx)
7867  p = args2params(args, keys, t.ctx)
7868  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7869 
7870 def WithParams(t, p):
7871  """Return a tactic that applies tactic `t` using the given configuration options.
7872 
7873  >>> x, y = Ints('x y')
7874  >>> p = ParamsRef()
7875  >>> p.set("som", True)
7876  >>> t = WithParams(Tactic('simplify'), p)
7877  >>> t((x + 1)*(y + 2) == 0)
7878  [[2*x + y + x*y == -2]]
7879  """
7880  t = _to_tactic(t, None)
7881  return Tactic(Z3_tactic_using_params(t.ctx.ref(), t.tactic, p.params), t.ctx)
7882 
7883 def Repeat(t, max=4294967295, ctx=None):
7884  """Return a tactic that keeps applying `t` until the goal is not modified anymore or the maximum number of iterations `max` is reached.
7885 
7886  >>> x, y = Ints('x y')
7887  >>> c = And(Or(x == 0, x == 1), Or(y == 0, y == 1), x > y)
7888  >>> t = Repeat(OrElse(Tactic('split-clause'), Tactic('skip')))
7889  >>> r = t(c)
7890  >>> for subgoal in r: print(subgoal)
7891  [x == 0, y == 0, x > y]
7892  [x == 0, y == 1, x > y]
7893  [x == 1, y == 0, x > y]
7894  [x == 1, y == 1, x > y]
7895  >>> t = Then(t, Tactic('propagate-values'))
7896  >>> t(c)
7897  [[x == 1, y == 0]]
7898  """
7899  t = _to_tactic(t, ctx)
7900  return Tactic(Z3_tactic_repeat(t.ctx.ref(), t.tactic, max), t.ctx)
7901 
7902 def TryFor(t, ms, ctx=None):
7903  """Return a tactic that applies `t` to a given goal for `ms` milliseconds.
7904 
7905  If `t` does not terminate in `ms` milliseconds, then it fails.
7906  """
7907  t = _to_tactic(t, ctx)
7908  return Tactic(Z3_tactic_try_for(t.ctx.ref(), t.tactic, ms), t.ctx)
7909 
7910 def tactics(ctx=None):
7911  """Return a list of all available tactics in Z3.
7912 
7913  >>> l = tactics()
7914  >>> l.count('simplify') == 1
7915  True
7916  """
7917  ctx = _get_ctx(ctx)
7918  return [ Z3_get_tactic_name(ctx.ref(), i) for i in range(Z3_get_num_tactics(ctx.ref())) ]
7919 
7920 def tactic_description(name, ctx=None):
7921  """Return a short description for the tactic named `name`.
7922 
7923  >>> d = tactic_description('simplify')
7924  """
7925  ctx = _get_ctx(ctx)
7926  return Z3_tactic_get_descr(ctx.ref(), name)
7927 
7929  """Display a (tabular) description of all available tactics in Z3."""
7930  if in_html_mode():
7931  even = True
7932  print('<table border="1" cellpadding="2" cellspacing="0">')
7933  for t in tactics():
7934  if even:
7935  print('<tr style="background-color:#CFCFCF">')
7936  even = False
7937  else:
7938  print('<tr>')
7939  even = True
7940  print('<td>%s</td><td>%s</td></tr>' % (t, insert_line_breaks(tactic_description(t), 40)))
7941  print('</table>')
7942  else:
7943  for t in tactics():
7944  print('%s : %s' % (t, tactic_description(t)))
7945 
7946 class Probe:
7947  """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."""
7948  def __init__(self, probe, ctx=None):
7949  self.ctx = _get_ctx(ctx)
7950  self.probe = None
7951  if isinstance(probe, ProbeObj):
7952  self.probe = probe
7953  elif isinstance(probe, float):
7954  self.probe = Z3_probe_const(self.ctx.ref(), probe)
7955  elif _is_int(probe):
7956  self.probe = Z3_probe_const(self.ctx.ref(), float(probe))
7957  elif isinstance(probe, bool):
7958  if probe:
7959  self.probe = Z3_probe_const(self.ctx.ref(), 1.0)
7960  else:
7961  self.probe = Z3_probe_const(self.ctx.ref(), 0.0)
7962  else:
7963  if z3_debug():
7964  _z3_assert(isinstance(probe, str), "probe name expected")
7965  try:
7966  self.probe = Z3_mk_probe(self.ctx.ref(), probe)
7967  except Z3Exception:
7968  raise Z3Exception("unknown probe '%s'" % probe)
7969  Z3_probe_inc_ref(self.ctx.ref(), self.probe)
7970 
7971  def __deepcopy__(self, memo={}):
7972  return Probe(self.probe, self.ctx)
7973 
7974  def __del__(self):
7975  if self.probe is not None and self.ctx.ref() is not None:
7976  Z3_probe_dec_ref(self.ctx.ref(), self.probe)
7977 
7978  def __lt__(self, other):
7979  """Return a probe that evaluates to "true" when the value returned by `self` is less than the value returned by `other`.
7980 
7981  >>> p = Probe('size') < 10
7982  >>> x = Int('x')
7983  >>> g = Goal()
7984  >>> g.add(x > 0)
7985  >>> g.add(x < 10)
7986  >>> p(g)
7987  1.0
7988  """
7989  return Probe(Z3_probe_lt(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
7990 
7991  def __gt__(self, other):
7992  """Return a probe that evaluates to "true" when the value returned by `self` is greater than the value returned by `other`.
7993 
7994  >>> p = Probe('size') > 10
7995  >>> x = Int('x')
7996  >>> g = Goal()
7997  >>> g.add(x > 0)
7998  >>> g.add(x < 10)
7999  >>> p(g)
8000  0.0
8001  """
8002  return Probe(Z3_probe_gt(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8003 
8004  def __le__(self, other):
8005  """Return a probe that evaluates to "true" when the value returned by `self` is less than or equal to the value returned by `other`.
8006 
8007  >>> p = Probe('size') <= 2
8008  >>> x = Int('x')
8009  >>> g = Goal()
8010  >>> g.add(x > 0)
8011  >>> g.add(x < 10)
8012  >>> p(g)
8013  1.0
8014  """
8015  return Probe(Z3_probe_le(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8016 
8017  def __ge__(self, other):
8018  """Return a probe that evaluates to "true" when the value returned by `self` is greater than or equal to the value returned by `other`.
8019 
8020  >>> p = Probe('size') >= 2
8021  >>> x = Int('x')
8022  >>> g = Goal()
8023  >>> g.add(x > 0)
8024  >>> g.add(x < 10)
8025  >>> p(g)
8026  1.0
8027  """
8028  return Probe(Z3_probe_ge(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8029 
8030  def __eq__(self, other):
8031  """Return a probe that evaluates to "true" when the value returned by `self` is equal to the value returned by `other`.
8032 
8033  >>> p = Probe('size') == 2
8034  >>> x = Int('x')
8035  >>> g = Goal()
8036  >>> g.add(x > 0)
8037  >>> g.add(x < 10)
8038  >>> p(g)
8039  1.0
8040  """
8041  return Probe(Z3_probe_eq(self.ctx.ref(), self.probe, _to_probe(other, self.ctx).probe), self.ctx)
8042 
8043  def __ne__(self, other):
8044  """Return a probe that evaluates to "true" when the value returned by `self` is not equal to the value returned by `other`.
8045 
8046  >>> p = Probe('size') != 2
8047  >>> x = Int('x')
8048  >>> g = Goal()
8049  >>> g.add(x > 0)
8050  >>> g.add(x < 10)
8051  >>> p(g)
8052  0.0
8053  """
8054  p = self.__eq__(other)
8055  return Probe(Z3_probe_not(self.ctx.ref(), p.probe), self.ctx)
8056 
8057  def __call__(self, goal):
8058  """Evaluate the probe `self` in the given goal.
8059 
8060  >>> p = Probe('size')
8061  >>> x = Int('x')
8062  >>> g = Goal()
8063  >>> g.add(x > 0)
8064  >>> g.add(x < 10)
8065  >>> p(g)
8066  2.0
8067  >>> g.add(x < 20)
8068  >>> p(g)
8069  3.0
8070  >>> p = Probe('num-consts')
8071  >>> p(g)
8072  1.0
8073  >>> p = Probe('is-propositional')
8074  >>> p(g)
8075  0.0
8076  >>> p = Probe('is-qflia')
8077  >>> p(g)
8078  1.0
8079  """
8080  if z3_debug():
8081  _z3_assert(isinstance(goal, Goal) or isinstance(goal, BoolRef), "Z3 Goal or Boolean expression expected")
8082  goal = _to_goal(goal)
8083  return Z3_probe_apply(self.ctx.ref(), self.probe, goal.goal)
8084 
8085 def is_probe(p):
8086  """Return `True` if `p` is a Z3 probe.
8087 
8088  >>> is_probe(Int('x'))
8089  False
8090  >>> is_probe(Probe('memory'))
8091  True
8092  """
8093  return isinstance(p, Probe)
8094 
8095 def _to_probe(p, ctx=None):
8096  if is_probe(p):
8097  return p
8098  else:
8099  return Probe(p, ctx)
8100 
8101 def probes(ctx=None):
8102  """Return a list of all available probes in Z3.
8103 
8104  >>> l = probes()
8105  >>> l.count('memory') == 1
8106  True
8107  """
8108  ctx = _get_ctx(ctx)
8109  return [ Z3_get_probe_name(ctx.ref(), i) for i in range(Z3_get_num_probes(ctx.ref())) ]
8110 
8111 def probe_description(name, ctx=None):
8112  """Return a short description for the probe named `name`.
8113 
8114  >>> d = probe_description('memory')
8115  """
8116  ctx = _get_ctx(ctx)
8117  return Z3_probe_get_descr(ctx.ref(), name)
8118 
8120  """Display a (tabular) description of all available probes in Z3."""
8121  if in_html_mode():
8122  even = True
8123  print('<table border="1" cellpadding="2" cellspacing="0">')
8124  for p in probes():
8125  if even:
8126  print('<tr style="background-color:#CFCFCF">')
8127  even = False
8128  else:
8129  print('<tr>')
8130  even = True
8131  print('<td>%s</td><td>%s</td></tr>' % (p, insert_line_breaks(probe_description(p), 40)))
8132  print('</table>')
8133  else:
8134  for p in probes():
8135  print('%s : %s' % (p, probe_description(p)))
8136 
8137 def _probe_nary(f, args, ctx):
8138  if z3_debug():
8139  _z3_assert(len(args) > 0, "At least one argument expected")
8140  num = len(args)
8141  r = _to_probe(args[0], ctx)
8142  for i in range(num - 1):
8143  r = Probe(f(ctx.ref(), r.probe, _to_probe(args[i+1], ctx).probe), ctx)
8144  return r
8145 
8146 def _probe_and(args, ctx):
8147  return _probe_nary(Z3_probe_and, args, ctx)
8148 
8149 def _probe_or(args, ctx):
8150  return _probe_nary(Z3_probe_or, args, ctx)
8151 
8152 def FailIf(p, ctx=None):
8153  """Return a tactic that fails if the probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8154 
8155  In the following example, the tactic applies 'simplify' if and only if there are more than 2 constraints in the goal.
8156 
8157  >>> t = OrElse(FailIf(Probe('size') > 2), Tactic('simplify'))
8158  >>> x, y = Ints('x y')
8159  >>> g = Goal()
8160  >>> g.add(x > 0)
8161  >>> g.add(y > 0)
8162  >>> t(g)
8163  [[x > 0, y > 0]]
8164  >>> g.add(x == y + 1)
8165  >>> t(g)
8166  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8167  """
8168  p = _to_probe(p, ctx)
8169  return Tactic(Z3_tactic_fail_if(p.ctx.ref(), p.probe), p.ctx)
8170 
8171 def When(p, t, ctx=None):
8172  """Return a tactic that applies tactic `t` only if probe `p` evaluates to true. Otherwise, it returns the input goal unmodified.
8173 
8174  >>> t = When(Probe('size') > 2, Tactic('simplify'))
8175  >>> x, y = Ints('x y')
8176  >>> g = Goal()
8177  >>> g.add(x > 0)
8178  >>> g.add(y > 0)
8179  >>> t(g)
8180  [[x > 0, y > 0]]
8181  >>> g.add(x == y + 1)
8182  >>> t(g)
8183  [[Not(x <= 0), Not(y <= 0), x == 1 + y]]
8184  """
8185  p = _to_probe(p, ctx)
8186  t = _to_tactic(t, ctx)
8187  return Tactic(Z3_tactic_when(t.ctx.ref(), p.probe, t.tactic), t.ctx)
8188 
8189 def Cond(p, t1, t2, ctx=None):
8190  """Return a tactic that applies tactic `t1` to a goal if probe `p` evaluates to true, and `t2` otherwise.
8191 
8192  >>> t = Cond(Probe('is-qfnra'), Tactic('qfnra'), Tactic('smt'))
8193  """
8194  p = _to_probe(p, ctx)
8195  t1 = _to_tactic(t1, ctx)
8196  t2 = _to_tactic(t2, ctx)
8197  return Tactic(Z3_tactic_cond(t1.ctx.ref(), p.probe, t1.tactic, t2.tactic), t1.ctx)
8198 
8199 
8204 
8205 def simplify(a, *arguments, **keywords):
8206  """Simplify the expression `a` using the given options.
8207 
8208  This function has many options. Use `help_simplify` to obtain the complete list.
8209 
8210  >>> x = Int('x')
8211  >>> y = Int('y')
8212  >>> simplify(x + 1 + y + x + 1)
8213  2 + 2*x + y
8214  >>> simplify((x + 1)*(y + 1), som=True)
8215  1 + x + y + x*y
8216  >>> simplify(Distinct(x, y, 1), blast_distinct=True)
8217  And(Not(x == y), Not(x == 1), Not(y == 1))
8218  >>> simplify(And(x == 0, y == 1), elim_and=True)
8219  Not(Or(Not(x == 0), Not(y == 1)))
8220  """
8221  if z3_debug():
8222  _z3_assert(is_expr(a), "Z3 expression expected")
8223  if len(arguments) > 0 or len(keywords) > 0:
8224  p = args2params(arguments, keywords, a.ctx)
8225  return _to_expr_ref(Z3_simplify_ex(a.ctx_ref(), a.as_ast(), p.params), a.ctx)
8226  else:
8227  return _to_expr_ref(Z3_simplify(a.ctx_ref(), a.as_ast()), a.ctx)
8228 
8230  """Return a string describing all options available for Z3 `simplify` procedure."""
8231  print(Z3_simplify_get_help(main_ctx().ref()))
8232 
8234  """Return the set of parameter descriptions for Z3 `simplify` procedure."""
8236 
8237 def substitute(t, *m):
8238  """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.
8239 
8240  >>> x = Int('x')
8241  >>> y = Int('y')
8242  >>> substitute(x + 1, (x, y + 1))
8243  y + 1 + 1
8244  >>> f = Function('f', IntSort(), IntSort())
8245  >>> substitute(f(x) + f(y), (f(x), IntVal(1)), (f(y), IntVal(1)))
8246  1 + 1
8247  """
8248  if isinstance(m, tuple):
8249  m1 = _get_args(m)
8250  if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1):
8251  m = m1
8252  if z3_debug():
8253  _z3_assert(is_expr(t), "Z3 expression expected")
8254  _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.")
8255  num = len(m)
8256  _from = (Ast * num)()
8257  _to = (Ast * num)()
8258  for i in range(num):
8259  _from[i] = m[i][0].as_ast()
8260  _to[i] = m[i][1].as_ast()
8261  return _to_expr_ref(Z3_substitute(t.ctx.ref(), t.as_ast(), num, _from, _to), t.ctx)
8262 
8263 def substitute_vars(t, *m):
8264  """Substitute the free variables in t with the expression in m.
8265 
8266  >>> v0 = Var(0, IntSort())
8267  >>> v1 = Var(1, IntSort())
8268  >>> x = Int('x')
8269  >>> f = Function('f', IntSort(), IntSort(), IntSort())
8270  >>> # replace v0 with x+1 and v1 with x
8271  >>> substitute_vars(f(v0, v1), x + 1, x)
8272  f(x + 1, x)
8273  """
8274  if z3_debug():
8275  _z3_assert(is_expr(t), "Z3 expression expected")
8276  _z3_assert(all([is_expr(n) for n in m]), "Z3 invalid substitution, list of expressions expected.")
8277  num = len(m)
8278  _to = (Ast * num)()
8279  for i in range(num):
8280  _to[i] = m[i].as_ast()
8281  return _to_expr_ref(Z3_substitute_vars(t.ctx.ref(), t.as_ast(), num, _to), t.ctx)
8282 
8283 def Sum(*args):
8284  """Create the sum of the Z3 expressions.
8285 
8286  >>> a, b, c = Ints('a b c')
8287  >>> Sum(a, b, c)
8288  a + b + c
8289  >>> Sum([a, b, c])
8290  a + b + c
8291  >>> A = IntVector('a', 5)
8292  >>> Sum(A)
8293  a__0 + a__1 + a__2 + a__3 + a__4
8294  """
8295  args = _get_args(args)
8296  if len(args) == 0:
8297  return 0
8298  ctx = _ctx_from_ast_arg_list(args)
8299  if ctx is None:
8300  return _reduce(lambda a, b: a + b, args, 0)
8301  args = _coerce_expr_list(args, ctx)
8302  if is_bv(args[0]):
8303  return _reduce(lambda a, b: a + b, args, 0)
8304  else:
8305  _args, sz = _to_ast_array(args)
8306  return ArithRef(Z3_mk_add(ctx.ref(), sz, _args), ctx)
8307 
8308 
8309 def Product(*args):
8310  """Create the product of the Z3 expressions.
8311 
8312  >>> a, b, c = Ints('a b c')
8313  >>> Product(a, b, c)
8314  a*b*c
8315  >>> Product([a, b, c])
8316  a*b*c
8317  >>> A = IntVector('a', 5)
8318  >>> Product(A)
8319  a__0*a__1*a__2*a__3*a__4
8320  """
8321  args = _get_args(args)
8322  if len(args) == 0:
8323  return 1
8324  ctx = _ctx_from_ast_arg_list(args)
8325  if ctx is None:
8326  return _reduce(lambda a, b: a * b, args, 1)
8327  args = _coerce_expr_list(args, ctx)
8328  if is_bv(args[0]):
8329  return _reduce(lambda a, b: a * b, args, 1)
8330  else:
8331  _args, sz = _to_ast_array(args)
8332  return ArithRef(Z3_mk_mul(ctx.ref(), sz, _args), ctx)
8333 
8334 def AtMost(*args):
8335  """Create an at-most Pseudo-Boolean k constraint.
8336 
8337  >>> a, b, c = Bools('a b c')
8338  >>> f = AtMost(a, b, c, 2)
8339  """
8340  args = _get_args(args)
8341  if z3_debug():
8342  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8343  ctx = _ctx_from_ast_arg_list(args)
8344  if z3_debug():
8345  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8346  args1 = _coerce_expr_list(args[:-1], ctx)
8347  k = args[-1]
8348  _args, sz = _to_ast_array(args1)
8349  return BoolRef(Z3_mk_atmost(ctx.ref(), sz, _args, k), ctx)
8350 
8351 def AtLeast(*args):
8352  """Create an at-most Pseudo-Boolean k constraint.
8353 
8354  >>> a, b, c = Bools('a b c')
8355  >>> f = AtLeast(a, b, c, 2)
8356  """
8357  args = _get_args(args)
8358  if z3_debug():
8359  _z3_assert(len(args) > 1, "Non empty list of arguments expected")
8360  ctx = _ctx_from_ast_arg_list(args)
8361  if z3_debug():
8362  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8363  args1 = _coerce_expr_list(args[:-1], ctx)
8364  k = args[-1]
8365  _args, sz = _to_ast_array(args1)
8366  return BoolRef(Z3_mk_atleast(ctx.ref(), sz, _args, k), ctx)
8367 
8368 def _reorder_pb_arg(arg):
8369  a, b = arg
8370  if not _is_int(b) and _is_int(a):
8371  return b, a
8372  return arg
8373 
8374 def _pb_args_coeffs(args, default_ctx = None):
8375  args = _get_args_ast_list(args)
8376  if len(args) == 0:
8377  return _get_ctx(default_ctx), 0, (Ast * 0)(), (ctypes.c_int * 0)()
8378  args = [_reorder_pb_arg(arg) for arg in args]
8379  args, coeffs = zip(*args)
8380  if z3_debug():
8381  _z3_assert(len(args) > 0, "Non empty list of arguments expected")
8382  ctx = _ctx_from_ast_arg_list(args)
8383  if z3_debug():
8384  _z3_assert(ctx is not None, "At least one of the arguments must be a Z3 expression")
8385  args = _coerce_expr_list(args, ctx)
8386  _args, sz = _to_ast_array(args)
8387  _coeffs = (ctypes.c_int * len(coeffs))()
8388  for i in range(len(coeffs)):
8389  _z3_check_cint_overflow(coeffs[i], "coefficient")
8390  _coeffs[i] = coeffs[i]
8391  return ctx, sz, _args, _coeffs
8392 
8393 def PbLe(args, k):
8394  """Create a Pseudo-Boolean inequality k constraint.
8395 
8396  >>> a, b, c = Bools('a b c')
8397  >>> f = PbLe(((a,1),(b,3),(c,2)), 3)
8398  """
8399  _z3_check_cint_overflow(k, "k")
8400  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8401  return BoolRef(Z3_mk_pble(ctx.ref(), sz, _args, _coeffs, k), ctx)
8402 
8403 def PbGe(args, k):
8404  """Create a Pseudo-Boolean inequality k constraint.
8405 
8406  >>> a, b, c = Bools('a b c')
8407  >>> f = PbGe(((a,1),(b,3),(c,2)), 3)
8408  """
8409  _z3_check_cint_overflow(k, "k")
8410  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8411  return BoolRef(Z3_mk_pbge(ctx.ref(), sz, _args, _coeffs, k), ctx)
8412 
8413 def PbEq(args, k, ctx = None):
8414  """Create a Pseudo-Boolean inequality k constraint.
8415 
8416  >>> a, b, c = Bools('a b c')
8417  >>> f = PbEq(((a,1),(b,3),(c,2)), 3)
8418  """
8419  _z3_check_cint_overflow(k, "k")
8420  ctx, sz, _args, _coeffs = _pb_args_coeffs(args)
8421  return BoolRef(Z3_mk_pbeq(ctx.ref(), sz, _args, _coeffs, k), ctx)
8422 
8423 
8424 def solve(*args, **keywords):
8425  """Solve the constraints `*args`.
8426 
8427  This is a simple function for creating demonstrations. It creates a solver,
8428  configure it using the options in `keywords`, adds the constraints
8429  in `args`, and invokes check.
8430 
8431  >>> a = Int('a')
8432  >>> solve(a > 0, a < 2)
8433  [a = 1]
8434  """
8435  s = Solver()
8436  s.set(**keywords)
8437  s.add(*args)
8438  if keywords.get('show', False):
8439  print(s)
8440  r = s.check()
8441  if r == unsat:
8442  print("no solution")
8443  elif r == unknown:
8444  print("failed to solve")
8445  try:
8446  print(s.model())
8447  except Z3Exception:
8448  return
8449  else:
8450  print(s.model())
8451 
8452 def solve_using(s, *args, **keywords):
8453  """Solve the constraints `*args` using solver `s`.
8454 
8455  This is a simple function for creating demonstrations. It is similar to `solve`,
8456  but it uses the given solver `s`.
8457  It configures solver `s` using the options in `keywords`, adds the constraints
8458  in `args`, and invokes check.
8459  """
8460  if z3_debug():
8461  _z3_assert(isinstance(s, Solver), "Solver object expected")
8462  s.set(**keywords)
8463  s.add(*args)
8464  if keywords.get('show', False):
8465  print("Problem:")
8466  print(s)
8467  r = s.check()
8468  if r == unsat:
8469  print("no solution")
8470  elif r == unknown:
8471  print("failed to solve")
8472  try:
8473  print(s.model())
8474  except Z3Exception:
8475  return
8476  else:
8477  if keywords.get('show', False):
8478  print("Solution:")
8479  print(s.model())
8480 
8481 def prove(claim, **keywords):
8482  """Try to prove the given claim.
8483 
8484  This is a simple function for creating demonstrations. It tries to prove
8485  `claim` by showing the negation is unsatisfiable.
8486 
8487  >>> p, q = Bools('p q')
8488  >>> prove(Not(And(p, q)) == Or(Not(p), Not(q)))
8489  proved
8490  """
8491  if z3_debug():
8492  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8493  s = Solver()
8494  s.set(**keywords)
8495  s.add(Not(claim))
8496  if keywords.get('show', False):
8497  print(s)
8498  r = s.check()
8499  if r == unsat:
8500  print("proved")
8501  elif r == unknown:
8502  print("failed to prove")
8503  print(s.model())
8504  else:
8505  print("counterexample")
8506  print(s.model())
8507 
8508 def _solve_html(*args, **keywords):
8509  """Version of function `solve` used in RiSE4Fun."""
8510  s = Solver()
8511  s.set(**keywords)
8512  s.add(*args)
8513  if keywords.get('show', False):
8514  print("<b>Problem:</b>")
8515  print(s)
8516  r = s.check()
8517  if r == unsat:
8518  print("<b>no solution</b>")
8519  elif r == unknown:
8520  print("<b>failed to solve</b>")
8521  try:
8522  print(s.model())
8523  except Z3Exception:
8524  return
8525  else:
8526  if keywords.get('show', False):
8527  print("<b>Solution:</b>")
8528  print(s.model())
8529 
8530 def _solve_using_html(s, *args, **keywords):
8531  """Version of function `solve_using` used in RiSE4Fun."""
8532  if z3_debug():
8533  _z3_assert(isinstance(s, Solver), "Solver object expected")
8534  s.set(**keywords)
8535  s.add(*args)
8536  if keywords.get('show', False):
8537  print("<b>Problem:</b>")
8538  print(s)
8539  r = s.check()
8540  if r == unsat:
8541  print("<b>no solution</b>")
8542  elif r == unknown:
8543  print("<b>failed to solve</b>")
8544  try:
8545  print(s.model())
8546  except Z3Exception:
8547  return
8548  else:
8549  if keywords.get('show', False):
8550  print("<b>Solution:</b>")
8551  print(s.model())
8552 
8553 def _prove_html(claim, **keywords):
8554  """Version of function `prove` used in RiSE4Fun."""
8555  if z3_debug():
8556  _z3_assert(is_bool(claim), "Z3 Boolean expression expected")
8557  s = Solver()
8558  s.set(**keywords)
8559  s.add(Not(claim))
8560  if keywords.get('show', False):
8561  print(s)
8562  r = s.check()
8563  if r == unsat:
8564  print("<b>proved</b>")
8565  elif r == unknown:
8566  print("<b>failed to prove</b>")
8567  print(s.model())
8568  else:
8569  print("<b>counterexample</b>")
8570  print(s.model())
8571 
8572 def _dict2sarray(sorts, ctx):
8573  sz = len(sorts)
8574  _names = (Symbol * sz)()
8575  _sorts = (Sort * sz) ()
8576  i = 0
8577  for k in sorts:
8578  v = sorts[k]
8579  if z3_debug():
8580  _z3_assert(isinstance(k, str), "String expected")
8581  _z3_assert(is_sort(v), "Z3 sort expected")
8582  _names[i] = to_symbol(k, ctx)
8583  _sorts[i] = v.ast
8584  i = i + 1
8585  return sz, _names, _sorts
8586 
8587 def _dict2darray(decls, ctx):
8588  sz = len(decls)
8589  _names = (Symbol * sz)()
8590  _decls = (FuncDecl * sz) ()
8591  i = 0
8592  for k in decls:
8593  v = decls[k]
8594  if z3_debug():
8595  _z3_assert(isinstance(k, str), "String expected")
8596  _z3_assert(is_func_decl(v) or is_const(v), "Z3 declaration or constant expected")
8597  _names[i] = to_symbol(k, ctx)
8598  if is_const(v):
8599  _decls[i] = v.decl().ast
8600  else:
8601  _decls[i] = v.ast
8602  i = i + 1
8603  return sz, _names, _decls
8604 
8605 
8606 def parse_smt2_string(s, sorts={}, decls={}, ctx=None):
8607  """Parse a string in SMT 2.0 format using the given sorts and decls.
8608 
8609  The arguments sorts and decls are Python dictionaries used to initialize
8610  the symbol table used for the SMT 2.0 parser.
8611 
8612  >>> parse_smt2_string('(declare-const x Int) (assert (> x 0)) (assert (< x 10))')
8613  [x > 0, x < 10]
8614  >>> x, y = Ints('x y')
8615  >>> f = Function('f', IntSort(), IntSort())
8616  >>> parse_smt2_string('(assert (> (+ foo (g bar)) 0))', decls={ 'foo' : x, 'bar' : y, 'g' : f})
8617  [x + f(y) > 0]
8618  >>> parse_smt2_string('(declare-const a U) (assert (> a 0))', sorts={ 'U' : IntSort() })
8619  [a > 0]
8620  """
8621  ctx = _get_ctx(ctx)
8622  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8623  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8624  return AstVector(Z3_parse_smtlib2_string(ctx.ref(), s, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8625 
8626 def parse_smt2_file(f, sorts={}, decls={}, ctx=None):
8627  """Parse a file in SMT 2.0 format using the given sorts and decls.
8628 
8629  This function is similar to parse_smt2_string().
8630  """
8631  ctx = _get_ctx(ctx)
8632  ssz, snames, ssorts = _dict2sarray(sorts, ctx)
8633  dsz, dnames, ddecls = _dict2darray(decls, ctx)
8634  return AstVector(Z3_parse_smtlib2_file(ctx.ref(), f, ssz, snames, ssorts, dsz, dnames, ddecls), ctx)
8635 
8636 
8637 
8642 
8643 
8644 # Global default rounding mode
8645 _dflt_rounding_mode = Z3_OP_FPA_RM_TOWARD_ZERO
8646 _dflt_fpsort_ebits = 11
8647 _dflt_fpsort_sbits = 53
8648 
8650  """Retrieves the global default rounding mode."""
8651  global _dflt_rounding_mode
8652  if _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO:
8653  return RTZ(ctx)
8654  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE:
8655  return RTN(ctx)
8656  elif _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE:
8657  return RTP(ctx)
8658  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN:
8659  return RNE(ctx)
8660  elif _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY:
8661  return RNA(ctx)
8662 
8663 def set_default_rounding_mode(rm, ctx=None):
8664  global _dflt_rounding_mode
8665  if is_fprm_value(rm):
8666  _dflt_rounding_mode = rm.decl().kind()
8667  else:
8668  _z3_assert(_dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_ZERO or
8669  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_NEGATIVE or
8670  _dflt_rounding_mode == Z3_OP_FPA_RM_TOWARD_POSITIVE or
8671  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN or
8672  _dflt_rounding_mode == Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY,
8673  "illegal rounding mode")
8674  _dflt_rounding_mode = rm
8675 
8676 def get_default_fp_sort(ctx=None):
8677  return FPSort(_dflt_fpsort_ebits, _dflt_fpsort_sbits, ctx)
8678 
8679 def set_default_fp_sort(ebits, sbits, ctx=None):
8680  global _dflt_fpsort_ebits
8681  global _dflt_fpsort_sbits
8682  _dflt_fpsort_ebits = ebits
8683  _dflt_fpsort_sbits = sbits
8684 
8685 def _dflt_rm(ctx=None):
8686  return get_default_rounding_mode(ctx)
8687 
8688 def _dflt_fps(ctx=None):
8689  return get_default_fp_sort(ctx)
8690 
8691 def _coerce_fp_expr_list(alist, ctx):
8692  first_fp_sort = None
8693  for a in alist:
8694  if is_fp(a):
8695  if first_fp_sort is None:
8696  first_fp_sort = a.sort()
8697  elif first_fp_sort == a.sort():
8698  pass # OK, same as before
8699  else:
8700  # we saw at least 2 different float sorts; something will
8701  # throw a sort mismatch later, for now assume None.
8702  first_fp_sort = None
8703  break
8704 
8705  r = []
8706  for i in range(len(alist)):
8707  a = alist[i]
8708  if (isinstance(a, str) and a.contains('2**(') and a.endswith(')')) or _is_int(a) or isinstance(a, float) or isinstance(a, bool):
8709  r.append(FPVal(a, None, first_fp_sort, ctx))
8710  else:
8711  r.append(a)
8712  return _coerce_expr_list(r, ctx)
8713 
8714 
8715 
8716 
8718  """Floating-point sort."""
8719 
8720  def ebits(self):
8721  """Retrieves the number of bits reserved for the exponent in the FloatingPoint sort `self`.
8722  >>> b = FPSort(8, 24)
8723  >>> b.ebits()
8724  8
8725  """
8726  return int(Z3_fpa_get_ebits(self.ctx_ref(), self.ast))
8727 
8728  def sbits(self):
8729  """Retrieves the number of bits reserved for the significand in the FloatingPoint sort `self`.
8730  >>> b = FPSort(8, 24)
8731  >>> b.sbits()
8732  24
8733  """
8734  return int(Z3_fpa_get_sbits(self.ctx_ref(), self.ast))
8735 
8736  def cast(self, val):
8737  """Try to cast `val` as a floating-point expression.
8738  >>> b = FPSort(8, 24)
8739  >>> b.cast(1.0)
8740  1
8741  >>> b.cast(1.0).sexpr()
8742  '(fp #b0 #x7f #b00000000000000000000000)'
8743  """
8744  if is_expr(val):
8745  if z3_debug():
8746  _z3_assert(self.ctx == val.ctx, "Context mismatch")
8747  return val
8748  else:
8749  return FPVal(val, None, self, self.ctx)
8750 
8751 
8752 def Float16(ctx=None):
8753  """Floating-point 16-bit (half) sort."""
8754  ctx = _get_ctx(ctx)
8755  return FPSortRef(Z3_mk_fpa_sort_16(ctx.ref()), ctx)
8756 
8757 def FloatHalf(ctx=None):
8758  """Floating-point 16-bit (half) sort."""
8759  ctx = _get_ctx(ctx)
8760  return FPSortRef(Z3_mk_fpa_sort_half(ctx.ref()), ctx)
8761 
8762 def Float32(ctx=None):
8763  """Floating-point 32-bit (single) sort."""
8764  ctx = _get_ctx(ctx)
8765  return FPSortRef(Z3_mk_fpa_sort_32(ctx.ref()), ctx)
8766 
8767 def FloatSingle(ctx=None):
8768  """Floating-point 32-bit (single) sort."""
8769  ctx = _get_ctx(ctx)
8770  return FPSortRef(Z3_mk_fpa_sort_single(ctx.ref()), ctx)
8771 
8772 def Float64(ctx=None):
8773  """Floating-point 64-bit (double) sort."""
8774  ctx = _get_ctx(ctx)
8775  return FPSortRef(Z3_mk_fpa_sort_64(ctx.ref()), ctx)
8776 
8777 def FloatDouble(ctx=None):
8778  """Floating-point 64-bit (double) sort."""
8779  ctx = _get_ctx(ctx)
8780  return FPSortRef(Z3_mk_fpa_sort_double(ctx.ref()), ctx)
8781 
8782 def Float128(ctx=None):
8783  """Floating-point 128-bit (quadruple) sort."""
8784  ctx = _get_ctx(ctx)
8785  return FPSortRef(Z3_mk_fpa_sort_128(ctx.ref()), ctx)
8786 
8787 def FloatQuadruple(ctx=None):
8788  """Floating-point 128-bit (quadruple) sort."""
8789  ctx = _get_ctx(ctx)
8790  return FPSortRef(Z3_mk_fpa_sort_quadruple(ctx.ref()), ctx)
8791 
8793  """"Floating-point rounding mode sort."""
8794 
8795 
8796 def is_fp_sort(s):
8797  """Return True if `s` is a Z3 floating-point sort.
8798 
8799  >>> is_fp_sort(FPSort(8, 24))
8800  True
8801  >>> is_fp_sort(IntSort())
8802  False
8803  """
8804  return isinstance(s, FPSortRef)
8805 
8807  """Return True if `s` is a Z3 floating-point rounding mode sort.
8808 
8809  >>> is_fprm_sort(FPSort(8, 24))
8810  False
8811  >>> is_fprm_sort(RNE().sort())
8812  True
8813  """
8814  return isinstance(s, FPRMSortRef)
8815 
8816 
8817 
8819  """Floating-point expressions."""
8820 
8821  def sort(self):
8822  """Return the sort of the floating-point expression `self`.
8823 
8824  >>> x = FP('1.0', FPSort(8, 24))
8825  >>> x.sort()
8826  FPSort(8, 24)
8827  >>> x.sort() == FPSort(8, 24)
8828  True
8829  """
8830  return FPSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
8831 
8832  def ebits(self):
8833  """Retrieves the number of bits reserved for the exponent in the FloatingPoint expression `self`.
8834  >>> b = FPSort(8, 24)
8835  >>> b.ebits()
8836  8
8837  """
8838  return self.sort().ebits();
8839 
8840  def sbits(self):
8841  """Retrieves the number of bits reserved for the exponent in the FloatingPoint expression `self`.
8842  >>> b = FPSort(8, 24)
8843  >>> b.sbits()
8844  24
8845  """
8846  return self.sort().sbits();
8847 
8848  def as_string(self):
8849  """Return a Z3 floating point expression as a Python string."""
8850  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
8851 
8852  def __le__(self, other):
8853  return fpLEQ(self, other, self.ctx)
8854 
8855  def __lt__(self, other):
8856  return fpLT(self, other, self.ctx)
8857 
8858  def __ge__(self, other):
8859  return fpGEQ(self, other, self.ctx)
8860 
8861  def __gt__(self, other):
8862  return fpGT(self, other, self.ctx)
8863 
8864  def __add__(self, other):
8865  """Create the Z3 expression `self + other`.
8866 
8867  >>> x = FP('x', FPSort(8, 24))
8868  >>> y = FP('y', FPSort(8, 24))
8869  >>> x + y
8870  x + y
8871  >>> (x + y).sort()
8872  FPSort(8, 24)
8873  """
8874  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8875  return fpAdd(_dflt_rm(), a, b, self.ctx)
8876 
8877  def __radd__(self, other):
8878  """Create the Z3 expression `other + self`.
8879 
8880  >>> x = FP('x', FPSort(8, 24))
8881  >>> 10 + x
8882  1.25*(2**3) + x
8883  """
8884  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8885  return fpAdd(_dflt_rm(), a, b, self.ctx)
8886 
8887  def __sub__(self, other):
8888  """Create the Z3 expression `self - other`.
8889 
8890  >>> x = FP('x', FPSort(8, 24))
8891  >>> y = FP('y', FPSort(8, 24))
8892  >>> x - y
8893  x - y
8894  >>> (x - y).sort()
8895  FPSort(8, 24)
8896  """
8897  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8898  return fpSub(_dflt_rm(), a, b, self.ctx)
8899 
8900  def __rsub__(self, other):
8901  """Create the Z3 expression `other - self`.
8902 
8903  >>> x = FP('x', FPSort(8, 24))
8904  >>> 10 - x
8905  1.25*(2**3) - x
8906  """
8907  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8908  return fpSub(_dflt_rm(), a, b, self.ctx)
8909 
8910  def __mul__(self, other):
8911  """Create the Z3 expression `self * other`.
8912 
8913  >>> x = FP('x', FPSort(8, 24))
8914  >>> y = FP('y', FPSort(8, 24))
8915  >>> x * y
8916  x * y
8917  >>> (x * y).sort()
8918  FPSort(8, 24)
8919  >>> 10 * y
8920  1.25*(2**3) * y
8921  """
8922  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8923  return fpMul(_dflt_rm(), a, b, self.ctx)
8924 
8925  def __rmul__(self, other):
8926  """Create the Z3 expression `other * self`.
8927 
8928  >>> x = FP('x', FPSort(8, 24))
8929  >>> y = FP('y', FPSort(8, 24))
8930  >>> x * y
8931  x * y
8932  >>> x * 10
8933  x * 1.25*(2**3)
8934  """
8935  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8936  return fpMul(_dflt_rm(), a, b, self.ctx)
8937 
8938  def __pos__(self):
8939  """Create the Z3 expression `+self`."""
8940  return self
8941 
8942  def __neg__(self):
8943  """Create the Z3 expression `-self`.
8944 
8945  >>> x = FP('x', Float32())
8946  >>> -x
8947  -x
8948  """
8949  return fpNeg(self)
8950 
8951  def __div__(self, other):
8952  """Create the Z3 expression `self / other`.
8953 
8954  >>> x = FP('x', FPSort(8, 24))
8955  >>> y = FP('y', FPSort(8, 24))
8956  >>> x / y
8957  x / y
8958  >>> (x / y).sort()
8959  FPSort(8, 24)
8960  >>> 10 / y
8961  1.25*(2**3) / y
8962  """
8963  [a, b] = _coerce_fp_expr_list([self, other], self.ctx)
8964  return fpDiv(_dflt_rm(), a, b, self.ctx)
8965 
8966  def __rdiv__(self, other):
8967  """Create the Z3 expression `other / self`.
8968 
8969  >>> x = FP('x', FPSort(8, 24))
8970  >>> y = FP('y', FPSort(8, 24))
8971  >>> x / y
8972  x / y
8973  >>> x / 10
8974  x / 1.25*(2**3)
8975  """
8976  [a, b] = _coerce_fp_expr_list([other, self], self.ctx)
8977  return fpDiv(_dflt_rm(), a, b, self.ctx)
8978 
8979  def __truediv__(self, other):
8980  """Create the Z3 expression division `self / other`."""
8981  return self.__div__(other)
8982 
8983  def __rtruediv__(self, other):
8984  """Create the Z3 expression division `other / self`."""
8985  return self.__rdiv__(other)
8986 
8987  def __mod__(self, other):
8988  """Create the Z3 expression mod `self % other`."""
8989  return fpRem(self, other)
8990 
8991  def __rmod__(self, other):
8992  """Create the Z3 expression mod `other % self`."""
8993  return fpRem(other, self)
8994 
8996  """Floating-point rounding mode expressions"""
8997 
8998  def as_string(self):
8999  """Return a Z3 floating point expression as a Python string."""
9000  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
9001 
9002 
9004  ctx = _get_ctx(ctx)
9005  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9006 
9007 def RNE (ctx=None):
9008  ctx = _get_ctx(ctx)
9009  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_even(ctx.ref()), ctx)
9010 
9012  ctx = _get_ctx(ctx)
9013  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9014 
9015 def RNA (ctx=None):
9016  ctx = _get_ctx(ctx)
9017  return FPRMRef(Z3_mk_fpa_round_nearest_ties_to_away(ctx.ref()), ctx)
9018 
9019 def RoundTowardPositive(ctx=None):
9020  ctx = _get_ctx(ctx)
9021  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9022 
9023 def RTP(ctx=None):
9024  ctx = _get_ctx(ctx)
9025  return FPRMRef(Z3_mk_fpa_round_toward_positive(ctx.ref()), ctx)
9026 
9027 def RoundTowardNegative(ctx=None):
9028  ctx = _get_ctx(ctx)
9029  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9030 
9031 def RTN(ctx=None):
9032  ctx = _get_ctx(ctx)
9033  return FPRMRef(Z3_mk_fpa_round_toward_negative(ctx.ref()), ctx)
9034 
9035 def RoundTowardZero(ctx=None):
9036  ctx = _get_ctx(ctx)
9037  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9038 
9039 def RTZ(ctx=None):
9040  ctx = _get_ctx(ctx)
9041  return FPRMRef(Z3_mk_fpa_round_toward_zero(ctx.ref()), ctx)
9042 
9043 def is_fprm(a):
9044  """Return `True` if `a` is a Z3 floating-point rounding mode expression.
9045 
9046  >>> rm = RNE()
9047  >>> is_fprm(rm)
9048  True
9049  >>> rm = 1.0
9050  >>> is_fprm(rm)
9051  False
9052  """
9053  return isinstance(a, FPRMRef)
9054 
9056  """Return `True` if `a` is a Z3 floating-point rounding mode numeral value."""
9057  return is_fprm(a) and _is_numeral(a.ctx, a.ast)
9058 
9059 
9060 
9062  """The sign of the numeral.
9063 
9064  >>> x = FPVal(+1.0, FPSort(8, 24))
9065  >>> x.sign()
9066  False
9067  >>> x = FPVal(-1.0, FPSort(8, 24))
9068  >>> x.sign()
9069  True
9070  """
9071  def sign(self):
9072  l = (ctypes.c_int)()
9073  if Z3_fpa_get_numeral_sign(self.ctx.ref(), self.as_ast(), byref(l)) == False:
9074  raise Z3Exception("error retrieving the sign of a numeral.")
9075  return l.value != 0
9076 
9077  """The sign of a floating-point numeral as a bit-vector expression.
9078 
9079  Remark: NaN's are invalid arguments.
9080  """
9081  def sign_as_bv(self):
9082  return BitVecNumRef(Z3_fpa_get_numeral_sign_bv(self.ctx.ref(), self.as_ast()), self.ctx)
9083 
9084  """The significand of the numeral.
9085 
9086  >>> x = FPVal(2.5, FPSort(8, 24))
9087  >>> x.significand()
9088  1.25
9089  """
9090  def significand(self):
9091  return Z3_fpa_get_numeral_significand_string(self.ctx.ref(), self.as_ast())
9092 
9093  """The significand of the numeral as a long.
9094 
9095  >>> x = FPVal(2.5, FPSort(8, 24))
9096  >>> x.significand_as_long()
9097  1.25
9098  """
9100  ptr = (ctypes.c_ulonglong * 1)()
9101  if not Z3_fpa_get_numeral_significand_uint64(self.ctx.ref(), self.as_ast(), ptr):
9102  raise Z3Exception("error retrieving the significand of a numeral.")
9103  return ptr[0]
9104 
9105  """The significand of the numeral as a bit-vector expression.
9106 
9107  Remark: NaN are invalid arguments.
9108  """
9110  return BitVecNumRef(Z3_fpa_get_numeral_significand_bv(self.ctx.ref(), self.as_ast()), self.ctx)
9111 
9112  """The exponent of the numeral.
9113 
9114  >>> x = FPVal(2.5, FPSort(8, 24))
9115  >>> x.exponent()
9116  1
9117  """
9118  def exponent(self, biased=True):
9119  return Z3_fpa_get_numeral_exponent_string(self.ctx.ref(), self.as_ast(), biased)
9120 
9121  """The exponent of the numeral as a long.
9122 
9123  >>> x = FPVal(2.5, FPSort(8, 24))
9124  >>> x.exponent_as_long()
9125  1
9126  """
9127  def exponent_as_long(self, biased=True):
9128  ptr = (ctypes.c_longlong * 1)()
9129  if not Z3_fpa_get_numeral_exponent_int64(self.ctx.ref(), self.as_ast(), ptr, biased):
9130  raise Z3Exception("error retrieving the exponent of a numeral.")
9131  return ptr[0]
9132 
9133  """The exponent of the numeral as a bit-vector expression.
9134 
9135  Remark: NaNs are invalid arguments.
9136  """
9137  def exponent_as_bv(self, biased=True):
9138  return BitVecNumRef(Z3_fpa_get_numeral_exponent_bv(self.ctx.ref(), self.as_ast(), biased), self.ctx)
9139 
9140  """Indicates whether the numeral is a NaN."""
9141  def isNaN(self):
9142  return Z3_fpa_is_numeral_nan(self.ctx.ref(), self.as_ast())
9143 
9144  """Indicates whether the numeral is +oo or -oo."""
9145  def isInf(self):
9146  return Z3_fpa_is_numeral_inf(self.ctx.ref(), self.as_ast())
9147 
9148  """Indicates whether the numeral is +zero or -zero."""
9149  def isZero(self):
9150  return Z3_fpa_is_numeral_zero(self.ctx.ref(), self.as_ast())
9151 
9152  """Indicates whether the numeral is normal."""
9153  def isNormal(self):
9154  return Z3_fpa_is_numeral_normal(self.ctx.ref(), self.as_ast())
9155 
9156  """Indicates whether the numeral is subnormal."""
9157  def isSubnormal(self):
9158  return Z3_fpa_is_numeral_subnormal(self.ctx.ref(), self.as_ast())
9159 
9160  """Indicates whether the numeral is positive."""
9161  def isPositive(self):
9162  return Z3_fpa_is_numeral_positive(self.ctx.ref(), self.as_ast())
9163 
9164  """Indicates whether the numeral is negative."""
9165  def isNegative(self):
9166  return Z3_fpa_is_numeral_negative(self.ctx.ref(), self.as_ast())
9167 
9168  """
9169  The string representation of the numeral.
9170 
9171  >>> x = FPVal(20, FPSort(8, 24))
9172  >>> x.as_string()
9173  1.25*(2**4)
9174  """
9175  def as_string(self):
9176  s = Z3_get_numeral_string(self.ctx.ref(), self.as_ast())
9177  return ("FPVal(%s, %s)" % (s, self.sort()))
9178 
9179 def is_fp(a):
9180  """Return `True` if `a` is a Z3 floating-point expression.
9181 
9182  >>> b = FP('b', FPSort(8, 24))
9183  >>> is_fp(b)
9184  True
9185  >>> is_fp(b + 1.0)
9186  True
9187  >>> is_fp(Int('x'))
9188  False
9189  """
9190  return isinstance(a, FPRef)
9191 
9193  """Return `True` if `a` is a Z3 floating-point numeral value.
9194 
9195  >>> b = FP('b', FPSort(8, 24))
9196  >>> is_fp_value(b)
9197  False
9198  >>> b = FPVal(1.0, FPSort(8, 24))
9199  >>> b
9200  1
9201  >>> is_fp_value(b)
9202  True
9203  """
9204  return is_fp(a) and _is_numeral(a.ctx, a.ast)
9205 
9206 def FPSort(ebits, sbits, ctx=None):
9207  """Return a Z3 floating-point sort of the given sizes. If `ctx=None`, then the global context is used.
9208 
9209  >>> Single = FPSort(8, 24)
9210  >>> Double = FPSort(11, 53)
9211  >>> Single
9212  FPSort(8, 24)
9213  >>> x = Const('x', Single)
9214  >>> eq(x, FP('x', FPSort(8, 24)))
9215  True
9216  """
9217  ctx = _get_ctx(ctx)
9218  return FPSortRef(Z3_mk_fpa_sort(ctx.ref(), ebits, sbits), ctx)
9219 
9220 def _to_float_str(val, exp=0):
9221  if isinstance(val, float):
9222  if math.isnan(val):
9223  res = "NaN"
9224  elif val == 0.0:
9225  sone = math.copysign(1.0, val)
9226  if sone < 0.0:
9227  return "-0.0"
9228  else:
9229  return "+0.0"
9230  elif val == float("+inf"):
9231  res = "+oo"
9232  elif val == float("-inf"):
9233  res = "-oo"
9234  else:
9235  v = val.as_integer_ratio()
9236  num = v[0]
9237  den = v[1]
9238  rvs = str(num) + '/' + str(den)
9239  res = rvs + 'p' + _to_int_str(exp)
9240  elif isinstance(val, bool):
9241  if val:
9242  res = "1.0"
9243  else:
9244  res = "0.0"
9245  elif _is_int(val):
9246  res = str(val)
9247  elif isinstance(val, str):
9248  inx = val.find('*(2**')
9249  if inx == -1:
9250  res = val
9251  elif val[-1] == ')':
9252  res = val[0:inx]
9253  exp = str(int(val[inx+5:-1]) + int(exp))
9254  else:
9255  _z3_assert(False, "String does not have floating-point numeral form.")
9256  elif z3_debug():
9257  _z3_assert(False, "Python value cannot be used to create floating-point numerals.")
9258  if exp == 0:
9259  return res
9260  else:
9261  return res + 'p' + exp
9262 
9263 
9264 def fpNaN(s):
9265  """Create a Z3 floating-point NaN term.
9266 
9267  >>> s = FPSort(8, 24)
9268  >>> set_fpa_pretty(True)
9269  >>> fpNaN(s)
9270  NaN
9271  >>> pb = get_fpa_pretty()
9272  >>> set_fpa_pretty(False)
9273  >>> fpNaN(s)
9274  fpNaN(FPSort(8, 24))
9275  >>> set_fpa_pretty(pb)
9276  """
9277  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9278  return FPNumRef(Z3_mk_fpa_nan(s.ctx_ref(), s.ast), s.ctx)
9279 
9281  """Create a Z3 floating-point +oo term.
9282 
9283  >>> s = FPSort(8, 24)
9284  >>> pb = get_fpa_pretty()
9285  >>> set_fpa_pretty(True)
9286  >>> fpPlusInfinity(s)
9287  +oo
9288  >>> set_fpa_pretty(False)
9289  >>> fpPlusInfinity(s)
9290  fpPlusInfinity(FPSort(8, 24))
9291  >>> set_fpa_pretty(pb)
9292  """
9293  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9294  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, False), s.ctx)
9295 
9297  """Create a Z3 floating-point -oo term."""
9298  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9299  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, True), s.ctx)
9300 
9301 def fpInfinity(s, negative):
9302  """Create a Z3 floating-point +oo or -oo term."""
9303  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9304  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9305  return FPNumRef(Z3_mk_fpa_inf(s.ctx_ref(), s.ast, negative), s.ctx)
9306 
9307 def fpPlusZero(s):
9308  """Create a Z3 floating-point +0.0 term."""
9309  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9310  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, False), s.ctx)
9311 
9313  """Create a Z3 floating-point -0.0 term."""
9314  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9315  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, True), s.ctx)
9316 
9317 def fpZero(s, negative):
9318  """Create a Z3 floating-point +0.0 or -0.0 term."""
9319  _z3_assert(isinstance(s, FPSortRef), "sort mismatch")
9320  _z3_assert(isinstance(negative, bool), "expected Boolean flag")
9321  return FPNumRef(Z3_mk_fpa_zero(s.ctx_ref(), s.ast, negative), s.ctx)
9322 
9323 def FPVal(sig, exp=None, fps=None, ctx=None):
9324  """Return a floating-point value of value `val` and sort `fps`. If `ctx=None`, then the global context is used.
9325 
9326  >>> v = FPVal(20.0, FPSort(8, 24))
9327  >>> v
9328  1.25*(2**4)
9329  >>> print("0x%.8x" % v.exponent_as_long(False))
9330  0x00000004
9331  >>> v = FPVal(2.25, FPSort(8, 24))
9332  >>> v
9333  1.125*(2**1)
9334  >>> v = FPVal(-2.25, FPSort(8, 24))
9335  >>> v
9336  -1.125*(2**1)
9337  >>> FPVal(-0.0, FPSort(8, 24))
9338  -0.0
9339  >>> FPVal(0.0, FPSort(8, 24))
9340  +0.0
9341  >>> FPVal(+0.0, FPSort(8, 24))
9342  +0.0
9343  """
9344  ctx = _get_ctx(ctx)
9345  if is_fp_sort(exp):
9346  fps = exp
9347  exp = None
9348  elif fps is None:
9349  fps = _dflt_fps(ctx)
9350  _z3_assert(is_fp_sort(fps), "sort mismatch")
9351  if exp is None:
9352  exp = 0
9353  val = _to_float_str(sig)
9354  if val == "NaN" or val == "nan":
9355  return fpNaN(fps)
9356  elif val == "-0.0":
9357  return fpMinusZero(fps)
9358  elif val == "0.0" or val == "+0.0":
9359  return fpPlusZero(fps)
9360  elif val == "+oo" or val == "+inf" or val == "+Inf":
9361  return fpPlusInfinity(fps)
9362  elif val == "-oo" or val == "-inf" or val == "-Inf":
9363  return fpMinusInfinity(fps)
9364  else:
9365  return FPNumRef(Z3_mk_numeral(ctx.ref(), val, fps.ast), ctx)
9366 
9367 def FP(name, fpsort, ctx=None):
9368  """Return a floating-point constant named `name`.
9369  `fpsort` is the floating-point sort.
9370  If `ctx=None`, then the global context is used.
9371 
9372  >>> x = FP('x', FPSort(8, 24))
9373  >>> is_fp(x)
9374  True
9375  >>> x.ebits()
9376  8
9377  >>> x.sort()
9378  FPSort(8, 24)
9379  >>> word = FPSort(8, 24)
9380  >>> x2 = FP('x', word)
9381  >>> eq(x, x2)
9382  True
9383  """
9384  if isinstance(fpsort, FPSortRef) and ctx is None:
9385  ctx = fpsort.ctx
9386  else:
9387  ctx = _get_ctx(ctx)
9388  return FPRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), fpsort.ast), ctx)
9389 
9390 def FPs(names, fpsort, ctx=None):
9391  """Return an array of floating-point constants.
9392 
9393  >>> x, y, z = FPs('x y z', FPSort(8, 24))
9394  >>> x.sort()
9395  FPSort(8, 24)
9396  >>> x.sbits()
9397  24
9398  >>> x.ebits()
9399  8
9400  >>> fpMul(RNE(), fpAdd(RNE(), x, y), z)
9401  fpMul(RNE(), fpAdd(RNE(), x, y), z)
9402  """
9403  ctx = _get_ctx(ctx)
9404  if isinstance(names, str):
9405  names = names.split(" ")
9406  return [FP(name, fpsort, ctx) for name in names]
9407 
9408 def fpAbs(a, ctx=None):
9409  """Create a Z3 floating-point absolute value expression.
9410 
9411  >>> s = FPSort(8, 24)
9412  >>> rm = RNE()
9413  >>> x = FPVal(1.0, s)
9414  >>> fpAbs(x)
9415  fpAbs(1)
9416  >>> y = FPVal(-20.0, s)
9417  >>> y
9418  -1.25*(2**4)
9419  >>> fpAbs(y)
9420  fpAbs(-1.25*(2**4))
9421  >>> fpAbs(-1.25*(2**4))
9422  fpAbs(-1.25*(2**4))
9423  >>> fpAbs(x).sort()
9424  FPSort(8, 24)
9425  """
9426  ctx = _get_ctx(ctx)
9427  [a] = _coerce_fp_expr_list([a], ctx)
9428  return FPRef(Z3_mk_fpa_abs(ctx.ref(), a.as_ast()), ctx)
9429 
9430 def fpNeg(a, ctx=None):
9431  """Create a Z3 floating-point addition expression.
9432 
9433  >>> s = FPSort(8, 24)
9434  >>> rm = RNE()
9435  >>> x = FP('x', s)
9436  >>> fpNeg(x)
9437  -x
9438  >>> fpNeg(x).sort()
9439  FPSort(8, 24)
9440  """
9441  ctx = _get_ctx(ctx)
9442  [a] = _coerce_fp_expr_list([a], ctx)
9443  return FPRef(Z3_mk_fpa_neg(ctx.ref(), a.as_ast()), ctx)
9444 
9445 def _mk_fp_unary(f, rm, a, ctx):
9446  ctx = _get_ctx(ctx)
9447  [a] = _coerce_fp_expr_list([a], ctx)
9448  if z3_debug():
9449  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9450  _z3_assert(is_fp(a), "Second argument must be a Z3 floating-point expression")
9451  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast()), ctx)
9452 
9453 def _mk_fp_unary_pred(f, a, ctx):
9454  ctx = _get_ctx(ctx)
9455  [a] = _coerce_fp_expr_list([a], ctx)
9456  if z3_debug():
9457  _z3_assert(is_fp(a), "First argument must be a Z3 floating-point expression")
9458  return BoolRef(f(ctx.ref(), a.as_ast()), ctx)
9459 
9460 def _mk_fp_bin(f, rm, a, b, ctx):
9461  ctx = _get_ctx(ctx)
9462  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9463  if z3_debug():
9464  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9465  _z3_assert(is_fp(a) or is_fp(b), "Second or third argument must be a Z3 floating-point expression")
9466  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast()), ctx)
9467 
9468 def _mk_fp_bin_norm(f, a, b, ctx):
9469  ctx = _get_ctx(ctx)
9470  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9471  if z3_debug():
9472  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9473  return FPRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
9474 
9475 def _mk_fp_bin_pred(f, a, b, ctx):
9476  ctx = _get_ctx(ctx)
9477  [a, b] = _coerce_fp_expr_list([a, b], ctx)
9478  if z3_debug():
9479  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9480  return BoolRef(f(ctx.ref(), a.as_ast(), b.as_ast()), ctx)
9481 
9482 def _mk_fp_tern(f, rm, a, b, c, ctx):
9483  ctx = _get_ctx(ctx)
9484  [a, b, c] = _coerce_fp_expr_list([a, b, c], ctx)
9485  if z3_debug():
9486  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9487  _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")
9488  return FPRef(f(ctx.ref(), rm.as_ast(), a.as_ast(), b.as_ast(), c.as_ast()), ctx)
9489 
9490 def fpAdd(rm, a, b, ctx=None):
9491  """Create a Z3 floating-point addition expression.
9492 
9493  >>> s = FPSort(8, 24)
9494  >>> rm = RNE()
9495  >>> x = FP('x', s)
9496  >>> y = FP('y', s)
9497  >>> fpAdd(rm, x, y)
9498  fpAdd(RNE(), x, y)
9499  >>> fpAdd(RTZ(), x, y) # default rounding mode is RTZ
9500  x + y
9501  >>> fpAdd(rm, x, y).sort()
9502  FPSort(8, 24)
9503  """
9504  return _mk_fp_bin(Z3_mk_fpa_add, rm, a, b, ctx)
9505 
9506 def fpSub(rm, a, b, ctx=None):
9507  """Create a Z3 floating-point subtraction expression.
9508 
9509  >>> s = FPSort(8, 24)
9510  >>> rm = RNE()
9511  >>> x = FP('x', s)
9512  >>> y = FP('y', s)
9513  >>> fpSub(rm, x, y)
9514  fpSub(RNE(), x, y)
9515  >>> fpSub(rm, x, y).sort()
9516  FPSort(8, 24)
9517  """
9518  return _mk_fp_bin(Z3_mk_fpa_sub, rm, a, b, ctx)
9519 
9520 def fpMul(rm, a, b, ctx=None):
9521  """Create a Z3 floating-point multiplication expression.
9522 
9523  >>> s = FPSort(8, 24)
9524  >>> rm = RNE()
9525  >>> x = FP('x', s)
9526  >>> y = FP('y', s)
9527  >>> fpMul(rm, x, y)
9528  fpMul(RNE(), x, y)
9529  >>> fpMul(rm, x, y).sort()
9530  FPSort(8, 24)
9531  """
9532  return _mk_fp_bin(Z3_mk_fpa_mul, rm, a, b, ctx)
9533 
9534 def fpDiv(rm, a, b, ctx=None):
9535  """Create a Z3 floating-point division expression.
9536 
9537  >>> s = FPSort(8, 24)
9538  >>> rm = RNE()
9539  >>> x = FP('x', s)
9540  >>> y = FP('y', s)
9541  >>> fpDiv(rm, x, y)
9542  fpDiv(RNE(), x, y)
9543  >>> fpDiv(rm, x, y).sort()
9544  FPSort(8, 24)
9545  """
9546  return _mk_fp_bin(Z3_mk_fpa_div, rm, a, b, ctx)
9547 
9548 def fpRem(a, b, ctx=None):
9549  """Create a Z3 floating-point remainder expression.
9550 
9551  >>> s = FPSort(8, 24)
9552  >>> x = FP('x', s)
9553  >>> y = FP('y', s)
9554  >>> fpRem(x, y)
9555  fpRem(x, y)
9556  >>> fpRem(x, y).sort()
9557  FPSort(8, 24)
9558  """
9559  return _mk_fp_bin_norm(Z3_mk_fpa_rem, a, b, ctx)
9560 
9561 def fpMin(a, b, ctx=None):
9562  """Create a Z3 floating-point minimum expression.
9563 
9564  >>> s = FPSort(8, 24)
9565  >>> rm = RNE()
9566  >>> x = FP('x', s)
9567  >>> y = FP('y', s)
9568  >>> fpMin(x, y)
9569  fpMin(x, y)
9570  >>> fpMin(x, y).sort()
9571  FPSort(8, 24)
9572  """
9573  return _mk_fp_bin_norm(Z3_mk_fpa_min, a, b, ctx)
9574 
9575 def fpMax(a, b, ctx=None):
9576  """Create a Z3 floating-point maximum expression.
9577 
9578  >>> s = FPSort(8, 24)
9579  >>> rm = RNE()
9580  >>> x = FP('x', s)
9581  >>> y = FP('y', s)
9582  >>> fpMax(x, y)
9583  fpMax(x, y)
9584  >>> fpMax(x, y).sort()
9585  FPSort(8, 24)
9586  """
9587  return _mk_fp_bin_norm(Z3_mk_fpa_max, a, b, ctx)
9588 
9589 def fpFMA(rm, a, b, c, ctx=None):
9590  """Create a Z3 floating-point fused multiply-add expression.
9591  """
9592  return _mk_fp_tern(Z3_mk_fpa_fma, rm, a, b, c, ctx)
9593 
9594 def fpSqrt(rm, a, ctx=None):
9595  """Create a Z3 floating-point square root expression.
9596  """
9597  return _mk_fp_unary(Z3_mk_fpa_sqrt, rm, a, ctx)
9598 
9599 def fpRoundToIntegral(rm, a, ctx=None):
9600  """Create a Z3 floating-point roundToIntegral expression.
9601  """
9602  return _mk_fp_unary(Z3_mk_fpa_round_to_integral, rm, a, ctx)
9603 
9604 def fpIsNaN(a, ctx=None):
9605  """Create a Z3 floating-point isNaN expression.
9606 
9607  >>> s = FPSort(8, 24)
9608  >>> x = FP('x', s)
9609  >>> y = FP('y', s)
9610  >>> fpIsNaN(x)
9611  fpIsNaN(x)
9612  """
9613  return _mk_fp_unary_pred(Z3_mk_fpa_is_nan, a, ctx)
9614 
9615 def fpIsInf(a, ctx=None):
9616  """Create a Z3 floating-point isInfinite expression.
9617 
9618  >>> s = FPSort(8, 24)
9619  >>> x = FP('x', s)
9620  >>> fpIsInf(x)
9621  fpIsInf(x)
9622  """
9623  return _mk_fp_unary_pred(Z3_mk_fpa_is_infinite, a, ctx)
9624 
9625 def fpIsZero(a, ctx=None):
9626  """Create a Z3 floating-point isZero expression.
9627  """
9628  return _mk_fp_unary_pred(Z3_mk_fpa_is_zero, a, ctx)
9629 
9630 def fpIsNormal(a, ctx=None):
9631  """Create a Z3 floating-point isNormal expression.
9632  """
9633  return _mk_fp_unary_pred(Z3_mk_fpa_is_normal, a, ctx)
9634 
9635 def fpIsSubnormal(a, ctx=None):
9636  """Create a Z3 floating-point isSubnormal expression.
9637  """
9638  return _mk_fp_unary_pred(Z3_mk_fpa_is_subnormal, a, ctx)
9639 
9640 def fpIsNegative(a, ctx=None):
9641  """Create a Z3 floating-point isNegative expression.
9642  """
9643  return _mk_fp_unary_pred(Z3_mk_fpa_is_negative, a, ctx)
9644 
9645 def fpIsPositive(a, ctx=None):
9646  """Create a Z3 floating-point isPositive expression.
9647  """
9648  return _mk_fp_unary_pred(Z3_mk_fpa_is_positive, a, ctx)
9649 
9650 def _check_fp_args(a, b):
9651  if z3_debug():
9652  _z3_assert(is_fp(a) or is_fp(b), "First or second argument must be a Z3 floating-point expression")
9653 
9654 def fpLT(a, b, ctx=None):
9655  """Create the Z3 floating-point expression `other < self`.
9656 
9657  >>> x, y = FPs('x y', FPSort(8, 24))
9658  >>> fpLT(x, y)
9659  x < y
9660  >>> (x < y).sexpr()
9661  '(fp.lt x y)'
9662  """
9663  return _mk_fp_bin_pred(Z3_mk_fpa_lt, a, b, ctx)
9664 
9665 def fpLEQ(a, b, ctx=None):
9666  """Create the Z3 floating-point expression `other <= self`.
9667 
9668  >>> x, y = FPs('x y', FPSort(8, 24))
9669  >>> fpLEQ(x, y)
9670  x <= y
9671  >>> (x <= y).sexpr()
9672  '(fp.leq x y)'
9673  """
9674  return _mk_fp_bin_pred(Z3_mk_fpa_leq, a, b, ctx)
9675 
9676 def fpGT(a, b, ctx=None):
9677  """Create the Z3 floating-point expression `other > self`.
9678 
9679  >>> x, y = FPs('x y', FPSort(8, 24))
9680  >>> fpGT(x, y)
9681  x > y
9682  >>> (x > y).sexpr()
9683  '(fp.gt x y)'
9684  """
9685  return _mk_fp_bin_pred(Z3_mk_fpa_gt, a, b, ctx)
9686 
9687 def fpGEQ(a, b, ctx=None):
9688  """Create the Z3 floating-point expression `other >= self`.
9689 
9690  >>> x, y = FPs('x y', FPSort(8, 24))
9691  >>> fpGEQ(x, y)
9692  x >= y
9693  >>> (x >= y).sexpr()
9694  '(fp.geq x y)'
9695  """
9696  return _mk_fp_bin_pred(Z3_mk_fpa_geq, a, b, ctx)
9697 
9698 def fpEQ(a, b, ctx=None):
9699  """Create the Z3 floating-point expression `fpEQ(other, self)`.
9700 
9701  >>> x, y = FPs('x y', FPSort(8, 24))
9702  >>> fpEQ(x, y)
9703  fpEQ(x, y)
9704  >>> fpEQ(x, y).sexpr()
9705  '(fp.eq x y)'
9706  """
9707  return _mk_fp_bin_pred(Z3_mk_fpa_eq, a, b, ctx)
9708 
9709 def fpNEQ(a, b, ctx=None):
9710  """Create the Z3 floating-point expression `Not(fpEQ(other, self))`.
9711 
9712  >>> x, y = FPs('x y', FPSort(8, 24))
9713  >>> fpNEQ(x, y)
9714  Not(fpEQ(x, y))
9715  >>> (x != y).sexpr()
9716  '(distinct x y)'
9717  """
9718  return Not(fpEQ(a, b, ctx))
9719 
9720 def fpFP(sgn, exp, sig, ctx=None):
9721  """Create the Z3 floating-point value `fpFP(sgn, sig, exp)` from the three bit-vectors sgn, sig, and exp.
9722 
9723  >>> s = FPSort(8, 24)
9724  >>> x = fpFP(BitVecVal(1, 1), BitVecVal(2**7-1, 8), BitVecVal(2**22, 23))
9725  >>> print(x)
9726  fpFP(1, 127, 4194304)
9727  >>> xv = FPVal(-1.5, s)
9728  >>> print(xv)
9729  -1.5
9730  >>> slvr = Solver()
9731  >>> slvr.add(fpEQ(x, xv))
9732  >>> slvr.check()
9733  sat
9734  >>> xv = FPVal(+1.5, s)
9735  >>> print(xv)
9736  1.5
9737  >>> slvr = Solver()
9738  >>> slvr.add(fpEQ(x, xv))
9739  >>> slvr.check()
9740  unsat
9741  """
9742  _z3_assert(is_bv(sgn) and is_bv(exp) and is_bv(sig), "sort mismatch")
9743  _z3_assert(sgn.sort().size() == 1, "sort mismatch")
9744  ctx = _get_ctx(ctx)
9745  _z3_assert(ctx == sgn.ctx == exp.ctx == sig.ctx, "context mismatch")
9746  return FPRef(Z3_mk_fpa_fp(ctx.ref(), sgn.ast, exp.ast, sig.ast), ctx)
9747 
9748 def fpToFP(a1, a2=None, a3=None, ctx=None):
9749  """Create a Z3 floating-point conversion expression from other term sorts
9750  to floating-point.
9751 
9752  From a bit-vector term in IEEE 754-2008 format:
9753  >>> x = FPVal(1.0, Float32())
9754  >>> x_bv = fpToIEEEBV(x)
9755  >>> simplify(fpToFP(x_bv, Float32()))
9756  1
9757 
9758  From a floating-point term with different precision:
9759  >>> x = FPVal(1.0, Float32())
9760  >>> x_db = fpToFP(RNE(), x, Float64())
9761  >>> x_db.sort()
9762  FPSort(11, 53)
9763 
9764  From a real term:
9765  >>> x_r = RealVal(1.5)
9766  >>> simplify(fpToFP(RNE(), x_r, Float32()))
9767  1.5
9768 
9769  From a signed bit-vector term:
9770  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9771  >>> simplify(fpToFP(RNE(), x_signed, Float32()))
9772  -1.25*(2**2)
9773  """
9774  ctx = _get_ctx(ctx)
9775  if is_bv(a1) and is_fp_sort(a2):
9776  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), a1.ast, a2.ast), ctx)
9777  elif is_fprm(a1) and is_fp(a2) and is_fp_sort(a3):
9778  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9779  elif is_fprm(a1) and is_real(a2) and is_fp_sort(a3):
9780  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9781  elif is_fprm(a1) and is_bv(a2) and is_fp_sort(a3):
9782  return FPRef(Z3_mk_fpa_to_fp_signed(ctx.ref(), a1.ast, a2.ast, a3.ast), ctx)
9783  else:
9784  raise Z3Exception("Unsupported combination of arguments for conversion to floating-point term.")
9785 
9786 def fpBVToFP(v, sort, ctx=None):
9787  """Create a Z3 floating-point conversion expression that represents the
9788  conversion from a bit-vector term to a floating-point term.
9789 
9790  >>> x_bv = BitVecVal(0x3F800000, 32)
9791  >>> x_fp = fpBVToFP(x_bv, Float32())
9792  >>> x_fp
9793  fpToFP(1065353216)
9794  >>> simplify(x_fp)
9795  1
9796  """
9797  _z3_assert(is_bv(v), "First argument must be a Z3 bit-vector expression")
9798  _z3_assert(is_fp_sort(sort), "Second argument must be a Z3 floating-point sort.")
9799  ctx = _get_ctx(ctx)
9800  return FPRef(Z3_mk_fpa_to_fp_bv(ctx.ref(), v.ast, sort.ast), ctx)
9801 
9802 def fpFPToFP(rm, v, sort, ctx=None):
9803  """Create a Z3 floating-point conversion expression that represents the
9804  conversion from a floating-point term to a floating-point term of different precision.
9805 
9806  >>> x_sgl = FPVal(1.0, Float32())
9807  >>> x_dbl = fpFPToFP(RNE(), x_sgl, Float64())
9808  >>> x_dbl
9809  fpToFP(RNE(), 1)
9810  >>> simplify(x_dbl)
9811  1
9812  >>> x_dbl.sort()
9813  FPSort(11, 53)
9814  """
9815  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9816  _z3_assert(is_fp(v), "Second argument must be a Z3 floating-point expression.")
9817  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9818  ctx = _get_ctx(ctx)
9819  return FPRef(Z3_mk_fpa_to_fp_float(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9820 
9821 def fpRealToFP(rm, v, sort, ctx=None):
9822  """Create a Z3 floating-point conversion expression that represents the
9823  conversion from a real term to a floating-point term.
9824 
9825  >>> x_r = RealVal(1.5)
9826  >>> x_fp = fpRealToFP(RNE(), x_r, Float32())
9827  >>> x_fp
9828  fpToFP(RNE(), 3/2)
9829  >>> simplify(x_fp)
9830  1.5
9831  """
9832  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9833  _z3_assert(is_real(v), "Second argument must be a Z3 expression or real sort.")
9834  _z3_assert(is_fp_sort(sort), "Third argument must be a Z3 floating-point sort.")
9835  ctx = _get_ctx(ctx)
9836  return FPRef(Z3_mk_fpa_to_fp_real(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9837 
9838 def fpSignedToFP(rm, v, sort, ctx=None):
9839  """Create a Z3 floating-point conversion expression that represents the
9840  conversion from a signed bit-vector term (encoding an integer) to a floating-point term.
9841 
9842  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9843  >>> x_fp = fpSignedToFP(RNE(), x_signed, Float32())
9844  >>> x_fp
9845  fpToFP(RNE(), 4294967291)
9846  >>> simplify(x_fp)
9847  -1.25*(2**2)
9848  """
9849  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9850  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector 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_signed(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9854 
9855 def fpUnsignedToFP(rm, v, sort, ctx=None):
9856  """Create a Z3 floating-point conversion expression that represents the
9857  conversion from an unsigned bit-vector term (encoding an integer) to a floating-point term.
9858 
9859  >>> x_signed = BitVecVal(-5, BitVecSort(32))
9860  >>> x_fp = fpUnsignedToFP(RNE(), x_signed, Float32())
9861  >>> x_fp
9862  fpToFPUnsigned(RNE(), 4294967291)
9863  >>> simplify(x_fp)
9864  1*(2**32)
9865  """
9866  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression.")
9867  _z3_assert(is_bv(v), "Second argument must be a Z3 bit-vector expression")
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_unsigned(ctx.ref(), rm.ast, v.ast, sort.ast), ctx)
9871 
9872 def fpToFPUnsigned(rm, x, s, ctx=None):
9873  """Create a Z3 floating-point conversion expression, from unsigned bit-vector to floating-point expression."""
9874  if z3_debug():
9875  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9876  _z3_assert(is_bv(x), "Second argument must be a Z3 bit-vector expression")
9877  _z3_assert(is_fp_sort(s), "Third argument must be Z3 floating-point sort")
9878  ctx = _get_ctx(ctx)
9879  return FPRef(Z3_mk_fpa_to_fp_unsigned(ctx.ref(), rm.ast, x.ast, s.ast), ctx)
9880 
9881 def fpToSBV(rm, x, s, ctx=None):
9882  """Create a Z3 floating-point conversion expression, from floating-point expression to signed bit-vector.
9883 
9884  >>> x = FP('x', FPSort(8, 24))
9885  >>> y = fpToSBV(RTZ(), x, BitVecSort(32))
9886  >>> print(is_fp(x))
9887  True
9888  >>> print(is_bv(y))
9889  True
9890  >>> print(is_fp(y))
9891  False
9892  >>> print(is_bv(x))
9893  False
9894  """
9895  if z3_debug():
9896  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9897  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9898  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9899  ctx = _get_ctx(ctx)
9900  return BitVecRef(Z3_mk_fpa_to_sbv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9901 
9902 def fpToUBV(rm, x, s, ctx=None):
9903  """Create a Z3 floating-point conversion expression, from floating-point expression to unsigned bit-vector.
9904 
9905  >>> x = FP('x', FPSort(8, 24))
9906  >>> y = fpToUBV(RTZ(), x, BitVecSort(32))
9907  >>> print(is_fp(x))
9908  True
9909  >>> print(is_bv(y))
9910  True
9911  >>> print(is_fp(y))
9912  False
9913  >>> print(is_bv(x))
9914  False
9915  """
9916  if z3_debug():
9917  _z3_assert(is_fprm(rm), "First argument must be a Z3 floating-point rounding mode expression")
9918  _z3_assert(is_fp(x), "Second argument must be a Z3 floating-point expression")
9919  _z3_assert(is_bv_sort(s), "Third argument must be Z3 bit-vector sort")
9920  ctx = _get_ctx(ctx)
9921  return BitVecRef(Z3_mk_fpa_to_ubv(ctx.ref(), rm.ast, x.ast, s.size()), ctx)
9922 
9923 def fpToReal(x, ctx=None):
9924  """Create a Z3 floating-point conversion expression, from floating-point expression to real.
9925 
9926  >>> x = FP('x', FPSort(8, 24))
9927  >>> y = fpToReal(x)
9928  >>> print(is_fp(x))
9929  True
9930  >>> print(is_real(y))
9931  True
9932  >>> print(is_fp(y))
9933  False
9934  >>> print(is_real(x))
9935  False
9936  """
9937  if z3_debug():
9938  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9939  ctx = _get_ctx(ctx)
9940  return ArithRef(Z3_mk_fpa_to_real(ctx.ref(), x.ast), ctx)
9941 
9942 def fpToIEEEBV(x, ctx=None):
9943  """\brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
9944 
9945  The size of the resulting bit-vector is automatically determined.
9946 
9947  Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion
9948  knows only one NaN and it will always produce the same bit-vector representation of
9949  that NaN.
9950 
9951  >>> x = FP('x', FPSort(8, 24))
9952  >>> y = fpToIEEEBV(x)
9953  >>> print(is_fp(x))
9954  True
9955  >>> print(is_bv(y))
9956  True
9957  >>> print(is_fp(y))
9958  False
9959  >>> print(is_bv(x))
9960  False
9961  """
9962  if z3_debug():
9963  _z3_assert(is_fp(x), "First argument must be a Z3 floating-point expression")
9964  ctx = _get_ctx(ctx)
9965  return BitVecRef(Z3_mk_fpa_to_ieee_bv(ctx.ref(), x.ast), ctx)
9966 
9967 
9968 
9969 
9974 
9976  """Sequence sort."""
9977 
9978  def is_string(self):
9979  """Determine if sort is a string
9980  >>> s = StringSort()
9981  >>> s.is_string()
9982  True
9983  >>> s = SeqSort(IntSort())
9984  >>> s.is_string()
9985  False
9986  """
9987  return Z3_is_string_sort(self.ctx_ref(), self.ast)
9988 
9989  def basis(self):
9990  return _to_sort_ref(Z3_get_seq_sort_basis(self.ctx_ref(), self.ast), self.ctx)
9991 
9992 
9993 def StringSort(ctx=None):
9994  """Create a string sort
9995  >>> s = StringSort()
9996  >>> print(s)
9997  String
9998  """
9999  ctx = _get_ctx(ctx)
10000  return SeqSortRef(Z3_mk_string_sort(ctx.ref()), ctx)
10001 
10002 
10003 def SeqSort(s):
10004  """Create a sequence sort over elements provided in the argument
10005  >>> s = SeqSort(IntSort())
10006  >>> s == Unit(IntVal(1)).sort()
10007  True
10008  """
10009  return SeqSortRef(Z3_mk_seq_sort(s.ctx_ref(), s.ast), s.ctx)
10010 
10012  """Sequence expression."""
10013 
10014  def sort(self):
10015  return SeqSortRef(Z3_get_sort(self.ctx_ref(), self.as_ast()), self.ctx)
10016 
10017  def __add__(self, other):
10018  return Concat(self, other)
10019 
10020  def __radd__(self, other):
10021  return Concat(other, self)
10022 
10023  def __getitem__(self, i):
10024  if _is_int(i):
10025  i = IntVal(i, self.ctx)
10026  return _to_expr_ref(Z3_mk_seq_nth(self.ctx_ref(), self.as_ast(), i.as_ast()), self.ctx)
10027 
10028  def at(self, i):
10029  if _is_int(i):
10030  i = IntVal(i, self.ctx)
10031  return SeqRef(Z3_mk_seq_at(self.ctx_ref(), self.as_ast(), i.as_ast()), self.ctx)
10032 
10033  def is_string(self):
10034  return Z3_is_string_sort(self.ctx_ref(), Z3_get_sort(self.ctx_ref(), self.as_ast()))
10035 
10036  def is_string_value(self):
10037  return Z3_is_string(self.ctx_ref(), self.as_ast())
10038 
10039 
10040  def as_string(self):
10041  """Return a string representation of sequence expression."""
10042  if self.is_string_value():
10043  string_length = ctypes.c_uint()
10044  chars = Z3_get_lstring(self.ctx_ref(), self.as_ast(), byref(string_length))
10045  return string_at(chars, size=string_length.value).decode('latin-1')
10046  return Z3_ast_to_string(self.ctx_ref(), self.as_ast())
10047 
10048  def __le__(self, other):
10049  return SeqRef(Z3_mk_str_le(self.ctx_ref(), self.as_ast(), other.as_ast()), self.ctx)
10050 
10051  def __lt__(self, other):
10052  return SeqRef(Z3_mk_str_lt(self.ctx_ref(), self.as_ast(), other.as_ast()), self.ctx)
10053 
10054  def __ge__(self, other):
10055  return SeqRef(Z3_mk_str_le(self.ctx_ref(), other.as_ast(), self.as_ast()), self.ctx)
10056 
10057  def __gt__(self, other):
10058  return SeqRef(Z3_mk_str_lt(self.ctx_ref(), other.as_ast(), self.as_ast()), self.ctx)
10059 
10060 
10061 def _coerce_seq(s, ctx=None):
10062  if isinstance(s, str):
10063  ctx = _get_ctx(ctx)
10064  s = StringVal(s, ctx)
10065  if not is_expr(s):
10066  raise Z3Exception("Non-expression passed as a sequence")
10067  if not is_seq(s):
10068  raise Z3Exception("Non-sequence passed as a sequence")
10069  return s
10070 
10071 def _get_ctx2(a, b, ctx=None):
10072  if is_expr(a):
10073  return a.ctx
10074  if is_expr(b):
10075  return b.ctx
10076  if ctx is None:
10077  ctx = main_ctx()
10078  return ctx
10079 
10080 def is_seq(a):
10081  """Return `True` if `a` is a Z3 sequence expression.
10082  >>> print (is_seq(Unit(IntVal(0))))
10083  True
10084  >>> print (is_seq(StringVal("abc")))
10085  True
10086  """
10087  return isinstance(a, SeqRef)
10088 
10089 def is_string(a):
10090  """Return `True` if `a` is a Z3 string expression.
10091  >>> print (is_string(StringVal("ab")))
10092  True
10093  """
10094  return isinstance(a, SeqRef) and a.is_string()
10095 
10097  """return 'True' if 'a' is a Z3 string constant expression.
10098  >>> print (is_string_value(StringVal("a")))
10099  True
10100  >>> print (is_string_value(StringVal("a") + StringVal("b")))
10101  False
10102  """
10103  return isinstance(a, SeqRef) and a.is_string_value()
10104 
10105 
10106 def StringVal(s, ctx=None):
10107  """create a string expression"""
10108  ctx = _get_ctx(ctx)
10109  return SeqRef(Z3_mk_lstring(ctx.ref(), len(s), s), ctx)
10110 
10111 def String(name, ctx=None):
10112  """Return a string constant named `name`. If `ctx=None`, then the global context is used.
10113 
10114  >>> x = String('x')
10115  """
10116  ctx = _get_ctx(ctx)
10117  return SeqRef(Z3_mk_const(ctx.ref(), to_symbol(name, ctx), StringSort(ctx).ast), ctx)
10118 
10119 def Strings(names, ctx=None):
10120  """Return string constants"""
10121  ctx = _get_ctx(ctx)
10122  if isinstance(names, str):
10123  names = names.split(" ")
10124  return [String(name, ctx) for name in names]
10125 
10126 def SubString(s, offset, length):
10127  """Extract substring or subsequence starting at offset"""
10128  return Extract(s, offset, length)
10129 
10130 def SubSeq(s, offset, length):
10131  """Extract substring or subsequence starting at offset"""
10132  return Extract(s, offset, length)
10133 
10134 def Strings(names, ctx=None):
10135  """Return a tuple of String constants. """
10136  ctx = _get_ctx(ctx)
10137  if isinstance(names, str):
10138  names = names.split(" ")
10139  return [String(name, ctx) for name in names]
10140 
10141 def Empty(s):
10142  """Create the empty sequence of the given sort
10143  >>> e = Empty(StringSort())
10144  >>> e2 = StringVal("")
10145  >>> print(e.eq(e2))
10146  True
10147  >>> e3 = Empty(SeqSort(IntSort()))
10148  >>> print(e3)
10149  Empty(Seq(Int))
10150  >>> e4 = Empty(ReSort(SeqSort(IntSort())))
10151  >>> print(e4)
10152  Empty(ReSort(Seq(Int)))
10153  """
10154  if isinstance(s, SeqSortRef):
10155  return SeqRef(Z3_mk_seq_empty(s.ctx_ref(), s.ast), s.ctx)
10156  if isinstance(s, ReSortRef):
10157  return ReRef(Z3_mk_re_empty(s.ctx_ref(), s.ast), s.ctx)
10158  raise Z3Exception("Non-sequence, non-regular expression sort passed to Empty")
10159 
10160 def Full(s):
10161  """Create the regular expression that accepts the universal language
10162  >>> e = Full(ReSort(SeqSort(IntSort())))
10163  >>> print(e)
10164  Full(ReSort(Seq(Int)))
10165  >>> e1 = Full(ReSort(StringSort()))
10166  >>> print(e1)
10167  Full(ReSort(String))
10168  """
10169  if isinstance(s, ReSortRef):
10170  return ReRef(Z3_mk_re_full(s.ctx_ref(), s.ast), s.ctx)
10171  raise Z3Exception("Non-sequence, non-regular expression sort passed to Full")
10172 
10173 
10174 def Unit(a):
10175  """Create a singleton sequence"""
10176  return SeqRef(Z3_mk_seq_unit(a.ctx_ref(), a.as_ast()), a.ctx)
10177 
10178 def PrefixOf(a, b):
10179  """Check if 'a' is a prefix of 'b'
10180  >>> s1 = PrefixOf("ab", "abc")
10181  >>> simplify(s1)
10182  True
10183  >>> s2 = PrefixOf("bc", "abc")
10184  >>> simplify(s2)
10185  False
10186  """
10187  ctx = _get_ctx2(a, b)
10188  a = _coerce_seq(a, ctx)
10189  b = _coerce_seq(b, ctx)
10190  return BoolRef(Z3_mk_seq_prefix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10191 
10192 def SuffixOf(a, b):
10193  """Check if 'a' is a suffix of 'b'
10194  >>> s1 = SuffixOf("ab", "abc")
10195  >>> simplify(s1)
10196  False
10197  >>> s2 = SuffixOf("bc", "abc")
10198  >>> simplify(s2)
10199  True
10200  """
10201  ctx = _get_ctx2(a, b)
10202  a = _coerce_seq(a, ctx)
10203  b = _coerce_seq(b, ctx)
10204  return BoolRef(Z3_mk_seq_suffix(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10205 
10206 def Contains(a, b):
10207  """Check if 'a' contains 'b'
10208  >>> s1 = Contains("abc", "ab")
10209  >>> simplify(s1)
10210  True
10211  >>> s2 = Contains("abc", "bc")
10212  >>> simplify(s2)
10213  True
10214  >>> x, y, z = Strings('x y z')
10215  >>> s3 = Contains(Concat(x,y,z), y)
10216  >>> simplify(s3)
10217  True
10218  """
10219  ctx = _get_ctx2(a, b)
10220  a = _coerce_seq(a, ctx)
10221  b = _coerce_seq(b, ctx)
10222  return BoolRef(Z3_mk_seq_contains(a.ctx_ref(), a.as_ast(), b.as_ast()), a.ctx)
10223 
10224 
10225 def Replace(s, src, dst):
10226  """Replace the first occurrence of 'src' by 'dst' in 's'
10227  >>> r = Replace("aaa", "a", "b")
10228  >>> simplify(r)
10229  "baa"
10230  """
10231  ctx = _get_ctx2(dst, s)
10232  if ctx is None and is_expr(src):
10233  ctx = src.ctx
10234  src = _coerce_seq(src, ctx)
10235  dst = _coerce_seq(dst, ctx)
10236  s = _coerce_seq(s, ctx)
10237  return SeqRef(Z3_mk_seq_replace(src.ctx_ref(), s.as_ast(), src.as_ast(), dst.as_ast()), s.ctx)
10238 
10239 def IndexOf(s, substr):
10240  return IndexOf(s, substr, IntVal(0))
10241 
10242 def IndexOf(s, substr, offset):
10243  """Retrieve the index of substring within a string starting at a specified offset.
10244  >>> simplify(IndexOf("abcabc", "bc", 0))
10245  1
10246  >>> simplify(IndexOf("abcabc", "bc", 2))
10247  4
10248  """
10249  ctx = None
10250  if is_expr(offset):
10251  ctx = offset.ctx
10252  ctx = _get_ctx2(s, substr, ctx)
10253  s = _coerce_seq(s, ctx)
10254  substr = _coerce_seq(substr, ctx)
10255  if _is_int(offset):
10256  offset = IntVal(offset, ctx)
10257  return ArithRef(Z3_mk_seq_index(s.ctx_ref(), s.as_ast(), substr.as_ast(), offset.as_ast()), s.ctx)
10258 
10259 def LastIndexOf(s, substr):
10260  """Retrieve the last index of substring within a string"""
10261  ctx = None
10262  ctx = _get_ctx2(s, substr, ctx)
10263  s = _coerce_seq(s, ctx)
10264  substr = _coerce_seq(substr, ctx)
10265  return ArithRef(Z3_mk_seq_last_index(s.ctx_ref(), s.as_ast(), substr.as_ast()), s.ctx)
10266 
10267 
10268 def Length(s):
10269  """Obtain the length of a sequence 's'
10270  >>> l = Length(StringVal("abc"))
10271  >>> simplify(l)
10272  3
10273  """
10274  s = _coerce_seq(s)
10275  return ArithRef(Z3_mk_seq_length(s.ctx_ref(), s.as_ast()), s.ctx)
10276 
10277 def StrToInt(s):
10278  """Convert string expression to integer
10279  >>> a = StrToInt("1")
10280  >>> simplify(1 == a)
10281  True
10282  >>> b = StrToInt("2")
10283  >>> simplify(1 == b)
10284  False
10285  >>> c = StrToInt(IntToStr(2))
10286  >>> simplify(1 == c)
10287  False
10288  """
10289  s = _coerce_seq(s)
10290  return ArithRef(Z3_mk_str_to_int(s.ctx_ref(), s.as_ast()), s.ctx)
10291 
10292 
10293 def IntToStr(s):
10294  """Convert integer expression to string"""
10295  if not is_expr(s):
10296  s = _py2expr(s)
10297  return SeqRef(Z3_mk_int_to_str(s.ctx_ref(), s.as_ast()), s.ctx)
10298 
10299 
10300 def Re(s, ctx=None):
10301  """The regular expression that accepts sequence 's'
10302  >>> s1 = Re("ab")
10303  >>> s2 = Re(StringVal("ab"))
10304  >>> s3 = Re(Unit(BoolVal(True)))
10305  """
10306  s = _coerce_seq(s, ctx)
10307  return ReRef(Z3_mk_seq_to_re(s.ctx_ref(), s.as_ast()), s.ctx)
10308 
10309 
10310 
10311 
10312 
10313 
10315  """Regular expression sort."""
10316 
10317  def basis(self):
10318  return _to_sort_ref(Z3_get_re_sort_basis(self.ctx_ref(), self.ast), self.ctx)
10319 
10320 def ReSort(s):
10321  if is_ast(s):
10322  return ReSortRef(Z3_mk_re_sort(s.ctx.ref(), s.ast), s.ctx)
10323  if s is None or isinstance(s, Context):
10324  ctx = _get_ctx(s)
10325  return ReSortRef(Z3_mk_re_sort(ctx.ref(), Z3_mk_string_sort(ctx.ref())), s.ctx)
10326  raise Z3Exception("Regular expression sort constructor expects either a string or a context or no argument")
10327 
10328 
10330  """Regular expressions."""
10331 
10332  def __add__(self, other):
10333  return Union(self, other)
10334 
10335 def is_re(s):
10336  return isinstance(s, ReRef)
10337 
10338 
10339 def InRe(s, re):
10340  """Create regular expression membership test
10341  >>> re = Union(Re("a"),Re("b"))
10342  >>> print (simplify(InRe("a", re)))
10343  True
10344  >>> print (simplify(InRe("b", re)))
10345  True
10346  >>> print (simplify(InRe("c", re)))
10347  False
10348  """
10349  s = _coerce_seq(s, re.ctx)
10350  return BoolRef(Z3_mk_seq_in_re(s.ctx_ref(), s.as_ast(), re.as_ast()), s.ctx)
10351 
10352 def Union(*args):
10353  """Create union of regular expressions.
10354  >>> re = Union(Re("a"), Re("b"), Re("c"))
10355  >>> print (simplify(InRe("d", re)))
10356  False
10357  """
10358  args = _get_args(args)
10359  sz = len(args)
10360  if z3_debug():
10361  _z3_assert(sz > 0, "At least one argument expected.")
10362  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10363  if sz == 1:
10364  return args[0]
10365  ctx = args[0].ctx
10366  v = (Ast * sz)()
10367  for i in range(sz):
10368  v[i] = args[i].as_ast()
10369  return ReRef(Z3_mk_re_union(ctx.ref(), sz, v), ctx)
10370 
10371 def Intersect(*args):
10372  """Create intersection of regular expressions.
10373  >>> re = Intersect(Re("a"), Re("b"), Re("c"))
10374  """
10375  args = _get_args(args)
10376  sz = len(args)
10377  if z3_debug():
10378  _z3_assert(sz > 0, "At least one argument expected.")
10379  _z3_assert(all([is_re(a) for a in args]), "All arguments must be regular expressions.")
10380  if sz == 1:
10381  return args[0]
10382  ctx = args[0].ctx
10383  v = (Ast * sz)()
10384  for i in range(sz):
10385  v[i] = args[i].as_ast()
10386  return ReRef(Z3_mk_re_intersect(ctx.ref(), sz, v), ctx)
10387 
10388 def Plus(re):
10389  """Create the regular expression accepting one or more repetitions of argument.
10390  >>> re = Plus(Re("a"))
10391  >>> print(simplify(InRe("aa", re)))
10392  True
10393  >>> print(simplify(InRe("ab", re)))
10394  False
10395  >>> print(simplify(InRe("", re)))
10396  False
10397  """
10398  return ReRef(Z3_mk_re_plus(re.ctx_ref(), re.as_ast()), re.ctx)
10399 
10400 def Option(re):
10401  """Create the regular expression that optionally accepts the argument.
10402  >>> re = Option(Re("a"))
10403  >>> print(simplify(InRe("a", re)))
10404  True
10405  >>> print(simplify(InRe("", re)))
10406  True
10407  >>> print(simplify(InRe("aa", re)))
10408  False
10409  """
10410  return ReRef(Z3_mk_re_option(re.ctx_ref(), re.as_ast()), re.ctx)
10411 
10412 def Complement(re):
10413  """Create the complement regular expression."""
10414  return ReRef(Z3_mk_re_complement(re.ctx_ref(), re.as_ast()), re.ctx)
10415 
10416 def Star(re):
10417  """Create the regular expression accepting zero or more repetitions of argument.
10418  >>> re = Star(Re("a"))
10419  >>> print(simplify(InRe("aa", re)))
10420  True
10421  >>> print(simplify(InRe("ab", re)))
10422  False
10423  >>> print(simplify(InRe("", re)))
10424  True
10425  """
10426  return ReRef(Z3_mk_re_star(re.ctx_ref(), re.as_ast()), re.ctx)
10427 
10428 def Loop(re, lo, hi=0):
10429  """Create the regular expression accepting between a lower and upper bound repetitions
10430  >>> re = Loop(Re("a"), 1, 3)
10431  >>> print(simplify(InRe("aa", re)))
10432  True
10433  >>> print(simplify(InRe("aaaa", re)))
10434  False
10435  >>> print(simplify(InRe("", re)))
10436  False
10437  """
10438  return ReRef(Z3_mk_re_loop(re.ctx_ref(), re.as_ast(), lo, hi), re.ctx)
10439 
10440 def Range(lo, hi, ctx = None):
10441  """Create the range regular expression over two sequences of length 1
10442  >>> range = Range("a","z")
10443  >>> print(simplify(InRe("b", range)))
10444  True
10445  >>> print(simplify(InRe("bb", range)))
10446  False
10447  """
10448  lo = _coerce_seq(lo, ctx)
10449  hi = _coerce_seq(hi, ctx)
10450  return ReRef(Z3_mk_re_range(lo.ctx_ref(), lo.ast, hi.ast), lo.ctx)
10451 
10452 # Special Relations
10453 
10454 def PartialOrder(a, index):
10455  return FuncDeclRef(Z3_mk_partial_order(a.ctx_ref(), a.ast, index), a.ctx);
10456 
10457 def LinearOrder(a, index):
10458  return FuncDeclRef(Z3_mk_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10459 
10460 def TreeOrder(a, index):
10461  return FuncDeclRef(Z3_mk_tree_order(a.ctx_ref(), a.ast, index), a.ctx);
10462 
10463 def PiecewiseLinearOrder(a, index):
10464  return FuncDeclRef(Z3_mk_piecewise_linear_order(a.ctx_ref(), a.ast, index), a.ctx);
10465 
10467  """Given a binary relation R, such that the two arguments have the same sort
10468  create the transitive closure relation R+.
10469  The transitive closure R+ is a new relation.
10470  """
10471  return FuncDeclRef(Z3_mk_transitive_closure(f.ctx_ref(), f.ast), f.ctx)
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:3092
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:3385
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:9301
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:5759
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:9015
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 ...
z3py.FiniteDomainRef.as_string
def as_string(self)
Definition: z3py.py:7269
z3py.fpLT
def fpLT(a, b, ctx=None)
Definition: z3py.py:9654
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:9599
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:3339
z3py.RepeatBitVec
def RepeatBitVec(n, a)
Definition: z3py.py:4153
z3py.QuantifierRef.num_vars
def num_vars(self)
Definition: z3py.py:1963
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:6281
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:8806
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:7021
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:5118
z3py.ModelRef.get_sort
def get_sort(self, idx)
Definition: z3py.py:6122
z3py.Fixedpoint.help
def help(self)
Definition: z3py.py:6999
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:6491
z3py.ParamDescrsRef.__repr__
def __repr__(self)
Definition: z3py.py:5162
z3py.Optimize.unsat_core
def unsat_core(self)
Definition: z3py.py:7513
z3py.RoundTowardPositive
def RoundTowardPositive(ctx=None)
Definition: z3py.py:9019
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:10036
z3py.Optimize.help
def help(self)
Definition: z3py.py:7401
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:2857
z3py.QuantifierRef.body
def body(self)
Definition: z3py.py:1952
z3py.FreshReal
def FreshReal(prefix='b', ctx=None)
Definition: z3py.py:3120
z3py.Fixedpoint.fact
def fact(self, head, name=None)
Definition: z3py.py:7064
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:6286
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:7991
z3py.FPNumRef.exponent
def exponent(self, biased=True)
Definition: z3py.py:9118
z3py.Fixedpoint.parse_string
def parse_string(self, s)
Definition: z3py.py:7166
z3py.Goal.get
def get(self, i)
Definition: z3py.py:5286
z3py.BitVecRef.__xor__
def __xor__(self, other)
Definition: z3py.py:3395
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:7405
z3py.ArithRef.__pos__
def __pos__(self)
Definition: z3py.py:2437
z3py.Probe.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7971
z3py.BitVecRef.__rxor__
def __rxor__(self, other)
Definition: z3py.py:3408
z3py.is_fprm
def is_fprm(a)
Definition: z3py.py:9043
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:4279
z3py.Optimize.ctx
ctx
Definition: z3py.py:7384
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:4897
z3py.QuantifierRef.sort
def sort(self)
Definition: z3py.py:1841
z3py.FiniteDomainNumRef.as_long
def as_long(self)
Definition: z3py.py:7289
z3py.fpIsInf
def fpIsInf(a, ctx=None)
Definition: z3py.py:9615
z3py.SeqRef.__le__
def __le__(self, other)
Definition: z3py.py:10048
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:5957
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:7686
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:4994
z3py.FPRef.__div__
def __div__(self, other)
Definition: z3py.py:8951
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:8840
z3py.BitVecRef.__le__
def __le__(self, other)
Definition: z3py.py:3531
z3py.ScopedConstructor.__del__
def __del__(self)
Definition: z3py.py:4792
z3py.FuncEntry.arg_value
def arg_value(self, idx)
Definition: z3py.py:5788
z3py.ModelRef.evaluate
def evaluate(self, t, model_completion=False)
Definition: z3py.py:6032
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:9786
Z3_del_context
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
z3py.FuncEntry
Definition: z3py.py:5755
z3py.ArithRef.__truediv__
def __truediv__(self, other)
Definition: z3py.py:2374
z3py.fpMinusInfinity
def fpMinusInfinity(s)
Definition: z3py.py:9296
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:7354
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:9390
z3py.ArithRef
Definition: z3py.py:2214
z3py.Fixedpoint.__repr__
def __repr__(self)
Definition: z3py.py:7182
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:5577
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:8728
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:5737
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:4126
z3py.ParOr
def ParOr(*ts, **ks)
Definition: z3py.py:7821
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:5136
z3py.IsMember
def IsMember(e, s)
Definition: z3py.py:4674
z3py.FuncDeclRef.as_func_decl
def as_func_decl(self)
Definition: z3py.py:674
z3py.SetIntersect
def SetIntersect(*args)
Definition: z3py.py:4623
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:10051
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:9149
z3py.FPRef.__mod__
def __mod__(self, other)
Definition: z3py.py:8987
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:3150
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:6107
z3py.FuncInterp.num_entries
def num_entries(self)
Definition: z3py.py:5902
z3py.Goal.dimacs
def dimacs(self)
Definition: z3py.py:5398
z3py.QuantifierRef.as_ast
def as_ast(self)
Definition: z3py.py:1835
z3py.DisjointSum
def DisjointSum(name, sorts, ctx=None)
Definition: z3py.py:5005
z3py.Strings
def Strings(names, ctx=None)
Definition: z3py.py:10119
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:9179
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:6800
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:6900
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:4556
z3py.RealSort
def RealSort(ctx=None)
Definition: z3py.py:2944
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:5054
z3py.Solver.cube
def cube(self, vars=None)
Definition: z3py.py:6772
z3py.BitVecRef.__rlshift__
def __rlshift__(self, other)
Definition: z3py.py:3653
z3py.ModelRef
Definition: z3py.py:5983
z3py.is_array_sort
def is_array_sort(a)
Definition: z3py.py:4313
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:9323
z3py.Goal.add
def add(self, *args)
Definition: z3py.py:5351
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:9902
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:9023
z3py.ArrayRef.range
def range(self)
Definition: z3py.py:4288
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.
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:10466
z3py.FPRef.__sub__
def __sub__(self, other)
Definition: z3py.py:8887
z3py.Var
def Var(idx, s)
Definition: z3py.py:1351
z3py.FuncEntry.num_args
def num_args(self)
Definition: z3py.py:5770
z3py.Fixedpoint.query
def query(self, *query)
Definition: z3py.py:7068
z3py.Optimize.set
def set(self, *args, **keys)
Definition: z3py.py:7395
z3py.AtLeast
def AtLeast(*args)
Definition: z3py.py:8351
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:8101
z3py.SignExt
def SignExt(n, a)
Definition: z3py.py:4097
z3py.AstVector.push
def push(self, v)
Definition: z3py.py:5552
z3py.FPNumRef.isNormal
def isNormal(self)
Definition: z3py.py:9153
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:3488
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:4200
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:5146
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:8606
z3py.reset_params
def reset_params()
Definition: z3py.py:263
z3py.ULT
def ULT(a, b)
Definition: z3py.py:3925
z3py.Optimize.lower
def lower(self, obj)
Definition: z3py.py:7516
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:4741
z3py.RoundTowardNegative
def RoundTowardNegative(ctx=None)
Definition: z3py.py:9027
z3py.Datatype.ctx
ctx
Definition: z3py.py:4732
z3py.ApplyResult.__init__
def __init__(self, result, ctx)
Definition: z3py.py:7577
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:3216
z3py.ApplyResult.__repr__
def __repr__(self)
Definition: z3py.py:7625
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:4736
z3py.RatVal
def RatVal(a, b, ctx=None)
Definition: z3py.py:3004
z3py.IntVal
def IntVal(val, ctx=None)
Definition: z3py.py:2975
z3py.FuncDeclRef.params
def params(self)
Definition: z3py.py:731
z3py.SetDifference
def SetDifference(a, b)
Definition: z3py.py:4664
z3py.Solver.translate
def translate(self, target)
Definition: z3py.py:6884
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:9748
z3py.ModelRef.eval
def eval(self, t, model_completion=False)
Definition: z3py.py:6003
z3py.FuncInterp.ctx
ctx
Definition: z3py.py:5868
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:8852
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:7669
z3py.Datatype.__repr__
def __repr__(self)
Definition: z3py.py:4768
z3py.FPRMSortRef
Definition: z3py.py:8792
z3py.BitVecRef.__div__
def __div__(self, other)
Definition: z3py.py:3449
z3py.BitVecRef.__ge__
def __ge__(self, other)
Definition: z3py.py:3579
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:5875
z3py.AstRef.ast
ast
Definition: z3py.py:308
z3py.fpGT
def fpGT(a, b, ctx=None)
Definition: z3py.py:9676
z3py.Goal.inconsistent
def inconsistent(self)
Definition: z3py.py:5212
z3py.tactics
def tactics(ctx=None)
Definition: z3py.py:7910
z3py.Fixedpoint.to_string
def to_string(self, queries)
Definition: z3py.py:7191
z3py.Optimize.optimize
optimize
Definition: z3py.py:7385
z3py.FPRef.__ge__
def __ge__(self, other)
Definition: z3py.py:8858
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:10011
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:9090
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:9855
z3py.Solver.ctx
ctx
Definition: z3py.py:6464
z3py.FPNumRef
FP Numerals.
Definition: z3py.py:9061
z3py.IsInt
def IsInt(a)
Definition: z3py.py:3167
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:9031
z3py.Datatype
Definition: z3py.py:4705
z3py.Solver.cube_vars
def cube_vars(self)
Definition: z3py.py:6793
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:7150
z3py.AstVector.__repr__
def __repr__(self)
Definition: z3py.py:5619
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:4067
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:10054
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:7037
z3py.RatNumRef.numerator_as_long
def numerator_as_long(self)
Definition: z3py.py:2824
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:7146
z3py.TreeOrder
def TreeOrder(a, index)
Definition: z3py.py:10460
z3py.Optimize.__repr__
def __repr__(self)
Definition: z3py.py:7552
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:10428
z3py.SubSeq
def SubSeq(s, offset, length)
Definition: z3py.py:10130
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.
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:6954
z3py.AstVector.__len__
def __len__(self)
Definition: z3py.py:5499
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.With
def With(t, *args, **keys)
Definition: z3py.py:7857
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:6918
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:8998
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:4561
z3py.simplify
def simplify(a, *arguments, **keywords)
Utils.
Definition: z3py.py:8205
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:7236
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:5492
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:7262
z3py.SeqSortRef.is_string
def is_string(self)
Definition: z3py.py:9978
z3py.Fixedpoint.sexpr
def sexpr(self)
Definition: z3py.py:7186
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:6903
z3py.Solver.__copy__
def __copy__(self)
Definition: z3py.py:6897
z3py.StringSort
def StringSort(ctx=None)
Definition: z3py.py:9993
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.
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:7383
z3py.Solver.param_descrs
def param_descrs(self)
Definition: z3py.py:6876
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:3427
z3py.Optimize.minimize
def minimize(self, arg)
Definition: z3py.py:7481
z3py.ReRef
Definition: z3py.py:10329
z3py.Tactic.__call__
def __call__(self, goal, *arguments, **keywords)
Definition: z3py.py:7724
z3py.BitVecRef.__rdiv__
def __rdiv__(self, other)
Definition: z3py.py:3472
z3py.SeqRef.at
def at(self, i)
Definition: z3py.py:10028
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:5705
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:4354
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:10033
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:4246
z3py.ReRef.__add__
def __add__(self, other)
Definition: z3py.py:10332
z3py.fpMul
def fpMul(rm, a, b, ctx=None)
Definition: z3py.py:9520
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:6914
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:10017
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:8821
z3py.fpGEQ
def fpGEQ(a, b, ctx=None)
Definition: z3py.py:9687
z3py.ScopedConstructor.ctx
ctx
Definition: z3py.py:4791
z3py.is_string_value
def is_string_value(a)
Definition: z3py.py:10096
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:10239
z3py.is_app
def is_app(a)
Definition: z3py.py:1157
z3py.fpEQ
def fpEQ(a, b, ctx=None)
Definition: z3py.py:9698
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:4036
z3py.CheckSatResult.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:6423
z3py.Statistics.ctx
ctx
Definition: z3py.py:6283
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:4369
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:2891
z3py.AstVector.__init__
def __init__(self, v=None, ctx=None)
Definition: z3py.py:5481
z3py.Solver.consequences
def consequences(self, assumptions, variables)
Definition: z3py.py:6736
z3py.FPRef.__add__
def __add__(self, other)
Definition: z3py.py:8864
z3py.fpRem
def fpRem(a, b, ctx=None)
Definition: z3py.py:9548
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:8237
z3py.Union
def Union(*args)
Definition: z3py.py:10352
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:9312
z3py.Statistics
Statistics.
Definition: z3py.py:6278
z3py.Solver.set
def set(self, *args, **keys)
Definition: z3py.py:6479
z3py.Goal
Definition: z3py.py:5171
z3py.RotateRight
def RotateRight(a, b)
Definition: z3py.py:4082
z3py.FiniteDomainSort
def FiniteDomainSort(name, sz, ctx=None)
Definition: z3py.py:7244
Z3_get_numeral_string
Z3_string Z3_API Z3_get_numeral_string(Z3_context c, Z3_ast a)
Return numeral value, as a 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:5722
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:6977
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:10178
z3py.InRe
def InRe(s, re)
Definition: z3py.py:10339
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:2854
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:4310
z3py.RatNumRef.as_fraction
def as_fraction(self)
Definition: z3py.py:2882
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:7218
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:6311
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:5120
z3py.UGE
def UGE(a, b)
Definition: z3py.py:3942
z3py.Cbrt
def Cbrt(a, ctx=None)
Definition: z3py.py:3195
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:5758
z3py.Float64
def Float64(ctx=None)
Definition: z3py.py:8772
z3py.BitVecVal
def BitVecVal(val, bv, ctx=None)
Definition: z3py.py:3777
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:9157
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:4790
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:4342
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:3293
z3py.Float32
def Float32(ctx=None)
Definition: z3py.py:8762
z3py.BoolRef.sort
def sort(self)
Definition: z3py.py:1426
z3py.AstMap.__setitem__
def __setitem__(self, k, v)
Definition: z3py.py:5689
z3py.Range
def Range(lo, hi, ctx=None)
Definition: z3py.py:10440
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:9127
z3py.BitVecRef.__or__
def __or__(self, other)
Definition: z3py.py:3349
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:8189
z3py.FPRef.__truediv__
def __truediv__(self, other)
Definition: z3py.py:8979
z3py.AstVector
Definition: z3py.py:5478
Z3_goal_to_dimacs_string
Z3_string Z3_API Z3_goal_to_dimacs_string(Z3_context c, Z3_goal g)
Convert a goal into a DIMACS formatted string. The goal must be in CNF. You can convert a goal to CNF...
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:5867
z3py.is_fp_value
def is_fp_value(a)
Definition: z3py.py:9192
z3py.is_finite_domain_sort
def is_finite_domain_sort(s)
Definition: z3py.py:7251
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:7556
z3py.fpMax
def fpMax(a, b, ctx=None)
Definition: z3py.py:9575
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.
z3py.Solver.from_file
def from_file(self, filename)
Definition: z3py.py:6764
z3py.RealVal
def RealVal(val, ctx=None)
Definition: z3py.py:2986
z3py.Solver.non_units
def non_units(self)
Definition: z3py.py:6823
z3py.PbLe
def PbLe(args, k)
Definition: z3py.py:8393
z3py.ModelRef.translate
def translate(self, target)
Definition: z3py.py:6245
z3py.solve
def solve(*args, **keywords)
Definition: z3py.py:8424
z3py.FPRef.__rdiv__
def __rdiv__(self, other)
Definition: z3py.py:8966
z3py.RoundNearestTiesToEven
def RoundNearestTiesToEven(ctx=None)
Definition: z3py.py:9003
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:5156
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:9872
z3py.Fixedpoint.set_predicate_representation
def set_predicate_representation(self, f, *representations)
Definition: z3py.py:7156
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:8787
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:7578
Z3_mk_bvnot
Z3_ast Z3_API Z3_mk_bvnot(Z3_context c, Z3_ast t1)
Bitwise negation.
z3py.BitVecRef
Definition: z3py.py:3255
z3py.eq
def eq(a, b)
Definition: z3py.py:432
z3py.fpAbs
def fpAbs(a, ctx=None)
Definition: z3py.py:9408
z3py.FuncEntry.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5763
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:5637
z3py.Optimize.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7388
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:8942
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:2837
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:8832
z3py.set_default_rounding_mode
def set_default_rounding_mode(rm, ctx=None)
Definition: z3py.py:8663
z3py.ParamDescrsRef.get_documentation
def get_documentation(self, n)
Definition: z3py.py:5151
z3py.Goal.__repr__
def __repr__(self)
Definition: z3py.py:5391
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:4317
z3py.BitVecRef.__add__
def __add__(self, other)
Definition: z3py.py:3280
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:7526
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:7489
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:6267
z3py.ApplyResult.__getitem__
def __getitem__(self, idx)
Definition: z3py.py:7608
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:9589
z3py.is_not
def is_not(a)
Definition: z3py.py:1522
z3py.Int
def Int(name, ctx=None)
Definition: z3py.py:3031
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:7683
z3py.ModelRef.__copy__
def __copy__(self)
Definition: z3py.py:6253
z3py.ArithRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:2290
z3py.simplify_param_descrs
def simplify_param_descrs()
Definition: z3py.py:8233
z3py.EmptySet
def EmptySet(s)
Definition: z3py.py:4595
z3py.FPRef.__lt__
def __lt__(self, other)
Definition: z3py.py:8855
z3py.FPNumRef.exponent_as_bv
def exponent_as_bv(self, biased=True)
Definition: z3py.py:9137
z3py.SuffixOf
def SuffixOf(a, b)
Definition: z3py.py:10192
z3py.FPNumRef.sign
def sign(self)
Definition: z3py.py:9071
z3py.Context.eh
eh
Definition: z3py.py:187
z3py.BitVecRef.__sub__
def __sub__(self, other)
Definition: z3py.py:3326
z3py.Solver.__iadd__
def __iadd__(self, fml)
Definition: z3py.py:6597
z3py.fpSignedToFP
def fpSignedToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9838
z3py.CheckSatResult.__eq__
def __eq__(self, other)
Definition: z3py.py:6426
z3py.get_default_rounding_mode
def get_default_rounding_mode(ctx=None)
Definition: z3py.py:8649
z3py.Statistics.__getitem__
def __getitem__(self, idx)
Definition: z3py.py:6325
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:8413
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:6420
z3py.DatatypeRef
Definition: z3py.py:4988
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:3225
z3py.is_fprm_value
def is_fprm_value(a)
Definition: z3py.py:9055
z3py.AstRef.ctx_ref
def ctx_ref(self)
Definition: z3py.py:362
z3py.RatNumRef.denominator
def denominator(self)
Definition: z3py.py:2813
z3py.Context
Definition: z3py.py:161
z3py.RatNumRef.is_int
def is_int(self)
Definition: z3py.py:2848
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
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:7370
z3py.Solver.model
def model(self)
Definition: z3py.py:6681
z3py.AstMap.__getitem__
def __getitem__(self, key)
Definition: z3py.py:5678
z3py.ScopedConstructorList.c
c
Definition: z3py.py:4799
z3py.BVRedOr
def BVRedOr(a)
Definition: z3py.py:4182
z3py.BitVecRef.__lt__
def __lt__(self, other)
Definition: z3py.py:3547
z3py.AstRef.__hash__
def __hash__(self)
Definition: z3py.py:329
z3py.BitVecRef.__mul__
def __mul__(self, other)
Definition: z3py.py:3303
z3py.Goal.insert
def insert(self, *args)
Definition: z3py.py:5340
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:8736
z3py.Tactic.tactic
tactic
Definition: z3py.py:7671
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:10268
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:6768
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:4990
z3py.BVAddNoOverflow
def BVAddNoOverflow(a, b, signed)
Definition: z3py.py:4188
z3py.is_eq
def is_eq(a)
Definition: z3py.py:1533
z3py.Fixedpoint.get_assertions
def get_assertions(self)
Definition: z3py.py:7178
z3py.AstMap.__del__
def __del__(self)
Definition: z3py.py:5648
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:8991
z3py.ApplyResult.__del__
def __del__(self)
Definition: z3py.py:7585
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:9604
z3py.Fixedpoint.get_cover_delta
def get_cover_delta(self, level, predicate)
Definition: z3py.py:7141
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.URem
def URem(a, b)
Definition: z3py.py:3996
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:10416
z3py.Solver.__repr__
def __repr__(self)
Definition: z3py.py:6880
z3py.AstMap.map
map
Definition: z3py.py:5635
z3py.RatNumRef.numerator
def numerator(self)
Definition: z3py.py:2798
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:3043
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:6259
z3py.Extract
def Extract(high, low, a)
Definition: z3py.py:3881
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:3755
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:5841
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:10225
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:2894
z3py.FPSortRef.ebits
def ebits(self)
Definition: z3py.py:8720
z3py.Array
def Array(name, dom, rng)
Definition: z3py.py:4426
z3py.CreateDatatypes
def CreateDatatypes(*ds)
Definition: z3py.py:4805
z3py.main_ctx
def main_ctx()
Definition: z3py.py:211
z3py.SeqRef.sort
def sort(self)
Definition: z3py.py:10014
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:7738
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:5131
z3py.RNE
def RNE(ctx=None)
Definition: z3py.py:9007
z3py.Optimize.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:7409
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:5183
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:7853
z3py.BVAddNoUnderflow
def BVAddNoUnderflow(a, b)
Definition: z3py.py:4194
z3py.FloatDouble
def FloatDouble(ctx=None)
Definition: z3py.py:8777
z3py.Optimize.add
def add(self, *args)
Definition: z3py.py:7421
z3py.Fixedpoint.append
def append(self, *args)
Definition: z3py.py:7029
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:8848
z3py.Float16
def Float16(ctx=None)
Definition: z3py.py:8752
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:10371
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:8283
z3py.FPRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:8925
z3py.RoundNearestTiesToAway
def RoundNearestTiesToAway(ctx=None)
Definition: z3py.py:9011
z3py.ReSortRef.basis
def basis(self)
Definition: z3py.py:10317
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:7115
z3py.is_pattern
def is_pattern(a)
Definition: z3py.py:1780
z3py.Goal.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5188
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:8626
z3py.DatatypeSortRef.recognizer
def recognizer(self, idx)
Definition: z3py.py:4931
z3py.substitute_vars
def substitute_vars(t, *m)
Definition: z3py.py:8263
z3py.Goal.sexpr
def sexpr(self)
Definition: z3py.py:5394
z3py.Optimize.push
def push(self)
Definition: z3py.py:7485
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:8229
z3py.IsSubset
def IsSubset(a, b)
Definition: z3py.py:4684
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.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:9145
z3py.Tactic.ctx
ctx
Definition: z3py.py:7670
z3py.BitVecRef.__mod__
def __mod__(self, other)
Definition: z3py.py:3492
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:4912
z3py.CheckSatResult.__ne__
def __ne__(self, other)
Definition: z3py.py:6429
z3py.FPRef.__mul__
def __mul__(self, other)
Definition: z3py.py:8910
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:10314
z3py.ModelRef.__del__
def __del__(self)
Definition: z3py.py:5992
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:7125
z3py.Context.interrupt
def interrupt(self)
Definition: z3py.py:200
z3py.BVSDivNoOverflow
def BVSDivNoOverflow(a, b)
Definition: z3py.py:4213
z3py.ExprRef.sort
def sort(self)
Definition: z3py.py:909
z3py.BitVec
def BitVec(name, bv, ctx=None)
Definition: z3py.py:3793
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:7664
z3py.is_int_value
def is_int_value(a)
Definition: z3py.py:2560
z3py.Optimize.statistics
def statistics(self)
Definition: z3py.py:7561
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:5989
z3py.ToReal
def ToReal(a)
Definition: z3py.py:3133
z3py.FuncInterp.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5872
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:3488
z3py.SeqRef.__radd__
def __radd__(self, other)
Definition: z3py.py:10020
z3py.BitVecs
def BitVecs(names, bv, ctx=None)
Definition: z3py.py:3816
z3py.is_re
def is_re(s)
Definition: z3py.py:10335
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:6818
z3py.Fixedpoint.__del__
def __del__(self)
Definition: z3py.py:6989
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:10259
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:7521
z3py.is_string
def is_string(a)
Definition: z3py.py:10089
z3py.OptimizeObjective
Optimize.
Definition: z3py.py:7348
z3py.ArithRef.__sub__
def __sub__(self, other)
Definition: z3py.py:2300
z3py.Default
def Default(a)
Definition: z3py.py:4460
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:5645
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:5141
z3py.QuantifierRef.is_lambda
def is_lambda(self)
Definition: z3py.py:1875
z3py.get_map_func
def get_map_func(a)
Definition: z3py.py:4377
z3py.Solver.assertions
def assertions(self)
Definition: z3py.py:6804
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:9630
z3py.Fixedpoint.__init__
def __init__(self, fixedpoint=None, ctx=None)
Definition: z3py.py:6975
z3py.ModelRef.get_universe
def get_universe(self, s)
Definition: z3py.py:6162
z3py.FreshConst
def FreshConst(sort, prefix='c')
Definition: z3py.py:1346
z3py.PbGe
def PbGe(args, k)
Definition: z3py.py:8403
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:5049
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:4734
z3py.ParamDescrsRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5124
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:6465
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:7458
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:6601
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:5451
z3py.is_true
def is_true(a)
Definition: z3py.py:1459
z3py.ScopedConstructorList.__del__
def __del__(self)
Definition: z3py.py:4801
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:6836
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:4591
z3py.Goal.__len__
def __len__(self)
Definition: z3py.py:5273
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:3080
z3py.ApplyResult.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:7582
z3py.probe_description
def probe_description(name, ctx=None)
Definition: z3py.py:8111
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:9975
z3py.Tactic.solver
def solver(self, logFile=None)
Definition: z3py.py:7690
z3py.Optimize.assert_and_track
def assert_and_track(self, a, p)
Definition: z3py.py:7429
z3py.Lambda
def Lambda(vs, body)
Definition: z3py.py:2102
z3py.tactic_description
def tactic_description(name, ctx=None)
Definition: z3py.py:7920
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:10106
z3py.QuantifierRef
Quantifiers.
Definition: z3py.py:1832
z3py.StrToInt
def StrToInt(s)
Definition: z3py.py:10277
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:7106
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:9720
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:9175
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:9099
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:9307
z3py.ScopedConstructorList
Definition: z3py.py:4796
z3py.fpNaN
def fpNaN(s)
Definition: z3py.py:9264
z3py.ParamDescrsRef
Definition: z3py.py:5115
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.FPSort
def FPSort(ebits, sbits, ctx=None)
Definition: z3py.py:9206
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:7589
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
z3py.ParamsRef.set
def set(self, name, val)
Definition: z3py.py:5069
z3py.get_version
def get_version()
Definition: z3py.py:81
z3py.BitVecRef.__and__
def __and__(self, other)
Definition: z3py.py:3372
z3py.ParamDescrsRef.descr
descr
Definition: z3py.py:5121
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:6432
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:10174
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:5564
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:5708
z3py.fpSqrt
def fpSqrt(rm, a, ctx=None)
Definition: z3py.py:9594
z3py.fpZero
def fpZero(s, negative)
Definition: z3py.py:9317
z3py.is_finite_domain
def is_finite_domain(a)
Definition: z3py.py:7273
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:7633
z3py.Solver.cube_vs
cube_vs
Definition: z3py.py:6779
z3py.ParamsRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:5062
z3py.Tactic.apply
def apply(self, goal, *arguments, **keywords)
Definition: z3py.py:7707
z3py.SortRef.cast
def cast(self, val)
Definition: z3py.py:543
z3py.RealVar
def RealVar(idx, ctx=None)
Definition: z3py.py:1363
z3py.FP
def FP(name, fpsort, ctx=None)
Definition: z3py.py:9367
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:9534
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:6263
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:8679
z3py.ScopedConstructorList.__init__
def __init__(self, c, ctx)
Definition: z3py.py:4798
z3py.Goal.precision
def precision(self)
Definition: z3py.py:5251
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:3667
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:5986
z3py.PiecewiseLinearOrder
def PiecewiseLinearOrder(a, index)
Definition: z3py.py:10463
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:10057
z3py.is_store
def is_store(a)
Definition: z3py.py:4573
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.
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:6612
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:4487
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:9081
z3py.FreshFunction
def FreshFunction(*sig)
Definition: z3py.py:821
z3py.AtMost
def AtMost(*args)
Definition: z3py.py:8334
z3py.FPRef.__radd__
def __radd__(self, other)
Definition: z3py.py:8877
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:5089
z3py.Fixedpoint.get_ground_sat_answer
def get_ground_sat_answer(self)
Definition: z3py.py:7120
z3py.RecAddDefinition
def RecAddDefinition(f, args, body)
Definition: z3py.py:860
z3py.Optimize.maximize
def maximize(self, arg)
Definition: z3py.py:7477
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:9881
z3py.QuantifierRef.pattern
def pattern(self, idx)
Definition: z3py.py:1924
z3py.Datatype.create
def create(self)
Definition: z3py.py:4771
z3py.FuncInterp.as_list
def as_list(self)
Definition: z3py.py:5963
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:5665
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:4800
z3py.ModelRef.__repr__
def __repr__(self)
Definition: z3py.py:5996
z3py.Re
def Re(s, ctx=None)
Definition: z3py.py:10300
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:4603
z3py.Solver.assert_and_track
def assert_and_track(self, a, p)
Definition: z3py.py:6623
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:7801
z3py.ModelRef.sorts
def sorts(self)
Definition: z3py.py:6145
z3py.Optimize.from_string
def from_string(self, s)
Definition: z3py.py:7540
z3py.Fixedpoint.rule
def rule(self, head, body=None, name=None)
Definition: z3py.py:7060
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:8085
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:7362
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.
z3py.Statistics.__getattr__
def __getattr__(self, name)
Definition: z3py.py:6381
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:3067
z3py.BoolSortRef
Booleans.
Definition: z3py.py:1390
z3py.BitVecSortRef
Bit-Vectors.
Definition: z3py.py:3213
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:5999
z3py.Solver.trail_levels
def trail_levels(self)
Definition: z3py.py:6828
z3py.fpPlusInfinity
def fpPlusInfinity(s)
Definition: z3py.py:9280
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:4249
z3py.solve_using
def solve_using(s, *args, **keywords)
Definition: z3py.py:8452
z3py.ExprRef.get_id
def get_id(self)
Definition: z3py.py:906
z3py.ScopedConstructor
Definition: z3py.py:4787
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:2851
z3py.Solver.help
def help(self)
Definition: z3py.py:6872
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:3258
z3py.Fixedpoint.insert
def insert(self, *args)
Definition: z3py.py:7033
z3py.Function
def Function(name, *sig)
Definition: z3py.py:799
z3py.Plus
def Plus(re)
Definition: z3py.py:10388
z3py.Solver.statistics
def statistics(self)
Definition: z3py.py:6841
z3py.append_log
def append_log(s)
Definition: z3py.py:105
z3py.Probe.__le__
def __le__(self, other)
Definition: z3py.py:8004
z3py.Probe.__lt__
def __lt__(self, other)
Definition: z3py.py:7978
z3py.FiniteDomainVal
def FiniteDomainVal(val, sort, ctx=None)
Definition: z3py.py:7312
z3py.FuncInterp.arity
def arity(self)
Definition: z3py.py:5918
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:10040
z3py.Float128
def Float128(ctx=None)
Definition: z3py.py:8782
z3py.OptimizeObjective.__str__
def __str__(self)
Definition: z3py.py:7376
z3py.is_add
def is_add(a)
Definition: z3py.py:2617
z3py.Then
def Then(*ts, **ks)
Definition: z3py.py:7789
z3py.AstMap.__init__
def __init__(self, m=None, ctx=None)
Definition: z3py.py:5634
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.DatatypeSortRef.num_constructors
def num_constructors(self)
Definition: z3py.py:4899
z3py.AstMap.__len__
def __len__(self)
Definition: z3py.py:5652
z3py.LinearOrder
def LinearOrder(a, index)
Definition: z3py.py:10457
z3py.ArraySort
def ArraySort(*sig)
Definition: z3py.py:4394
z3py.ArrayRef
Definition: z3py.py:4267
z3py.ApplyResult.ctx
ctx
Definition: z3py.py:7579
z3py.BitVecSort
def BitVecSort(sz, ctx=None)
Definition: z3py.py:3763
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:7548
z3py.Goal.__copy__
def __copy__(self)
Definition: z3py.py:5425
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:5055
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:6586
z3py.Goal.translate
def translate(self, target)
Definition: z3py.py:5402
z3py.SortRef.__ne__
def __ne__(self, other)
Definition: z3py.py:581
z3py.AstVector.ctx
ctx
Definition: z3py.py:5484
z3py.BoolRef.__rmul__
def __rmul__(self, other)
Definition: z3py.py:1429
z3py.Contains
def Contains(a, b)
Definition: z3py.py:10206
z3py.fpAdd
def fpAdd(rm, a, b, ctx=None)
Definition: z3py.py:9490
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:7326
z3py.OptimizeObjective._opt
_opt
Definition: z3py.py:7350
z3py.Bool
def Bool(name, ctx=None)
Definition: z3py.py:1588
z3py.SetUnion
def SetUnion(*args)
Definition: z3py.py:4611
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:6986
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:3681
z3py.FPRMRef
Definition: z3py.py:8995
z3py.Probe.__ne__
def __ne__(self, other)
Definition: z3py.py:8043
z3py.Probe.ctx
ctx
Definition: z3py.py:7949
z3py.fpSub
def fpSub(rm, a, b, ctx=None)
Definition: z3py.py:9506
z3py.Fixedpoint.__iadd__
def __iadd__(self, fml)
Definition: z3py.py:7025
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:7204
z3py.is_const_array
def is_const_array(a)
Definition: z3py.py:4330
z3py.FPSortRef
FP Sorts.
Definition: z3py.py:8717
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:8309
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:4789
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:10293
z3py.QuantifierRef.no_pattern
def no_pattern(self, idx)
Definition: z3py.py:1946
z3py.TryFor
def TryFor(t, ms, ctx=None)
Definition: z3py.py:7902
z3py.ExprRef.arg
def arg(self, idx)
Definition: z3py.py:1005
z3py.FPNumRef.isNaN
def isNaN(self)
Definition: z3py.py:9141
z3py.Probe.__init__
def __init__(self, probe, ctx=None)
Definition: z3py.py:7948
z3py.FPRef
FP Expressions.
Definition: z3py.py:8818
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:6073
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:4645
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.ParamsRef.params
params
Definition: z3py.py:5057
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:7950
z3py.SRem
def SRem(a, b)
Definition: z3py.py:4016
z3py.get_var_index
def get_var_index(a)
Definition: z3py.py:1224
z3py.CheckSatResult.r
r
Definition: z3py.py:6421
z3py.fpNeg
def fpNeg(a, ctx=None)
Definition: z3py.py:9430
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:9665
z3py.EnumSort
def EnumSort(name, values, ctx=None)
Definition: z3py.py:5017
z3py.BoolVal
def BoolVal(val, ctx=None)
Definition: z3py.py:1570
z3py.RatNumRef.as_string
def as_string(self)
Definition: z3py.py:2873
z3py.FPRef.__gt__
def __gt__(self, other)
Definition: z3py.py:8861
z3py.Solver.reason_unknown
def reason_unknown(self)
Definition: z3py.py:6859
z3py.is_ast
def is_ast(a)
Definition: z3py.py:412
z3py.FiniteDomainSortRef
Definition: z3py.py:7233
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:9109
z3py.Optimize.__del__
def __del__(self)
Definition: z3py.py:7391
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:8676
z3py.ExprRef.__hash__
def __hash__(self)
Definition: z3py.py:949
z3py.Optimize
Definition: z3py.py:7380
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:3269
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:5179
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:4733
z3py.FuncEntry.ctx
ctx
Definition: z3py.py:5760
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:3719
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:6653
z3py.Goal.convert_model
def convert_model(self, model)
Definition: z3py.py:5362
z3py.is_idiv
def is_idiv(a)
Definition: z3py.py:2666
z3py.DatatypeSortRef.accessor
def accessor(self, i, j)
Definition: z3py.py:4959
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:6535
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:3836
z3py.Probe
Definition: z3py.py:7946
z3py.Statistics.keys
def keys(self)
Definition: z3py.py:6349
z3py.Goal.size
def size(self)
Definition: z3py.py:5260
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:5866
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
z3py.FuncInterp
Definition: z3py.py:5863
z3py.SolverFor
def SolverFor(logic, ctx=None, logFile=None)
Definition: z3py.py:6934
z3py.AstVector.vector
vector
Definition: z3py.py:5482
z3py.describe_probes
def describe_probes()
Definition: z3py.py:8119
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:3639
Z3_mk_bvand
Z3_ast Z3_API Z3_mk_bvand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise and.
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:6058
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:6553
z3py.Not
def Not(a, ctx=None)
Definition: z3py.py:1669
z3py.Goal.simplify
def simplify(self, *arguments, **keywords)
Definition: z3py.py:5431
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:3316
z3py.Datatype.__init__
def __init__(self, name, ctx=None)
Definition: z3py.py:4731
z3py.ParamsRef.__repr__
def __repr__(self)
Definition: z3py.py:5086
z3py.K
def K(dom, v)
Definition: z3py.py:4524
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.
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:4176
z3py.is_fp_sort
def is_fp_sort(s)
Definition: z3py.py:8796
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:5195
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:4219
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:7536
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:4258
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:3055
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:7351
z3py.AstVector.translate
def translate(self, other_ctx)
Definition: z3py.py:5600
z3py.Goal.prec
def prec(self)
Definition: z3py.py:5230
z3py.Fixedpoint.query_from_lvl
def query_from_lvl(self, lvl, *query)
Definition: z3py.py:7090
z3py.is_bv_sort
def is_bv_sort(s)
Definition: z3py.py:3245
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:2861
z3py.Statistics.get_key_value
def get_key_value(self, key)
Definition: z3py.py:6361
z3py.FuncInterp.__repr__
def __repr__(self)
Definition: z3py.py:5980
z3py.Solver.__del__
def __del__(self)
Definition: z3py.py:6475
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:10160
z3py.Optimize.model
def model(self)
Definition: z3py.py:7506
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:3228
z3py.BitVecNumRef.as_long
def as_long(self)
Definition: z3py.py:3670
z3py.ArithRef.__radd__
def __radd__(self, other)
Definition: z3py.py:2265
z3py.OptimizeObjective.__init__
def __init__(self, opt, value, is_max)
Definition: z3py.py:7349
z3py.AndThen
def AndThen(*ts, **ks)
Definition: z3py.py:7770
z3py.AstVector.__copy__
def __copy__(self)
Definition: z3py.py:5613
z3py.AstVector.sexpr
def sexpr(self)
Definition: z3py.py:5622
z3py.IntSort
def IntSort(ctx=None)
Definition: z3py.py:2928
z3py.fpIsZero
def fpIsZero(a, ctx=None)
Definition: z3py.py:9625
z3py.OptimizeObjective.upper_values
def upper_values(self)
Definition: z3py.py:7366
z3py.OptimizeObjective._is_max
_is_max
Definition: z3py.py:7352
z3py.Fixedpoint.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:7007
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:10454
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:5536
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:5182
z3py.Goal.assert_exprs
def assert_exprs(self, *args)
Definition: z3py.py:5314
z3py.FPRef.__rtruediv__
def __rtruediv__(self, other)
Definition: z3py.py:8983
z3py.Fixedpoint.set
def set(self, *args, **keys)
Definition: z3py.py:6993
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:3959
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.
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:3563
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.
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:9161
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:3976
z3py.BV2Int
def BV2Int(a, is_signed=False)
Definition: z3py.py:3733
z3py.Solver.__init__
def __init__(self, solver=None, ctx=None, logFile=None)
Definition: z3py.py:6462
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:9035
z3py.Optimize.reason_unknown
def reason_unknown(self)
Definition: z3py.py:7502
z3py.SortRef.kind
def kind(self)
Definition: z3py.py:519
z3py.BitVecRef.__rshift__
def __rshift__(self, other)
Definition: z3py.py:3595
z3py.WithParams
def WithParams(t, p)
Definition: z3py.py:7870
z3py.Fixedpoint.get_rule_names_along_trace
def get_rule_names_along_trace(self)
Definition: z3py.py:7129
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:6567
z3py.SortRef.__eq__
def __eq__(self, other)
Definition: z3py.py:568
z3py.ModelRef.model
model
Definition: z3py.py:5988
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:4232
z3py.Fixedpoint.parse_file
def parse_file(self, f)
Definition: z3py.py:7170
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:8030
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:5766
z3py.FuncInterp.translate
def translate(self, other_ctx)
Definition: z3py.py:5952
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:8900
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.prove
def prove(claim, **keywords)
Definition: z3py.py:8481
z3py.is_bv
def is_bv(a)
Definition: z3py.py:3706
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:9561
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:7199
z3py.AstRef.__eq__
def __eq__(self, other)
Definition: z3py.py:326
z3py.Datatype.declare
def declare(self, name, *args)
Definition: z3py.py:4748
z3py.Sqrt
def Sqrt(a, ctx=None)
Definition: z3py.py:3183
z3py.SetComplement
def SetComplement(s)
Definition: z3py.py:4655
z3py.is_app_of
def is_app_of(a, k)
Definition: z3py.py:1256
z3py.Solver.solver
solver
Definition: z3py.py:6466
z3py.ModelRef.__getitem__
def __getitem__(self, idx)
Definition: z3py.py:6182
z3py.BVMulNoOverflow
def BVMulNoOverflow(a, b, signed)
Definition: z3py.py:4225
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:7883
z3py.ApplyResult
Definition: z3py.py:7574
z3py.AstVector.__getitem__
def __getitem__(self, i)
Definition: z3py.py:5512
z3py.fpToReal
def fpToReal(x, ctx=None)
Definition: z3py.py:9923
z3py.Optimize.check
def check(self, *assumptions)
Definition: z3py.py:7493
z3py.FuncInterp.else_value
def else_value(self)
Definition: z3py.py:5879
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:4439
z3py.FPRef.__pos__
def __pos__(self)
Definition: z3py.py:8938
z3py.Z3PPObject.use_pp
def use_pp(self)
Definition: z3py.py:294
z3py.describe_tactics
def describe_tactics()
Definition: z3py.py:7928
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.FuncEntry.__repr__
def __repr__(self)
Definition: z3py.py:5860
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:7265
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:6704
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:8757
z3py.BitVecRef.__lshift__
def __lshift__(self, other)
Definition: z3py.py:3625
z3py.ArrayRef.sort
def sort(self)
Definition: z3py.py:4270
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:2905
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:7531
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:7137
z3py.ModelRef.__deepcopy__
def __deepcopy__(self, memo={})
Definition: z3py.py:6256
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:7003
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:3513
z3py.AstMap
Definition: z3py.py:5631
z3py.Context.__del__
def __del__(self)
Definition: z3py.py:191
z3py.fpIsSubnormal
def fpIsSubnormal(a, ctx=None)
Definition: z3py.py:9635
z3py.Goal.__getitem__
def __getitem__(self, arg)
Definition: z3py.py:5299
z3py.FiniteDomainNumRef
Definition: z3py.py:7286
z3py.Probe.__del__
def __del__(self)
Definition: z3py.py:7974
z3py.SetAdd
def SetAdd(s, e)
Definition: z3py.py:4635
z3py.ParamsRef.__del__
def __del__(self)
Definition: z3py.py:5065
z3py.Ext
def Ext(a, b)
Definition: z3py.py:4545
z3py.ApplyResult.sexpr
def sexpr(self)
Definition: z3py.py:7628
z3py.FPNumRef.isNegative
def isNegative(self)
Definition: z3py.py:9165
z3py.Goal.append
def append(self, *args)
Definition: z3py.py:5329
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.fpIsNegative
def fpIsNegative(a, ctx=None)
Definition: z3py.py:9640
z3py.Fixedpoint.declare_var
def declare_var(self, *vars)
Definition: z3py.py:7209
z3py.fpFPToFP
def fpFPToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9802
z3py.fpNEQ
def fpNEQ(a, b, ctx=None)
Definition: z3py.py:9709
z3py.OptimizeObjective.upper
def upper(self)
Definition: z3py.py:7358
z3py.Statistics.__repr__
def __repr__(self)
Definition: z3py.py:6293
z3py.CheckSatResult
Definition: z3py.py:6409
z3py.Statistics.__del__
def __del__(self)
Definition: z3py.py:6289
z3py.SeqSort
def SeqSort(s)
Definition: z3py.py:10003
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:6984
z3py.BitVecRef.__invert__
def __invert__(self)
Definition: z3py.py:3438
z3py.BitVecRef.__truediv__
def __truediv__(self, other)
Definition: z3py.py:3468
z3py.Context.ctx
ctx
Definition: z3py.py:186
z3py.SeqSortRef.basis
def basis(self)
Definition: z3py.py:9989
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:4502
z3py.RatNumRef
Definition: z3py.py:2795
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:4207
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:7839
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:5093
z3py.FuncInterp.entry
def entry(self, idx)
Definition: z3py.py:5932
z3py.Tactic.help
def help(self)
Definition: z3py.py:7734
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:4471
z3py.Probe.__ge__
def __ge__(self, other)
Definition: z3py.py:8017
z3py.FloatSingle
def FloatSingle(ctx=None)
Definition: z3py.py:8767
z3py.ULE
def ULE(a, b)
Definition: z3py.py:3908
z3py.Solver
Definition: z3py.py:6459
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:8152
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:7425
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:6513
z3py.ExprRef.children
def children(self)
Definition: z3py.py:1026
z3py.ParamDescrsRef.__del__
def __del__(self)
Definition: z3py.py:5127
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:6226
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:5495
z3py.fpRealToFP
def fpRealToFP(rm, v, sort, ctx=None)
Definition: z3py.py:9821
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:10023
z3py.Complement
def Complement(re)
Definition: z3py.py:10412
z3py.RealVector
def RealVector(prefix, sz, ctx=None)
Definition: z3py.py:3106
z3py.Optimize.assertions
def assertions(self)
Definition: z3py.py:7544
z3py.Fixedpoint
Fixedpoint.
Definition: z3py.py:6972
z3py.Empty
def Empty(s)
Definition: z3py.py:10141
z3py.QuantifierRef.children
def children(self)
Definition: z3py.py:2007
z3py.Option
def Option(re)
Definition: z3py.py:10400
z3py.ArrayRef.__getitem__
def __getitem__(self, arg)
Definition: z3py.py:4297
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:6282
z3py.Fixedpoint.fixedpoint
fixedpoint
Definition: z3py.py:6978
z3py.fpIsPositive
def fpIsPositive(a, ctx=None)
Definition: z3py.py:9645
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:10320
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:3703
z3py.RTZ
def RTZ(ctx=None)
Definition: z3py.py:9039
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.Solver.import_model_converter
def import_model_converter(self, other)
Definition: z3py.py:6700
z3py.ArithRef.__pow__
def __pow__(self, other)
Definition: z3py.py:2323
z3py.BitVecRef.__pos__
def __pos__(self)
Definition: z3py.py:3418
z3py.SubString
def SubString(s, offset, length)
Definition: z3py.py:10126
z3py.When
def When(p, t, ctx=None)
Definition: z3py.py:8171
z3py.Goal.__del__
def __del__(self)
Definition: z3py.py:5191
z3py.is_seq
def is_seq(a)
Definition: z3py.py:10080
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:5819
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:7174
z3py.Probe.__call__
def __call__(self, goal)
Definition: z3py.py:8057
z3py.fpToIEEEBV
def fpToIEEEBV(x, ctx=None)
Definition: z3py.py:9942
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:3019
z3py.ArithRef.__div__
def __div__(self, other)
Definition: z3py.py:2351
z3py.String
def String(name, ctx=None)
Definition: z3py.py:10111
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:3362
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:7301