Z3
z3++.h
Go to the documentation of this file.
1 /*++
2 Copyright (c) 2012 Microsoft Corporation
3 
4  Thin C++ layer on top of the Z3 C API.
5  Main features:
6  - Smart pointers for all Z3 objects.
7  - Object-Oriented interface.
8  - Operator overloading.
9  - Exceptions for signaling Z3 errors
10 
11  The C API can be used simultaneously with the C++ layer.
12  However, if you use the C API directly, you will have to check the error conditions manually.
13  Of course, you can invoke the method check_error() of the context object.
14 Author:
15 
16  Leonardo (leonardo) 2012-03-28
17 
18 Notes:
19 
20 --*/
21 #pragma once
22 
23 #include<cassert>
24 #include<iostream>
25 #include<string>
26 #include<sstream>
27 #include<memory>
28 #include<z3.h>
29 #include<limits.h>
30 #include<functional>
31 
32 #undef min
33 #undef max
34 
49 namespace z3 {
50 
51  class exception;
52  class config;
53  class context;
54  class symbol;
55  class params;
56  class param_descrs;
57  class ast;
58  class sort;
59  class func_decl;
60  class expr;
61  class solver;
62  class goal;
63  class tactic;
64  class probe;
65  class model;
66  class func_interp;
67  class func_entry;
68  class statistics;
69  class apply_result;
70  template<typename T> class cast_ast;
71  template<typename T> class ast_vector_tpl;
76 
77  inline void set_param(char const * param, char const * value) { Z3_global_param_set(param, value); }
78  inline void set_param(char const * param, bool value) { Z3_global_param_set(param, value ? "true" : "false"); }
79  inline void set_param(char const * param, int value) { auto str = std::to_string(value); Z3_global_param_set(param, str.c_str()); }
81 
85  class exception : public std::exception {
86  std::string m_msg;
87  public:
88  virtual ~exception() throw() {}
89  exception(char const * msg):m_msg(msg) {}
90  char const * msg() const { return m_msg.c_str(); }
91  char const * what() const throw() { return m_msg.c_str(); }
92  friend std::ostream & operator<<(std::ostream & out, exception const & e);
93  };
94  inline std::ostream & operator<<(std::ostream & out, exception const & e) { out << e.msg(); return out; }
95 
96 #if !defined(Z3_THROW)
97 #if __cpp_exceptions || _CPPUNWIND || __EXCEPTIONS
98 #define Z3_THROW(x) throw x
99 #else
100 #define Z3_THROW(x) {}
101 #endif
102 #endif // !defined(Z3_THROW)
103 
107  class config {
108  Z3_config m_cfg;
109  config(config const &) = delete;
110  config & operator=(config const &) = delete;
111  public:
112  config() { m_cfg = Z3_mk_config(); }
113  ~config() { Z3_del_config(m_cfg); }
114  operator Z3_config() const { return m_cfg; }
118  void set(char const * param, char const * value) { Z3_set_param_value(m_cfg, param, value); }
122  void set(char const * param, bool value) { Z3_set_param_value(m_cfg, param, value ? "true" : "false"); }
126  void set(char const * param, int value) {
127  auto str = std::to_string(value);
128  Z3_set_param_value(m_cfg, param, str.c_str());
129  }
130  };
131 
134  };
135 
141  RTZ
142  };
143 
145  if (l == Z3_L_TRUE) return sat;
146  else if (l == Z3_L_FALSE) return unsat;
147  return unknown;
148  }
149 
150 
156  class context {
157  private:
158  bool m_enable_exceptions;
159  rounding_mode m_rounding_mode;
160  Z3_context m_ctx;
161  void init(config & c) {
162  set_context(Z3_mk_context_rc(c));
163  }
164  void set_context(Z3_context ctx) {
165  m_ctx = ctx;
166  m_enable_exceptions = true;
167  m_rounding_mode = RNE;
168  Z3_set_error_handler(m_ctx, 0);
170  }
171 
172 
173  context(context const &) = delete;
174  context & operator=(context const &) = delete;
175 
176  friend class scoped_context;
177  context(Z3_context c) { set_context(c); }
178  void detach() { m_ctx = nullptr; }
179  public:
180  context() { config c; init(c); }
181  context(config & c) { init(c); }
182  ~context() { if (m_ctx) Z3_del_context(m_ctx); }
183  operator Z3_context() const { return m_ctx; }
184 
189  Z3_error_code e = Z3_get_error_code(m_ctx);
190  if (e != Z3_OK && enable_exceptions())
191  Z3_THROW(exception(Z3_get_error_msg(m_ctx, e)));
192  return e;
193  }
194 
195  void check_parser_error() const {
196  check_error();
197  }
198 
206  void set_enable_exceptions(bool f) { m_enable_exceptions = f; }
207 
208  bool enable_exceptions() const { return m_enable_exceptions; }
209 
213  void set(char const * param, char const * value) { Z3_update_param_value(m_ctx, param, value); }
217  void set(char const * param, bool value) { Z3_update_param_value(m_ctx, param, value ? "true" : "false"); }
221  void set(char const * param, int value) {
222  auto str = std::to_string(value);
223  Z3_update_param_value(m_ctx, param, str.c_str());
224  }
225 
230  void interrupt() { Z3_interrupt(m_ctx); }
231 
235  symbol str_symbol(char const * s);
239  symbol int_symbol(int n);
243  sort bool_sort();
247  sort int_sort();
251  sort real_sort();
255  sort bv_sort(unsigned sz);
256 
260  sort char_sort();
264  sort string_sort();
268  sort seq_sort(sort& s);
278  sort array_sort(sort d, sort r);
279  sort array_sort(sort_vector const& d, sort r);
286  sort fpa_sort(unsigned ebits, unsigned sbits);
290  template<size_t precision>
305  sort enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts);
306 
313  func_decl tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs);
314 
318  sort uninterpreted_sort(char const* name);
319  sort uninterpreted_sort(symbol const& name);
320 
321  func_decl function(symbol const & name, unsigned arity, sort const * domain, sort const & range);
322  func_decl function(char const * name, unsigned arity, sort const * domain, sort const & range);
323  func_decl function(symbol const& name, sort_vector const& domain, sort const& range);
324  func_decl function(char const * name, sort_vector const& domain, sort const& range);
325  func_decl function(char const * name, sort const & domain, sort const & range);
326  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & range);
327  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range);
328  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range);
329  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & d5, sort const & range);
330 
331  func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range);
332  func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range);
333  func_decl recfun(char const * name, sort const & domain, sort const & range);
334  func_decl recfun(char const * name, sort const & d1, sort const & d2, sort const & range);
335 
336  void recdef(func_decl, expr_vector const& args, expr const& body);
337  func_decl user_propagate_function(symbol const& name, sort_vector const& domain, sort const& range);
338 
339  expr constant(symbol const & name, sort const & s);
340  expr constant(char const * name, sort const & s);
341  expr bool_const(char const * name);
342  expr int_const(char const * name);
343  expr real_const(char const * name);
344  expr string_const(char const * name);
345  expr bv_const(char const * name, unsigned sz);
346  expr fpa_const(char const * name, unsigned ebits, unsigned sbits);
347 
348  template<size_t precision>
349  expr fpa_const(char const * name);
350 
352 
353  expr bool_val(bool b);
354 
355  expr int_val(int n);
356  expr int_val(unsigned n);
357  expr int_val(int64_t n);
358  expr int_val(uint64_t n);
359  expr int_val(char const * n);
360 
361  expr real_val(int n, int d);
362  expr real_val(int n);
363  expr real_val(unsigned n);
364  expr real_val(int64_t n);
365  expr real_val(uint64_t n);
366  expr real_val(char const * n);
367 
368  expr bv_val(int n, unsigned sz);
369  expr bv_val(unsigned n, unsigned sz);
370  expr bv_val(int64_t n, unsigned sz);
371  expr bv_val(uint64_t n, unsigned sz);
372  expr bv_val(char const * n, unsigned sz);
373  expr bv_val(unsigned n, bool const* bits);
374 
375  expr fpa_val(double n);
376  expr fpa_val(float n);
377  expr fpa_nan(sort const & s);
378  expr fpa_inf(sort const & s, bool sgn);
379 
380  expr string_val(char const* s);
381  expr string_val(char const* s, unsigned n);
382  expr string_val(std::string const& s);
383  expr string_val(std::u32string const& s);
384 
385  expr num_val(int n, sort const & s);
386 
390  expr_vector parse_string(char const* s);
391  expr_vector parse_file(char const* file);
392 
393  expr_vector parse_string(char const* s, sort_vector const& sorts, func_decl_vector const& decls);
394  expr_vector parse_file(char const* s, sort_vector const& sorts, func_decl_vector const& decls);
395  };
396 
397  class scoped_context final {
398  context m_ctx;
399  public:
400  scoped_context(Z3_context c): m_ctx(c) {}
401  ~scoped_context() { m_ctx.detach(); }
402  context& operator()() { return m_ctx; }
403  };
404 
405 
406  template<typename T>
407  class array {
408  std::unique_ptr<T[]> m_array;
409  unsigned m_size;
410  array(array const &) = delete;
411  array & operator=(array const &) = delete;
412  public:
413  array(unsigned sz):m_array(new T[sz]),m_size(sz) {}
414  template<typename T2>
415  array(ast_vector_tpl<T2> const & v);
416  void resize(unsigned sz) { m_array.reset(new T[sz]); m_size = sz; }
417  unsigned size() const { return m_size; }
418  T & operator[](int i) { assert(0 <= i); assert(static_cast<unsigned>(i) < m_size); return m_array[i]; }
419  T const & operator[](int i) const { assert(0 <= i); assert(static_cast<unsigned>(i) < m_size); return m_array[i]; }
420  T const * ptr() const { return m_array.get(); }
421  T * ptr() { return m_array.get(); }
422  };
423 
424  class object {
425  protected:
427  public:
428  object(context & c):m_ctx(&c) {}
429  context & ctx() const { return *m_ctx; }
431  friend void check_context(object const & a, object const & b);
432  };
433  inline void check_context(object const & a, object const & b) { (void)a; (void)b; assert(a.m_ctx == b.m_ctx); }
434 
435  class symbol : public object {
436  Z3_symbol m_sym;
437  public:
438  symbol(context & c, Z3_symbol s):object(c), m_sym(s) {}
439  operator Z3_symbol() const { return m_sym; }
440  Z3_symbol_kind kind() const { return Z3_get_symbol_kind(ctx(), m_sym); }
441  std::string str() const { assert(kind() == Z3_STRING_SYMBOL); return Z3_get_symbol_string(ctx(), m_sym); }
442  int to_int() const { assert(kind() == Z3_INT_SYMBOL); return Z3_get_symbol_int(ctx(), m_sym); }
443  friend std::ostream & operator<<(std::ostream & out, symbol const & s);
444  };
445 
446  inline std::ostream & operator<<(std::ostream & out, symbol const & s) {
447  if (s.kind() == Z3_INT_SYMBOL)
448  out << "k!" << s.to_int();
449  else
450  out << s.str();
451  return out;
452  }
453 
454 
455  class param_descrs : public object {
456  Z3_param_descrs m_descrs;
457  public:
458  param_descrs(context& c, Z3_param_descrs d): object(c), m_descrs(d) { Z3_param_descrs_inc_ref(c, d); }
459  param_descrs(param_descrs const& o): object(o.ctx()), m_descrs(o.m_descrs) { Z3_param_descrs_inc_ref(ctx(), m_descrs); }
461  Z3_param_descrs_inc_ref(o.ctx(), o.m_descrs);
462  Z3_param_descrs_dec_ref(ctx(), m_descrs);
463  m_descrs = o.m_descrs;
464  object::operator=(o);
465  return *this;
466  }
469 
470  unsigned size() { return Z3_param_descrs_size(ctx(), m_descrs); }
471  symbol name(unsigned i) { return symbol(ctx(), Z3_param_descrs_get_name(ctx(), m_descrs, i)); }
472  Z3_param_kind kind(symbol const& s) { return Z3_param_descrs_get_kind(ctx(), m_descrs, s); }
473  std::string documentation(symbol const& s) { char const* r = Z3_param_descrs_get_documentation(ctx(), m_descrs, s); check_error(); return r; }
474  std::string to_string() const { return Z3_param_descrs_to_string(ctx(), m_descrs); }
475  };
476 
477  inline std::ostream& operator<<(std::ostream & out, param_descrs const & d) { return out << d.to_string(); }
478 
479  class params : public object {
480  Z3_params m_params;
481  public:
482  params(context & c):object(c) { m_params = Z3_mk_params(c); Z3_params_inc_ref(ctx(), m_params); }
483  params(params const & s):object(s), m_params(s.m_params) { Z3_params_inc_ref(ctx(), m_params); }
484  ~params() { Z3_params_dec_ref(ctx(), m_params); }
485  operator Z3_params() const { return m_params; }
486  params & operator=(params const & s) {
487  Z3_params_inc_ref(s.ctx(), s.m_params);
488  Z3_params_dec_ref(ctx(), m_params);
489  object::operator=(s);
490  m_params = s.m_params;
491  return *this;
492  }
493  void set(char const * k, bool b) { Z3_params_set_bool(ctx(), m_params, ctx().str_symbol(k), b); }
494  void set(char const * k, unsigned n) { Z3_params_set_uint(ctx(), m_params, ctx().str_symbol(k), n); }
495  void set(char const * k, double n) { Z3_params_set_double(ctx(), m_params, ctx().str_symbol(k), n); }
496  void set(char const * k, symbol const & s) { Z3_params_set_symbol(ctx(), m_params, ctx().str_symbol(k), s); }
497  void set(char const * k, char const* s) { Z3_params_set_symbol(ctx(), m_params, ctx().str_symbol(k), ctx().str_symbol(s)); }
498  friend std::ostream & operator<<(std::ostream & out, params const & p);
499  };
500 
501  inline std::ostream & operator<<(std::ostream & out, params const & p) {
502  out << Z3_params_to_string(p.ctx(), p); return out;
503  }
504 
505  class ast : public object {
506  protected:
507  Z3_ast m_ast;
508  public:
509  ast(context & c):object(c), m_ast(0) {}
510  ast(context & c, Z3_ast n):object(c), m_ast(n) { Z3_inc_ref(ctx(), m_ast); }
511  ast(ast const & s) :object(s), m_ast(s.m_ast) { Z3_inc_ref(ctx(), m_ast); }
512  ~ast() { if (m_ast) Z3_dec_ref(*m_ctx, m_ast); }
513  operator Z3_ast() const { return m_ast; }
514  operator bool() const { return m_ast != 0; }
515  ast & operator=(ast const & s) {
516  Z3_inc_ref(s.ctx(), s.m_ast);
517  if (m_ast)
518  Z3_dec_ref(ctx(), m_ast);
519  object::operator=(s);
520  m_ast = s.m_ast;
521  return *this;
522  }
523  Z3_ast_kind kind() const { Z3_ast_kind r = Z3_get_ast_kind(ctx(), m_ast); check_error(); return r; }
524  unsigned hash() const { unsigned r = Z3_get_ast_hash(ctx(), m_ast); check_error(); return r; }
525  friend std::ostream & operator<<(std::ostream & out, ast const & n);
526  std::string to_string() const { return std::string(Z3_ast_to_string(ctx(), m_ast)); }
527 
528 
532  friend bool eq(ast const & a, ast const & b);
533  };
534  inline std::ostream & operator<<(std::ostream & out, ast const & n) {
535  out << Z3_ast_to_string(n.ctx(), n.m_ast); return out;
536  }
537 
538  inline bool eq(ast const & a, ast const & b) { return Z3_is_eq_ast(a.ctx(), a, b); }
539 
540  template<typename T>
541  class ast_vector_tpl : public object {
542  Z3_ast_vector m_vector;
543  void init(Z3_ast_vector v) { Z3_ast_vector_inc_ref(ctx(), v); m_vector = v; }
544  public:
546  ast_vector_tpl(context & c, Z3_ast_vector v):object(c) { init(v); }
547  ast_vector_tpl(ast_vector_tpl const & s):object(s), m_vector(s.m_vector) { Z3_ast_vector_inc_ref(ctx(), m_vector); }
548  ast_vector_tpl(context& c, ast_vector_tpl const& src): object(c) { init(Z3_ast_vector_translate(src.ctx(), src, c)); }
549 
551  operator Z3_ast_vector() const { return m_vector; }
552  unsigned size() const { return Z3_ast_vector_size(ctx(), m_vector); }
553  T operator[](int i) const { assert(0 <= i); Z3_ast r = Z3_ast_vector_get(ctx(), m_vector, i); check_error(); return cast_ast<T>()(ctx(), r); }
554  void push_back(T const & e) { Z3_ast_vector_push(ctx(), m_vector, e); check_error(); }
555  void resize(unsigned sz) { Z3_ast_vector_resize(ctx(), m_vector, sz); check_error(); }
556  T back() const { return operator[](size() - 1); }
557  void pop_back() { assert(size() > 0); resize(size() - 1); }
558  bool empty() const { return size() == 0; }
560  Z3_ast_vector_inc_ref(s.ctx(), s.m_vector);
561  Z3_ast_vector_dec_ref(ctx(), m_vector);
562  object::operator=(s);
563  m_vector = s.m_vector;
564  return *this;
565  }
566  ast_vector_tpl& set(unsigned idx, ast& a) {
567  Z3_ast_vector_set(ctx(), m_vector, idx, a);
568  return *this;
569  }
570  /*
571  Disabled pending C++98 build upgrade
572  bool contains(T const& x) const {
573  for (T y : *this) if (eq(x, y)) return true;
574  return false;
575  }
576  */
577 
578  class iterator final {
579  ast_vector_tpl const* m_vector;
580  unsigned m_index;
581  public:
582  iterator(ast_vector_tpl const* v, unsigned i): m_vector(v), m_index(i) {}
583 
584  bool operator==(iterator const& other) const noexcept {
585  return other.m_index == m_index;
586  };
587  bool operator!=(iterator const& other) const noexcept {
588  return other.m_index != m_index;
589  };
590  iterator& operator++() noexcept {
591  ++m_index;
592  return *this;
593  }
594  void set(T& arg) {
595  Z3_ast_vector_set(m_vector->ctx(), *m_vector, m_index, arg);
596  }
597  iterator operator++(int) noexcept { iterator tmp = *this; ++m_index; return tmp; }
598  T * operator->() const { return &(operator*()); }
599  T operator*() const { return (*m_vector)[m_index]; }
600  };
601  iterator begin() const noexcept { return iterator(this, 0); }
602  iterator end() const { return iterator(this, size()); }
603  friend std::ostream & operator<<(std::ostream & out, ast_vector_tpl const & v) { out << Z3_ast_vector_to_string(v.ctx(), v); return out; }
604  std::string to_string() const { return std::string(Z3_ast_vector_to_string(ctx(), m_vector)); }
605  };
606 
607 
611  class sort : public ast {
612  public:
613  sort(context & c):ast(c) {}
614  sort(context & c, Z3_sort s):ast(c, reinterpret_cast<Z3_ast>(s)) {}
615  sort(context & c, Z3_ast a):ast(c, a) {}
616  operator Z3_sort() const { return reinterpret_cast<Z3_sort>(m_ast); }
617 
621  unsigned id() const { unsigned r = Z3_get_sort_id(ctx(), *this); check_error(); return r; }
622 
626  Z3_sort_kind sort_kind() const { return Z3_get_sort_kind(*m_ctx, *this); }
630  symbol name() const { Z3_symbol s = Z3_get_sort_name(ctx(), *this); check_error(); return symbol(ctx(), s); }
634  bool is_bool() const { return sort_kind() == Z3_BOOL_SORT; }
638  bool is_int() const { return sort_kind() == Z3_INT_SORT; }
642  bool is_real() const { return sort_kind() == Z3_REAL_SORT; }
646  bool is_arith() const { return is_int() || is_real(); }
650  bool is_bv() const { return sort_kind() == Z3_BV_SORT; }
654  bool is_array() const { return sort_kind() == Z3_ARRAY_SORT; }
658  bool is_datatype() const { return sort_kind() == Z3_DATATYPE_SORT; }
662  bool is_relation() const { return sort_kind() == Z3_RELATION_SORT; }
666  bool is_seq() const { return sort_kind() == Z3_SEQ_SORT; }
670  bool is_re() const { return sort_kind() == Z3_RE_SORT; }
674  bool is_finite_domain() const { return sort_kind() == Z3_FINITE_DOMAIN_SORT; }
678  bool is_fpa() const { return sort_kind() == Z3_FLOATING_POINT_SORT; }
679 
685  unsigned bv_size() const { assert(is_bv()); unsigned r = Z3_get_bv_sort_size(ctx(), *this); check_error(); return r; }
686 
687  unsigned fpa_ebits() const { assert(is_fpa()); unsigned r = Z3_fpa_get_ebits(ctx(), *this); check_error(); return r; }
688 
689  unsigned fpa_sbits() const { assert(is_fpa()); unsigned r = Z3_fpa_get_sbits(ctx(), *this); check_error(); return r; }
695  sort array_domain() const { assert(is_array()); Z3_sort s = Z3_get_array_sort_domain(ctx(), *this); check_error(); return sort(ctx(), s); }
701  sort array_range() const { assert(is_array()); Z3_sort s = Z3_get_array_sort_range(ctx(), *this); check_error(); return sort(ctx(), s); }
702 
703  friend std::ostream & operator<<(std::ostream & out, sort const & s) { return out << Z3_sort_to_string(s.ctx(), Z3_sort(s.m_ast)); }
704  };
705 
710  class func_decl : public ast {
711  public:
712  func_decl(context & c):ast(c) {}
713  func_decl(context & c, Z3_func_decl n):ast(c, reinterpret_cast<Z3_ast>(n)) {}
714  operator Z3_func_decl() const { return reinterpret_cast<Z3_func_decl>(m_ast); }
715 
719  unsigned id() const { unsigned r = Z3_get_func_decl_id(ctx(), *this); check_error(); return r; }
720 
721  unsigned arity() const { return Z3_get_arity(ctx(), *this); }
722  sort domain(unsigned i) const { assert(i < arity()); Z3_sort r = Z3_get_domain(ctx(), *this, i); check_error(); return sort(ctx(), r); }
723  sort range() const { Z3_sort r = Z3_get_range(ctx(), *this); check_error(); return sort(ctx(), r); }
724  symbol name() const { Z3_symbol s = Z3_get_decl_name(ctx(), *this); check_error(); return symbol(ctx(), s); }
725  Z3_decl_kind decl_kind() const { return Z3_get_decl_kind(ctx(), *this); }
726 
728  Z3_func_decl tc = Z3_mk_transitive_closure(ctx(), *this); check_error(); return func_decl(ctx(), tc);
729  }
730 
731  bool is_const() const { return arity() == 0; }
732 
733  expr operator()() const;
734  expr operator()(unsigned n, expr const * args) const;
735  expr operator()(expr_vector const& v) const;
736  expr operator()(expr const & a) const;
737  expr operator()(int a) const;
738  expr operator()(expr const & a1, expr const & a2) const;
739  expr operator()(expr const & a1, int a2) const;
740  expr operator()(int a1, expr const & a2) const;
741  expr operator()(expr const & a1, expr const & a2, expr const & a3) const;
742  expr operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4) const;
743  expr operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4, expr const & a5) const;
744  };
745 
749  expr select(expr const & a, expr const& i);
750  expr select(expr const & a, expr_vector const & i);
751 
756  class expr : public ast {
757  public:
758  expr(context & c):ast(c) {}
759  expr(context & c, Z3_ast n):ast(c, reinterpret_cast<Z3_ast>(n)) {}
760 
764  sort get_sort() const { Z3_sort s = Z3_get_sort(*m_ctx, m_ast); check_error(); return sort(*m_ctx, s); }
765 
769  bool is_bool() const { return get_sort().is_bool(); }
773  bool is_int() const { return get_sort().is_int(); }
777  bool is_real() const { return get_sort().is_real(); }
781  bool is_arith() const { return get_sort().is_arith(); }
785  bool is_bv() const { return get_sort().is_bv(); }
789  bool is_array() const { return get_sort().is_array(); }
793  bool is_datatype() const { return get_sort().is_datatype(); }
797  bool is_relation() const { return get_sort().is_relation(); }
801  bool is_seq() const { return get_sort().is_seq(); }
805  bool is_re() const { return get_sort().is_re(); }
806 
815  bool is_finite_domain() const { return get_sort().is_finite_domain(); }
819  bool is_fpa() const { return get_sort().is_fpa(); }
820 
826  bool is_numeral() const { return kind() == Z3_NUMERAL_AST; }
827  bool is_numeral_i64(int64_t& i) const { bool r = Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;}
828  bool is_numeral_u64(uint64_t& i) const { bool r = Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;}
829  bool is_numeral_i(int& i) const { bool r = Z3_get_numeral_int(ctx(), m_ast, &i); check_error(); return r;}
830  bool is_numeral_u(unsigned& i) const { bool r = Z3_get_numeral_uint(ctx(), m_ast, &i); check_error(); return r;}
831  bool is_numeral(std::string& s) const { if (!is_numeral()) return false; s = Z3_get_numeral_string(ctx(), m_ast); check_error(); return true; }
832  bool is_numeral(std::string& s, unsigned precision) const { if (!is_numeral()) return false; s = Z3_get_numeral_decimal_string(ctx(), m_ast, precision); check_error(); return true; }
833  bool is_numeral(double& d) const { if (!is_numeral()) return false; d = Z3_get_numeral_double(ctx(), m_ast); check_error(); return true; }
834  bool as_binary(std::string& s) const { if (!is_numeral()) return false; s = Z3_get_numeral_binary_string(ctx(), m_ast); check_error(); return true; }
835 
836  double as_double() const { double d = 0; is_numeral(d); return d; }
837  uint64_t as_uint64() const { uint64_t r = 0; is_numeral_u64(r); return r; }
838  int64_t as_int64() const { int64_t r = 0; is_numeral_i64(r); return r; }
839 
840 
844  bool is_app() const { return kind() == Z3_APP_AST || kind() == Z3_NUMERAL_AST; }
848  bool is_const() const { return is_app() && num_args() == 0; }
852  bool is_quantifier() const { return kind() == Z3_QUANTIFIER_AST; }
853 
857  bool is_forall() const { return Z3_is_quantifier_forall(ctx(), m_ast); }
861  bool is_exists() const { return Z3_is_quantifier_exists(ctx(), m_ast); }
865  bool is_lambda() const { return Z3_is_lambda(ctx(), m_ast); }
870  bool is_var() const { return kind() == Z3_VAR_AST; }
874  bool is_algebraic() const { return Z3_is_algebraic_number(ctx(), m_ast); }
875 
879  bool is_well_sorted() const { bool r = Z3_is_well_sorted(ctx(), m_ast); check_error(); return r; }
880 
884  expr mk_is_inf() const {
885  assert(is_fpa());
886  Z3_ast r = Z3_mk_fpa_is_infinite(ctx(), m_ast);
887  check_error();
888  return expr(ctx(), r);
889  }
890 
894  expr mk_is_nan() const {
895  assert(is_fpa());
896  Z3_ast r = Z3_mk_fpa_is_nan(ctx(), m_ast);
897  check_error();
898  return expr(ctx(), r);
899  }
900 
904  expr mk_is_normal() const {
905  assert(is_fpa());
906  Z3_ast r = Z3_mk_fpa_is_normal(ctx(), m_ast);
907  check_error();
908  return expr(ctx(), r);
909  }
910 
915  assert(is_fpa());
916  Z3_ast r = Z3_mk_fpa_is_subnormal(ctx(), m_ast);
917  check_error();
918  return expr(ctx(), r);
919  }
920 
924  expr mk_is_zero() const {
925  assert(is_fpa());
926  Z3_ast r = Z3_mk_fpa_is_zero(ctx(), m_ast);
927  check_error();
928  return expr(ctx(), r);
929  }
930 
934  expr mk_to_ieee_bv() const {
935  assert(is_fpa());
936  Z3_ast r = Z3_mk_fpa_to_ieee_bv(ctx(), m_ast);
937  check_error();
938  return expr(ctx(), r);
939  }
940 
944  expr mk_from_ieee_bv(sort const &s) const {
945  assert(is_bv());
946  Z3_ast r = Z3_mk_fpa_to_fp_bv(ctx(), m_ast, s);
947  check_error();
948  return expr(ctx(), r);
949  }
950 
957  std::string get_decimal_string(int precision) const {
958  assert(is_numeral() || is_algebraic());
959  return std::string(Z3_get_numeral_decimal_string(ctx(), m_ast, precision));
960  }
961 
965  expr algebraic_lower(unsigned precision) const {
966  assert(is_algebraic());
967  Z3_ast r = Z3_get_algebraic_number_lower(ctx(), m_ast, precision);
968  check_error();
969  return expr(ctx(), r);
970  }
971 
972  expr algebraic_upper(unsigned precision) const {
973  assert(is_algebraic());
974  Z3_ast r = Z3_get_algebraic_number_upper(ctx(), m_ast, precision);
975  check_error();
976  return expr(ctx(), r);
977  }
978 
983  assert(is_algebraic());
984  Z3_ast_vector r = Z3_algebraic_get_poly(ctx(), m_ast);
985  check_error();
986  return expr_vector(ctx(), r);
987  }
988 
992  unsigned algebraic_i() const {
993  assert(is_algebraic());
994  unsigned i = Z3_algebraic_get_i(ctx(), m_ast);
995  check_error();
996  return i;
997  }
998 
1002  unsigned id() const { unsigned r = Z3_get_ast_id(ctx(), m_ast); check_error(); return r; }
1003 
1014  int get_numeral_int() const {
1015  int result = 0;
1016  if (!is_numeral_i(result)) {
1017  assert(ctx().enable_exceptions());
1018  if (!ctx().enable_exceptions()) return 0;
1019  Z3_THROW(exception("numeral does not fit in machine int"));
1020  }
1021  return result;
1022  }
1023 
1033  unsigned get_numeral_uint() const {
1034  assert(is_numeral());
1035  unsigned result = 0;
1036  if (!is_numeral_u(result)) {
1037  assert(ctx().enable_exceptions());
1038  if (!ctx().enable_exceptions()) return 0;
1039  Z3_THROW(exception("numeral does not fit in machine uint"));
1040  }
1041  return result;
1042  }
1043 
1050  int64_t get_numeral_int64() const {
1051  assert(is_numeral());
1052  int64_t result = 0;
1053  if (!is_numeral_i64(result)) {
1054  assert(ctx().enable_exceptions());
1055  if (!ctx().enable_exceptions()) return 0;
1056  Z3_THROW(exception("numeral does not fit in machine int64_t"));
1057  }
1058  return result;
1059  }
1060 
1067  uint64_t get_numeral_uint64() const {
1068  assert(is_numeral());
1069  uint64_t result = 0;
1070  if (!is_numeral_u64(result)) {
1071  assert(ctx().enable_exceptions());
1072  if (!ctx().enable_exceptions()) return 0;
1073  Z3_THROW(exception("numeral does not fit in machine uint64_t"));
1074  }
1075  return result;
1076  }
1077 
1079  return Z3_get_bool_value(ctx(), m_ast);
1080  }
1081 
1082  expr numerator() const {
1083  assert(is_numeral());
1084  Z3_ast r = Z3_get_numerator(ctx(), m_ast);
1085  check_error();
1086  return expr(ctx(),r);
1087  }
1088 
1089 
1090  expr denominator() const {
1091  assert(is_numeral());
1092  Z3_ast r = Z3_get_denominator(ctx(), m_ast);
1093  check_error();
1094  return expr(ctx(),r);
1095  }
1096 
1097 
1102  bool is_string_value() const { return Z3_is_string(ctx(), m_ast); }
1103 
1109  std::string get_string() const {
1110  assert(is_string_value());
1111  char const* s = Z3_get_string(ctx(), m_ast);
1112  check_error();
1113  return std::string(s);
1114  }
1115 
1121  std::u32string get_u32string() const {
1122  assert(is_string_value());
1123  unsigned n = Z3_get_string_length(ctx(), m_ast);
1124  std::u32string s;
1125  s.resize(n);
1126  Z3_get_string_contents(ctx(), m_ast, n, (unsigned*)s.data());
1127  return s;
1128  }
1129 
1130  operator Z3_app() const { assert(is_app()); return reinterpret_cast<Z3_app>(m_ast); }
1131 
1138  func_decl decl() const { Z3_func_decl f = Z3_get_app_decl(ctx(), *this); check_error(); return func_decl(ctx(), f); }
1145  unsigned num_args() const { unsigned r = Z3_get_app_num_args(ctx(), *this); check_error(); return r; }
1153  expr arg(unsigned i) const { Z3_ast r = Z3_get_app_arg(ctx(), *this, i); check_error(); return expr(ctx(), r); }
1154 
1160  expr body() const { assert(is_quantifier()); Z3_ast r = Z3_get_quantifier_body(ctx(), *this); check_error(); return expr(ctx(), r); }
1161 
1167  friend expr operator!(expr const & a);
1168 
1175  friend expr operator&&(expr const & a, expr const & b);
1176 
1177 
1184  friend expr operator&&(expr const & a, bool b);
1191  friend expr operator&&(bool a, expr const & b);
1192 
1199  friend expr operator||(expr const & a, expr const & b);
1206  friend expr operator||(expr const & a, bool b);
1207 
1214  friend expr operator||(bool a, expr const & b);
1215 
1216  friend expr implies(expr const & a, expr const & b);
1217  friend expr implies(expr const & a, bool b);
1218  friend expr implies(bool a, expr const & b);
1219 
1220  friend expr mk_or(expr_vector const& args);
1221  friend expr mk_xor(expr_vector const& args);
1222  friend expr mk_and(expr_vector const& args);
1223 
1224  friend expr ite(expr const & c, expr const & t, expr const & e);
1225 
1226  bool is_true() const { return is_app() && Z3_OP_TRUE == decl().decl_kind(); }
1227  bool is_false() const { return is_app() && Z3_OP_FALSE == decl().decl_kind(); }
1228  bool is_not() const { return is_app() && Z3_OP_NOT == decl().decl_kind(); }
1229  bool is_and() const { return is_app() && Z3_OP_AND == decl().decl_kind(); }
1230  bool is_or() const { return is_app() && Z3_OP_OR == decl().decl_kind(); }
1231  bool is_xor() const { return is_app() && Z3_OP_XOR == decl().decl_kind(); }
1232  bool is_implies() const { return is_app() && Z3_OP_IMPLIES == decl().decl_kind(); }
1233  bool is_eq() const { return is_app() && Z3_OP_EQ == decl().decl_kind(); }
1234  bool is_ite() const { return is_app() && Z3_OP_ITE == decl().decl_kind(); }
1235  bool is_distinct() const { return is_app() && Z3_OP_DISTINCT == decl().decl_kind(); }
1236 
1237  friend expr distinct(expr_vector const& args);
1238  friend expr concat(expr const& a, expr const& b);
1239  friend expr concat(expr_vector const& args);
1240 
1241  friend expr operator==(expr const & a, expr const & b);
1242  friend expr operator==(expr const & a, int b);
1243  friend expr operator==(int a, expr const & b);
1244 
1245  friend expr operator!=(expr const & a, expr const & b);
1246  friend expr operator!=(expr const & a, int b);
1247  friend expr operator!=(int a, expr const & b);
1248 
1249  friend expr operator+(expr const & a, expr const & b);
1250  friend expr operator+(expr const & a, int b);
1251  friend expr operator+(int a, expr const & b);
1252  friend expr sum(expr_vector const& args);
1253 
1254  friend expr operator*(expr const & a, expr const & b);
1255  friend expr operator*(expr const & a, int b);
1256  friend expr operator*(int a, expr const & b);
1257 
1258  /* \brief Power operator */
1259  friend expr pw(expr const & a, expr const & b);
1260  friend expr pw(expr const & a, int b);
1261  friend expr pw(int a, expr const & b);
1262 
1263  /* \brief mod operator */
1264  friend expr mod(expr const& a, expr const& b);
1265  friend expr mod(expr const& a, int b);
1266  friend expr mod(int a, expr const& b);
1267 
1268  /* \brief rem operator */
1269  friend expr rem(expr const& a, expr const& b);
1270  friend expr rem(expr const& a, int b);
1271  friend expr rem(int a, expr const& b);
1272 
1273  friend expr is_int(expr const& e);
1274 
1275  friend expr operator/(expr const & a, expr const & b);
1276  friend expr operator/(expr const & a, int b);
1277  friend expr operator/(int a, expr const & b);
1278 
1279  friend expr operator-(expr const & a);
1280 
1281  friend expr operator-(expr const & a, expr const & b);
1282  friend expr operator-(expr const & a, int b);
1283  friend expr operator-(int a, expr const & b);
1284 
1285  friend expr operator<=(expr const & a, expr const & b);
1286  friend expr operator<=(expr const & a, int b);
1287  friend expr operator<=(int a, expr const & b);
1288 
1289 
1290  friend expr operator>=(expr const & a, expr const & b);
1291  friend expr operator>=(expr const & a, int b);
1292  friend expr operator>=(int a, expr const & b);
1293 
1294  friend expr operator<(expr const & a, expr const & b);
1295  friend expr operator<(expr const & a, int b);
1296  friend expr operator<(int a, expr const & b);
1297 
1298  friend expr operator>(expr const & a, expr const & b);
1299  friend expr operator>(expr const & a, int b);
1300  friend expr operator>(int a, expr const & b);
1301 
1302  friend expr pble(expr_vector const& es, int const * coeffs, int bound);
1303  friend expr pbge(expr_vector const& es, int const * coeffs, int bound);
1304  friend expr pbeq(expr_vector const& es, int const * coeffs, int bound);
1305  friend expr atmost(expr_vector const& es, unsigned bound);
1306  friend expr atleast(expr_vector const& es, unsigned bound);
1307 
1308  friend expr operator&(expr const & a, expr const & b);
1309  friend expr operator&(expr const & a, int b);
1310  friend expr operator&(int a, expr const & b);
1311 
1312  friend expr operator^(expr const & a, expr const & b);
1313  friend expr operator^(expr const & a, int b);
1314  friend expr operator^(int a, expr const & b);
1315 
1316  friend expr operator|(expr const & a, expr const & b);
1317  friend expr operator|(expr const & a, int b);
1318  friend expr operator|(int a, expr const & b);
1319  friend expr nand(expr const& a, expr const& b);
1320  friend expr nor(expr const& a, expr const& b);
1321  friend expr xnor(expr const& a, expr const& b);
1322 
1323  friend expr min(expr const& a, expr const& b);
1324  friend expr max(expr const& a, expr const& b);
1325 
1326  friend expr bv2int(expr const& a, bool is_signed);
1327  friend expr int2bv(unsigned n, expr const& a);
1328  friend expr bvadd_no_overflow(expr const& a, expr const& b, bool is_signed);
1329  friend expr bvadd_no_underflow(expr const& a, expr const& b);
1330  friend expr bvsub_no_overflow(expr const& a, expr const& b);
1331  friend expr bvsub_no_underflow(expr const& a, expr const& b, bool is_signed);
1332  friend expr bvsdiv_no_overflow(expr const& a, expr const& b);
1333  friend expr bvneg_no_overflow(expr const& a);
1334  friend expr bvmul_no_overflow(expr const& a, expr const& b, bool is_signed);
1335  friend expr bvmul_no_underflow(expr const& a, expr const& b);
1336 
1337  expr rotate_left(unsigned i) { Z3_ast r = Z3_mk_rotate_left(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1338  expr rotate_right(unsigned i) { Z3_ast r = Z3_mk_rotate_right(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1339  expr repeat(unsigned i) { Z3_ast r = Z3_mk_repeat(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1340 
1341  friend expr bvredor(expr const & a);
1342  friend expr bvredand(expr const & a);
1343 
1344  friend expr abs(expr const & a);
1345  friend expr sqrt(expr const & a, expr const & rm);
1346  friend expr fp_eq(expr const & a, expr const & b);
1347 
1348  friend expr operator~(expr const & a);
1349  expr extract(unsigned hi, unsigned lo) const { Z3_ast r = Z3_mk_extract(ctx(), hi, lo, *this); ctx().check_error(); return expr(ctx(), r); }
1350  unsigned lo() const { assert (is_app() && Z3_get_decl_num_parameters(ctx(), decl()) == 2); return static_cast<unsigned>(Z3_get_decl_int_parameter(ctx(), decl(), 1)); }
1351  unsigned hi() const { assert (is_app() && Z3_get_decl_num_parameters(ctx(), decl()) == 2); return static_cast<unsigned>(Z3_get_decl_int_parameter(ctx(), decl(), 0)); }
1352 
1356  friend expr fma(expr const& a, expr const& b, expr const& c, expr const& rm);
1357 
1361  friend expr fpa_fp(expr const& sgn, expr const& exp, expr const& sig);
1362 
1366  friend expr fpa_to_sbv(expr const& t, unsigned sz);
1367 
1371  friend expr fpa_to_ubv(expr const& t, unsigned sz);
1372 
1376  friend expr sbv_to_fpa(expr const& t, sort s);
1377 
1381  friend expr ubv_to_fpa(expr const& t, sort s);
1382 
1386  friend expr fpa_to_fpa(expr const& t, sort s);
1387 
1391  friend expr round_fpa_to_closest_integer(expr const& t);
1392 
1398  expr extract(expr const& offset, expr const& length) const {
1399  check_context(*this, offset); check_context(offset, length);
1400  Z3_ast r = Z3_mk_seq_extract(ctx(), *this, offset, length); check_error(); return expr(ctx(), r);
1401  }
1402  expr replace(expr const& src, expr const& dst) const {
1403  check_context(*this, src); check_context(src, dst);
1404  Z3_ast r = Z3_mk_seq_replace(ctx(), *this, src, dst);
1405  check_error();
1406  return expr(ctx(), r);
1407  }
1408  expr unit() const {
1409  Z3_ast r = Z3_mk_seq_unit(ctx(), *this);
1410  check_error();
1411  return expr(ctx(), r);
1412  }
1413  expr contains(expr const& s) const {
1414  check_context(*this, s);
1415  Z3_ast r = Z3_mk_seq_contains(ctx(), *this, s);
1416  check_error();
1417  return expr(ctx(), r);
1418  }
1419  expr at(expr const& index) const {
1420  check_context(*this, index);
1421  Z3_ast r = Z3_mk_seq_at(ctx(), *this, index);
1422  check_error();
1423  return expr(ctx(), r);
1424  }
1425  expr nth(expr const& index) const {
1426  check_context(*this, index);
1427  Z3_ast r = Z3_mk_seq_nth(ctx(), *this, index);
1428  check_error();
1429  return expr(ctx(), r);
1430  }
1431  expr length() const {
1432  Z3_ast r = Z3_mk_seq_length(ctx(), *this);
1433  check_error();
1434  return expr(ctx(), r);
1435  }
1436  expr stoi() const {
1437  Z3_ast r = Z3_mk_str_to_int(ctx(), *this);
1438  check_error();
1439  return expr(ctx(), r);
1440  }
1441  expr itos() const {
1442  Z3_ast r = Z3_mk_int_to_str(ctx(), *this);
1443  check_error();
1444  return expr(ctx(), r);
1445  }
1446  expr ubvtos() const {
1447  Z3_ast r = Z3_mk_ubv_to_str(ctx(), *this);
1448  check_error();
1449  return expr(ctx(), r);
1450  }
1451  expr sbvtos() const {
1452  Z3_ast r = Z3_mk_sbv_to_str(ctx(), *this);
1453  check_error();
1454  return expr(ctx(), r);
1455  }
1456  expr char_to_int() const {
1457  Z3_ast r = Z3_mk_char_to_int(ctx(), *this);
1458  check_error();
1459  return expr(ctx(), r);
1460  }
1461  expr char_to_bv() const {
1462  Z3_ast r = Z3_mk_char_to_bv(ctx(), *this);
1463  check_error();
1464  return expr(ctx(), r);
1465  }
1466  expr char_from_bv() const {
1467  Z3_ast r = Z3_mk_char_from_bv(ctx(), *this);
1468  check_error();
1469  return expr(ctx(), r);
1470  }
1471  expr is_digit() const {
1472  Z3_ast r = Z3_mk_char_is_digit(ctx(), *this);
1473  check_error();
1474  return expr(ctx(), r);
1475  }
1476 
1477  friend expr range(expr const& lo, expr const& hi);
1481  expr loop(unsigned lo) {
1482  Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, 0);
1483  check_error();
1484  return expr(ctx(), r);
1485  }
1486  expr loop(unsigned lo, unsigned hi) {
1487  Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, hi);
1488  check_error();
1489  return expr(ctx(), r);
1490  }
1491 
1495  expr operator[](expr const& index) const {
1496  assert(is_array() || is_seq());
1497  if (is_array()) {
1498  return select(*this, index);
1499  }
1500  return nth(index);
1501  }
1502 
1503  expr operator[](expr_vector const& index) const {
1504  return select(*this, index);
1505  }
1506 
1510  expr simplify() const { Z3_ast r = Z3_simplify(ctx(), m_ast); check_error(); return expr(ctx(), r); }
1514  expr simplify(params const & p) const { Z3_ast r = Z3_simplify_ex(ctx(), m_ast, p); check_error(); return expr(ctx(), r); }
1515 
1519  expr substitute(expr_vector const& src, expr_vector const& dst);
1520 
1524  expr substitute(expr_vector const& dst);
1525 
1526 
1527  class iterator {
1528  expr& e;
1529  unsigned i;
1530  public:
1531  iterator(expr& e, unsigned i): e(e), i(i) {}
1532  bool operator==(iterator const& other) noexcept {
1533  return i == other.i;
1534  }
1535  bool operator!=(iterator const& other) noexcept {
1536  return i != other.i;
1537  }
1538  expr operator*() const { return e.arg(i); }
1539  iterator& operator++() { ++i; return *this; }
1540  iterator operator++(int) { assert(false); return *this; }
1541  };
1542 
1543  iterator begin() { return iterator(*this, 0); }
1544  iterator end() { return iterator(*this, is_app() ? num_args() : 0); }
1545 
1546  };
1547 
1548 #define _Z3_MK_BIN_(a, b, binop) \
1549  check_context(a, b); \
1550  Z3_ast r = binop(a.ctx(), a, b); \
1551  a.check_error(); \
1552  return expr(a.ctx(), r); \
1553 
1554 
1555  inline expr implies(expr const & a, expr const & b) {
1556  assert(a.is_bool() && b.is_bool());
1557  _Z3_MK_BIN_(a, b, Z3_mk_implies);
1558  }
1559  inline expr implies(expr const & a, bool b) { return implies(a, a.ctx().bool_val(b)); }
1560  inline expr implies(bool a, expr const & b) { return implies(b.ctx().bool_val(a), b); }
1561 
1562 
1563  inline expr pw(expr const & a, expr const & b) { _Z3_MK_BIN_(a, b, Z3_mk_power); }
1564  inline expr pw(expr const & a, int b) { return pw(a, a.ctx().num_val(b, a.get_sort())); }
1565  inline expr pw(int a, expr const & b) { return pw(b.ctx().num_val(a, b.get_sort()), b); }
1566 
1567  inline expr mod(expr const& a, expr const& b) {
1568  if (a.is_bv()) {
1569  _Z3_MK_BIN_(a, b, Z3_mk_bvsmod);
1570  }
1571  else {
1572  _Z3_MK_BIN_(a, b, Z3_mk_mod);
1573  }
1574  }
1575  inline expr mod(expr const & a, int b) { return mod(a, a.ctx().num_val(b, a.get_sort())); }
1576  inline expr mod(int a, expr const & b) { return mod(b.ctx().num_val(a, b.get_sort()), b); }
1577 
1578  inline expr operator%(expr const& a, expr const& b) { return mod(a, b); }
1579  inline expr operator%(expr const& a, int b) { return mod(a, b); }
1580  inline expr operator%(int a, expr const& b) { return mod(a, b); }
1581 
1582 
1583  inline expr rem(expr const& a, expr const& b) {
1584  if (a.is_fpa() && b.is_fpa()) {
1585  _Z3_MK_BIN_(a, b, Z3_mk_fpa_rem);
1586  } else {
1587  _Z3_MK_BIN_(a, b, Z3_mk_rem);
1588  }
1589  }
1590  inline expr rem(expr const & a, int b) { return rem(a, a.ctx().num_val(b, a.get_sort())); }
1591  inline expr rem(int a, expr const & b) { return rem(b.ctx().num_val(a, b.get_sort()), b); }
1592 
1593 #undef _Z3_MK_BIN_
1594 
1595 #define _Z3_MK_UN_(a, mkun) \
1596  Z3_ast r = mkun(a.ctx(), a); \
1597  a.check_error(); \
1598  return expr(a.ctx(), r); \
1599 
1600 
1601  inline expr operator!(expr const & a) { assert(a.is_bool()); _Z3_MK_UN_(a, Z3_mk_not); }
1602 
1603  inline expr is_int(expr const& e) { _Z3_MK_UN_(e, Z3_mk_is_int); }
1604 
1605 #undef _Z3_MK_UN_
1606 
1607  inline expr operator&&(expr const & a, expr const & b) {
1608  check_context(a, b);
1609  assert(a.is_bool() && b.is_bool());
1610  Z3_ast args[2] = { a, b };
1611  Z3_ast r = Z3_mk_and(a.ctx(), 2, args);
1612  a.check_error();
1613  return expr(a.ctx(), r);
1614  }
1615 
1616  inline expr operator&&(expr const & a, bool b) { return a && a.ctx().bool_val(b); }
1617  inline expr operator&&(bool a, expr const & b) { return b.ctx().bool_val(a) && b; }
1618 
1619  inline expr operator||(expr const & a, expr const & b) {
1620  check_context(a, b);
1621  assert(a.is_bool() && b.is_bool());
1622  Z3_ast args[2] = { a, b };
1623  Z3_ast r = Z3_mk_or(a.ctx(), 2, args);
1624  a.check_error();
1625  return expr(a.ctx(), r);
1626  }
1627 
1628  inline expr operator||(expr const & a, bool b) { return a || a.ctx().bool_val(b); }
1629 
1630  inline expr operator||(bool a, expr const & b) { return b.ctx().bool_val(a) || b; }
1631 
1632  inline expr operator==(expr const & a, expr const & b) {
1633  check_context(a, b);
1634  Z3_ast r = Z3_mk_eq(a.ctx(), a, b);
1635  a.check_error();
1636  return expr(a.ctx(), r);
1637  }
1638  inline expr operator==(expr const & a, int b) { assert(a.is_arith() || a.is_bv() || a.is_fpa()); return a == a.ctx().num_val(b, a.get_sort()); }
1639  inline expr operator==(int a, expr const & b) { assert(b.is_arith() || b.is_bv() || b.is_fpa()); return b.ctx().num_val(a, b.get_sort()) == b; }
1640  inline expr operator==(expr const & a, double b) { assert(a.is_fpa()); return a == a.ctx().fpa_val(b); }
1641  inline expr operator==(double a, expr const & b) { assert(b.is_fpa()); return b.ctx().fpa_val(a) == b; }
1642 
1643  inline expr operator!=(expr const & a, expr const & b) {
1644  check_context(a, b);
1645  Z3_ast args[2] = { a, b };
1646  Z3_ast r = Z3_mk_distinct(a.ctx(), 2, args);
1647  a.check_error();
1648  return expr(a.ctx(), r);
1649  }
1650  inline expr operator!=(expr const & a, int b) { assert(a.is_arith() || a.is_bv() || a.is_fpa()); return a != a.ctx().num_val(b, a.get_sort()); }
1651  inline expr operator!=(int a, expr const & b) { assert(b.is_arith() || b.is_bv() || b.is_fpa()); return b.ctx().num_val(a, b.get_sort()) != b; }
1652  inline expr operator!=(expr const & a, double b) { assert(a.is_fpa()); return a != a.ctx().fpa_val(b); }
1653  inline expr operator!=(double a, expr const & b) { assert(b.is_fpa()); return b.ctx().fpa_val(a) != b; }
1654 
1655  inline expr operator+(expr const & a, expr const & b) {
1656  check_context(a, b);
1657  Z3_ast r = 0;
1658  if (a.is_arith() && b.is_arith()) {
1659  Z3_ast args[2] = { a, b };
1660  r = Z3_mk_add(a.ctx(), 2, args);
1661  }
1662  else if (a.is_bv() && b.is_bv()) {
1663  r = Z3_mk_bvadd(a.ctx(), a, b);
1664  }
1665  else if (a.is_seq() && b.is_seq()) {
1666  return concat(a, b);
1667  }
1668  else if (a.is_re() && b.is_re()) {
1669  Z3_ast _args[2] = { a, b };
1670  r = Z3_mk_re_union(a.ctx(), 2, _args);
1671  }
1672  else if (a.is_fpa() && b.is_fpa()) {
1673  r = Z3_mk_fpa_add(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1674  }
1675  else {
1676  // operator is not supported by given arguments.
1677  assert(false);
1678  }
1679  a.check_error();
1680  return expr(a.ctx(), r);
1681  }
1682  inline expr operator+(expr const & a, int b) { return a + a.ctx().num_val(b, a.get_sort()); }
1683  inline expr operator+(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) + b; }
1684 
1685  inline expr operator*(expr const & a, expr const & b) {
1686  check_context(a, b);
1687  Z3_ast r = 0;
1688  if (a.is_arith() && b.is_arith()) {
1689  Z3_ast args[2] = { a, b };
1690  r = Z3_mk_mul(a.ctx(), 2, args);
1691  }
1692  else if (a.is_bv() && b.is_bv()) {
1693  r = Z3_mk_bvmul(a.ctx(), a, b);
1694  }
1695  else if (a.is_fpa() && b.is_fpa()) {
1696  r = Z3_mk_fpa_mul(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1697  }
1698  else {
1699  // operator is not supported by given arguments.
1700  assert(false);
1701  }
1702  a.check_error();
1703  return expr(a.ctx(), r);
1704  }
1705  inline expr operator*(expr const & a, int b) { return a * a.ctx().num_val(b, a.get_sort()); }
1706  inline expr operator*(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) * b; }
1707 
1708 
1709  inline expr operator>=(expr const & a, expr const & b) {
1710  check_context(a, b);
1711  Z3_ast r = 0;
1712  if (a.is_arith() && b.is_arith()) {
1713  r = Z3_mk_ge(a.ctx(), a, b);
1714  }
1715  else if (a.is_bv() && b.is_bv()) {
1716  r = Z3_mk_bvsge(a.ctx(), a, b);
1717  }
1718  else if (a.is_fpa() && b.is_fpa()) {
1719  r = Z3_mk_fpa_geq(a.ctx(), a, b);
1720  }
1721  else {
1722  // operator is not supported by given arguments.
1723  assert(false);
1724  }
1725  a.check_error();
1726  return expr(a.ctx(), r);
1727  }
1728 
1729  inline expr operator/(expr const & a, expr const & b) {
1730  check_context(a, b);
1731  Z3_ast r = 0;
1732  if (a.is_arith() && b.is_arith()) {
1733  r = Z3_mk_div(a.ctx(), a, b);
1734  }
1735  else if (a.is_bv() && b.is_bv()) {
1736  r = Z3_mk_bvsdiv(a.ctx(), a, b);
1737  }
1738  else if (a.is_fpa() && b.is_fpa()) {
1739  r = Z3_mk_fpa_div(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1740  }
1741  else {
1742  // operator is not supported by given arguments.
1743  assert(false);
1744  }
1745  a.check_error();
1746  return expr(a.ctx(), r);
1747  }
1748  inline expr operator/(expr const & a, int b) { return a / a.ctx().num_val(b, a.get_sort()); }
1749  inline expr operator/(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) / b; }
1750 
1751  inline expr operator-(expr const & a) {
1752  Z3_ast r = 0;
1753  if (a.is_arith()) {
1754  r = Z3_mk_unary_minus(a.ctx(), a);
1755  }
1756  else if (a.is_bv()) {
1757  r = Z3_mk_bvneg(a.ctx(), a);
1758  }
1759  else if (a.is_fpa()) {
1760  r = Z3_mk_fpa_neg(a.ctx(), a);
1761  }
1762  else {
1763  // operator is not supported by given arguments.
1764  assert(false);
1765  }
1766  a.check_error();
1767  return expr(a.ctx(), r);
1768  }
1769 
1770  inline expr operator-(expr const & a, expr const & b) {
1771  check_context(a, b);
1772  Z3_ast r = 0;
1773  if (a.is_arith() && b.is_arith()) {
1774  Z3_ast args[2] = { a, b };
1775  r = Z3_mk_sub(a.ctx(), 2, args);
1776  }
1777  else if (a.is_bv() && b.is_bv()) {
1778  r = Z3_mk_bvsub(a.ctx(), a, b);
1779  }
1780  else if (a.is_fpa() && b.is_fpa()) {
1781  r = Z3_mk_fpa_sub(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1782  }
1783  else {
1784  // operator is not supported by given arguments.
1785  assert(false);
1786  }
1787  a.check_error();
1788  return expr(a.ctx(), r);
1789  }
1790  inline expr operator-(expr const & a, int b) { return a - a.ctx().num_val(b, a.get_sort()); }
1791  inline expr operator-(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) - b; }
1792 
1793  inline expr operator<=(expr const & a, expr const & b) {
1794  check_context(a, b);
1795  Z3_ast r = 0;
1796  if (a.is_arith() && b.is_arith()) {
1797  r = Z3_mk_le(a.ctx(), a, b);
1798  }
1799  else if (a.is_bv() && b.is_bv()) {
1800  r = Z3_mk_bvsle(a.ctx(), a, b);
1801  }
1802  else if (a.is_fpa() && b.is_fpa()) {
1803  r = Z3_mk_fpa_leq(a.ctx(), a, b);
1804  }
1805  else {
1806  // operator is not supported by given arguments.
1807  assert(false);
1808  }
1809  a.check_error();
1810  return expr(a.ctx(), r);
1811  }
1812  inline expr operator<=(expr const & a, int b) { return a <= a.ctx().num_val(b, a.get_sort()); }
1813  inline expr operator<=(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) <= b; }
1814 
1815  inline expr operator>=(expr const & a, int b) { return a >= a.ctx().num_val(b, a.get_sort()); }
1816  inline expr operator>=(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) >= b; }
1817 
1818  inline expr operator<(expr const & a, expr const & b) {
1819  check_context(a, b);
1820  Z3_ast r = 0;
1821  if (a.is_arith() && b.is_arith()) {
1822  r = Z3_mk_lt(a.ctx(), a, b);
1823  }
1824  else if (a.is_bv() && b.is_bv()) {
1825  r = Z3_mk_bvslt(a.ctx(), a, b);
1826  }
1827  else if (a.is_fpa() && b.is_fpa()) {
1828  r = Z3_mk_fpa_lt(a.ctx(), a, b);
1829  }
1830  else {
1831  // operator is not supported by given arguments.
1832  assert(false);
1833  }
1834  a.check_error();
1835  return expr(a.ctx(), r);
1836  }
1837  inline expr operator<(expr const & a, int b) { return a < a.ctx().num_val(b, a.get_sort()); }
1838  inline expr operator<(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) < b; }
1839 
1840  inline expr operator>(expr const & a, expr const & b) {
1841  check_context(a, b);
1842  Z3_ast r = 0;
1843  if (a.is_arith() && b.is_arith()) {
1844  r = Z3_mk_gt(a.ctx(), a, b);
1845  }
1846  else if (a.is_bv() && b.is_bv()) {
1847  r = Z3_mk_bvsgt(a.ctx(), a, b);
1848  }
1849  else if (a.is_fpa() && b.is_fpa()) {
1850  r = Z3_mk_fpa_gt(a.ctx(), a, b);
1851  }
1852  else {
1853  // operator is not supported by given arguments.
1854  assert(false);
1855  }
1856  a.check_error();
1857  return expr(a.ctx(), r);
1858  }
1859  inline expr operator>(expr const & a, int b) { return a > a.ctx().num_val(b, a.get_sort()); }
1860  inline expr operator>(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) > b; }
1861 
1862  inline expr operator&(expr const & a, expr const & b) { if (a.is_bool()) return a && b; check_context(a, b); Z3_ast r = Z3_mk_bvand(a.ctx(), a, b); return expr(a.ctx(), r); }
1863  inline expr operator&(expr const & a, int b) { return a & a.ctx().num_val(b, a.get_sort()); }
1864  inline expr operator&(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) & b; }
1865 
1866  inline expr operator^(expr const & a, expr const & b) { check_context(a, b); Z3_ast r = a.is_bool() ? Z3_mk_xor(a.ctx(), a, b) : Z3_mk_bvxor(a.ctx(), a, b); return expr(a.ctx(), r); }
1867  inline expr operator^(expr const & a, int b) { return a ^ a.ctx().num_val(b, a.get_sort()); }
1868  inline expr operator^(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) ^ b; }
1869 
1870  inline expr operator|(expr const & a, expr const & b) { if (a.is_bool()) return a || b; check_context(a, b); Z3_ast r = Z3_mk_bvor(a.ctx(), a, b); return expr(a.ctx(), r); }
1871  inline expr operator|(expr const & a, int b) { return a | a.ctx().num_val(b, a.get_sort()); }
1872  inline expr operator|(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) | b; }
1873 
1874  inline expr nand(expr const& a, expr const& b) { if (a.is_bool()) return !(a && b); check_context(a, b); Z3_ast r = Z3_mk_bvnand(a.ctx(), a, b); return expr(a.ctx(), r); }
1875  inline expr nor(expr const& a, expr const& b) { if (a.is_bool()) return !(a || b); check_context(a, b); Z3_ast r = Z3_mk_bvnor(a.ctx(), a, b); return expr(a.ctx(), r); }
1876  inline expr xnor(expr const& a, expr const& b) { if (a.is_bool()) return !(a ^ b); check_context(a, b); Z3_ast r = Z3_mk_bvxnor(a.ctx(), a, b); return expr(a.ctx(), r); }
1877  inline expr min(expr const& a, expr const& b) {
1878  check_context(a, b);
1879  Z3_ast r;
1880  if (a.is_arith()) {
1881  r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), b, a);
1882  }
1883  else if (a.is_bv()) {
1884  r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), b, a);
1885  }
1886  else {
1887  assert(a.is_fpa());
1888  r = Z3_mk_fpa_min(a.ctx(), a, b);
1889  }
1890  return expr(a.ctx(), r);
1891  }
1892  inline expr max(expr const& a, expr const& b) {
1893  check_context(a, b);
1894  Z3_ast r;
1895  if (a.is_arith()) {
1896  r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), a, b);
1897  }
1898  else if (a.is_bv()) {
1899  r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), a, b);
1900  }
1901  else {
1902  assert(a.is_fpa());
1903  r = Z3_mk_fpa_max(a.ctx(), a, b);
1904  }
1905  return expr(a.ctx(), r);
1906  }
1907  inline expr bvredor(expr const & a) {
1908  assert(a.is_bv());
1909  Z3_ast r = Z3_mk_bvredor(a.ctx(), a);
1910  a.check_error();
1911  return expr(a.ctx(), r);
1912  }
1913  inline expr bvredand(expr const & a) {
1914  assert(a.is_bv());
1915  Z3_ast r = Z3_mk_bvredand(a.ctx(), a);
1916  a.check_error();
1917  return expr(a.ctx(), r);
1918  }
1919  inline expr abs(expr const & a) {
1920  Z3_ast r;
1921  if (a.is_int()) {
1922  expr zero = a.ctx().int_val(0);
1923  expr ge = a >= zero;
1924  expr na = -a;
1925  r = Z3_mk_ite(a.ctx(), ge, a, na);
1926  }
1927  else if (a.is_real()) {
1928  expr zero = a.ctx().real_val(0);
1929  expr ge = a >= zero;
1930  expr na = -a;
1931  r = Z3_mk_ite(a.ctx(), ge, a, na);
1932  }
1933  else {
1934  r = Z3_mk_fpa_abs(a.ctx(), a);
1935  }
1936  a.check_error();
1937  return expr(a.ctx(), r);
1938  }
1939  inline expr sqrt(expr const & a, expr const& rm) {
1940  check_context(a, rm);
1941  assert(a.is_fpa());
1942  Z3_ast r = Z3_mk_fpa_sqrt(a.ctx(), rm, a);
1943  a.check_error();
1944  return expr(a.ctx(), r);
1945  }
1946  inline expr fp_eq(expr const & a, expr const & b) {
1947  check_context(a, b);
1948  assert(a.is_fpa());
1949  Z3_ast r = Z3_mk_fpa_eq(a.ctx(), a, b);
1950  a.check_error();
1951  return expr(a.ctx(), r);
1952  }
1953  inline expr operator~(expr const & a) { Z3_ast r = Z3_mk_bvnot(a.ctx(), a); return expr(a.ctx(), r); }
1954 
1955  inline expr fma(expr const& a, expr const& b, expr const& c, expr const& rm) {
1956  check_context(a, b); check_context(a, c); check_context(a, rm);
1957  assert(a.is_fpa() && b.is_fpa() && c.is_fpa());
1958  Z3_ast r = Z3_mk_fpa_fma(a.ctx(), rm, a, b, c);
1959  a.check_error();
1960  return expr(a.ctx(), r);
1961  }
1962 
1963  inline expr fpa_fp(expr const& sgn, expr const& exp, expr const& sig) {
1964  check_context(sgn, exp); check_context(exp, sig);
1965  assert(sgn.is_bv() && exp.is_bv() && sig.is_bv());
1966  Z3_ast r = Z3_mk_fpa_fp(sgn.ctx(), sgn, exp, sig);
1967  sgn.check_error();
1968  return expr(sgn.ctx(), r);
1969  }
1970 
1971  inline expr fpa_to_sbv(expr const& t, unsigned sz) {
1972  assert(t.is_fpa());
1973  Z3_ast r = Z3_mk_fpa_to_sbv(t.ctx(), t.ctx().fpa_rounding_mode(), t, sz);
1974  t.check_error();
1975  return expr(t.ctx(), r);
1976  }
1977 
1978  inline expr fpa_to_ubv(expr const& t, unsigned sz) {
1979  assert(t.is_fpa());
1980  Z3_ast r = Z3_mk_fpa_to_ubv(t.ctx(), t.ctx().fpa_rounding_mode(), t, sz);
1981  t.check_error();
1982  return expr(t.ctx(), r);
1983  }
1984 
1985  inline expr sbv_to_fpa(expr const& t, sort s) {
1986  assert(t.is_bv());
1987  Z3_ast r = Z3_mk_fpa_to_fp_signed(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
1988  t.check_error();
1989  return expr(t.ctx(), r);
1990  }
1991 
1992  inline expr ubv_to_fpa(expr const& t, sort s) {
1993  assert(t.is_bv());
1994  Z3_ast r = Z3_mk_fpa_to_fp_unsigned(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
1995  t.check_error();
1996  return expr(t.ctx(), r);
1997  }
1998 
1999  inline expr fpa_to_fpa(expr const& t, sort s) {
2000  assert(t.is_fpa());
2001  Z3_ast r = Z3_mk_fpa_to_fp_float(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2002  t.check_error();
2003  return expr(t.ctx(), r);
2004  }
2005 
2007  assert(t.is_fpa());
2008  Z3_ast r = Z3_mk_fpa_round_to_integral(t.ctx(), t.ctx().fpa_rounding_mode(), t);
2009  t.check_error();
2010  return expr(t.ctx(), r);
2011  }
2012 
2018  inline expr ite(expr const & c, expr const & t, expr const & e) {
2019  check_context(c, t); check_context(c, e);
2020  assert(c.is_bool());
2021  Z3_ast r = Z3_mk_ite(c.ctx(), c, t, e);
2022  c.check_error();
2023  return expr(c.ctx(), r);
2024  }
2025 
2026 
2031  inline expr to_expr(context & c, Z3_ast a) {
2032  c.check_error();
2033  assert(Z3_get_ast_kind(c, a) == Z3_APP_AST ||
2034  Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST ||
2035  Z3_get_ast_kind(c, a) == Z3_VAR_AST ||
2037  return expr(c, a);
2038  }
2039 
2040  inline sort to_sort(context & c, Z3_sort s) {
2041  c.check_error();
2042  return sort(c, s);
2043  }
2044 
2045  inline func_decl to_func_decl(context & c, Z3_func_decl f) {
2046  c.check_error();
2047  return func_decl(c, f);
2048  }
2049 
2053  inline expr sle(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsle(a.ctx(), a, b)); }
2054  inline expr sle(expr const & a, int b) { return sle(a, a.ctx().num_val(b, a.get_sort())); }
2055  inline expr sle(int a, expr const & b) { return sle(b.ctx().num_val(a, b.get_sort()), b); }
2059  inline expr slt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvslt(a.ctx(), a, b)); }
2060  inline expr slt(expr const & a, int b) { return slt(a, a.ctx().num_val(b, a.get_sort())); }
2061  inline expr slt(int a, expr const & b) { return slt(b.ctx().num_val(a, b.get_sort()), b); }
2065  inline expr sge(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsge(a.ctx(), a, b)); }
2066  inline expr sge(expr const & a, int b) { return sge(a, a.ctx().num_val(b, a.get_sort())); }
2067  inline expr sge(int a, expr const & b) { return sge(b.ctx().num_val(a, b.get_sort()), b); }
2071  inline expr sgt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsgt(a.ctx(), a, b)); }
2072  inline expr sgt(expr const & a, int b) { return sgt(a, a.ctx().num_val(b, a.get_sort())); }
2073  inline expr sgt(int a, expr const & b) { return sgt(b.ctx().num_val(a, b.get_sort()), b); }
2074 
2075 
2079  inline expr ule(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvule(a.ctx(), a, b)); }
2080  inline expr ule(expr const & a, int b) { return ule(a, a.ctx().num_val(b, a.get_sort())); }
2081  inline expr ule(int a, expr const & b) { return ule(b.ctx().num_val(a, b.get_sort()), b); }
2085  inline expr ult(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvult(a.ctx(), a, b)); }
2086  inline expr ult(expr const & a, int b) { return ult(a, a.ctx().num_val(b, a.get_sort())); }
2087  inline expr ult(int a, expr const & b) { return ult(b.ctx().num_val(a, b.get_sort()), b); }
2091  inline expr uge(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b)); }
2092  inline expr uge(expr const & a, int b) { return uge(a, a.ctx().num_val(b, a.get_sort())); }
2093  inline expr uge(int a, expr const & b) { return uge(b.ctx().num_val(a, b.get_sort()), b); }
2097  inline expr ugt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvugt(a.ctx(), a, b)); }
2098  inline expr ugt(expr const & a, int b) { return ugt(a, a.ctx().num_val(b, a.get_sort())); }
2099  inline expr ugt(int a, expr const & b) { return ugt(b.ctx().num_val(a, b.get_sort()), b); }
2103  inline expr udiv(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvudiv(a.ctx(), a, b)); }
2104  inline expr udiv(expr const & a, int b) { return udiv(a, a.ctx().num_val(b, a.get_sort())); }
2105  inline expr udiv(int a, expr const & b) { return udiv(b.ctx().num_val(a, b.get_sort()), b); }
2106 
2110  inline expr srem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsrem(a.ctx(), a, b)); }
2111  inline expr srem(expr const & a, int b) { return srem(a, a.ctx().num_val(b, a.get_sort())); }
2112  inline expr srem(int a, expr const & b) { return srem(b.ctx().num_val(a, b.get_sort()), b); }
2113 
2117  inline expr smod(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsmod(a.ctx(), a, b)); }
2118  inline expr smod(expr const & a, int b) { return smod(a, a.ctx().num_val(b, a.get_sort())); }
2119  inline expr smod(int a, expr const & b) { return smod(b.ctx().num_val(a, b.get_sort()), b); }
2120 
2124  inline expr urem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvurem(a.ctx(), a, b)); }
2125  inline expr urem(expr const & a, int b) { return urem(a, a.ctx().num_val(b, a.get_sort())); }
2126  inline expr urem(int a, expr const & b) { return urem(b.ctx().num_val(a, b.get_sort()), b); }
2127 
2131  inline expr shl(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvshl(a.ctx(), a, b)); }
2132  inline expr shl(expr const & a, int b) { return shl(a, a.ctx().num_val(b, a.get_sort())); }
2133  inline expr shl(int a, expr const & b) { return shl(b.ctx().num_val(a, b.get_sort()), b); }
2134 
2138  inline expr lshr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvlshr(a.ctx(), a, b)); }
2139  inline expr lshr(expr const & a, int b) { return lshr(a, a.ctx().num_val(b, a.get_sort())); }
2140  inline expr lshr(int a, expr const & b) { return lshr(b.ctx().num_val(a, b.get_sort()), b); }
2141 
2145  inline expr ashr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvashr(a.ctx(), a, b)); }
2146  inline expr ashr(expr const & a, int b) { return ashr(a, a.ctx().num_val(b, a.get_sort())); }
2147  inline expr ashr(int a, expr const & b) { return ashr(b.ctx().num_val(a, b.get_sort()), b); }
2148 
2152  inline expr zext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_zero_ext(a.ctx(), i, a)); }
2153 
2157  inline expr bv2int(expr const& a, bool is_signed) { Z3_ast r = Z3_mk_bv2int(a.ctx(), a, is_signed); a.check_error(); return expr(a.ctx(), r); }
2158  inline expr int2bv(unsigned n, expr const& a) { Z3_ast r = Z3_mk_int2bv(a.ctx(), n, a); a.check_error(); return expr(a.ctx(), r); }
2159 
2163  inline expr bvadd_no_overflow(expr const& a, expr const& b, bool is_signed) {
2164  check_context(a, b); Z3_ast r = Z3_mk_bvadd_no_overflow(a.ctx(), a, b, is_signed); a.check_error(); return expr(a.ctx(), r);
2165  }
2166  inline expr bvadd_no_underflow(expr const& a, expr const& b) {
2167  check_context(a, b); Z3_ast r = Z3_mk_bvadd_no_underflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2168  }
2169  inline expr bvsub_no_overflow(expr const& a, expr const& b) {
2170  check_context(a, b); Z3_ast r = Z3_mk_bvsub_no_overflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2171  }
2172  inline expr bvsub_no_underflow(expr const& a, expr const& b, bool is_signed) {
2173  check_context(a, b); Z3_ast r = Z3_mk_bvsub_no_underflow(a.ctx(), a, b, is_signed); a.check_error(); return expr(a.ctx(), r);
2174  }
2175  inline expr bvsdiv_no_overflow(expr const& a, expr const& b) {
2176  check_context(a, b); Z3_ast r = Z3_mk_bvsdiv_no_overflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2177  }
2178  inline expr bvneg_no_overflow(expr const& a) {
2179  Z3_ast r = Z3_mk_bvneg_no_overflow(a.ctx(), a); a.check_error(); return expr(a.ctx(), r);
2180  }
2181  inline expr bvmul_no_overflow(expr const& a, expr const& b, bool is_signed) {
2182  check_context(a, b); Z3_ast r = Z3_mk_bvmul_no_overflow(a.ctx(), a, b, is_signed); a.check_error(); return expr(a.ctx(), r);
2183  }
2184  inline expr bvmul_no_underflow(expr const& a, expr const& b) {
2185  check_context(a, b); Z3_ast r = Z3_mk_bvmul_no_underflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2186  }
2187 
2188 
2192  inline expr sext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_sign_ext(a.ctx(), i, a)); }
2193 
2194  inline func_decl linear_order(sort const& a, unsigned index) {
2195  return to_func_decl(a.ctx(), Z3_mk_linear_order(a.ctx(), a, index));
2196  }
2197  inline func_decl partial_order(sort const& a, unsigned index) {
2198  return to_func_decl(a.ctx(), Z3_mk_partial_order(a.ctx(), a, index));
2199  }
2200  inline func_decl piecewise_linear_order(sort const& a, unsigned index) {
2201  return to_func_decl(a.ctx(), Z3_mk_piecewise_linear_order(a.ctx(), a, index));
2202  }
2203  inline func_decl tree_order(sort const& a, unsigned index) {
2204  return to_func_decl(a.ctx(), Z3_mk_tree_order(a.ctx(), a, index));
2205  }
2206 
2207  template<> class cast_ast<ast> {
2208  public:
2209  ast operator()(context & c, Z3_ast a) { return ast(c, a); }
2210  };
2211 
2212  template<> class cast_ast<expr> {
2213  public:
2214  expr operator()(context & c, Z3_ast a) {
2215  assert(Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST ||
2216  Z3_get_ast_kind(c, a) == Z3_APP_AST ||
2218  Z3_get_ast_kind(c, a) == Z3_VAR_AST);
2219  return expr(c, a);
2220  }
2221  };
2222 
2223  template<> class cast_ast<sort> {
2224  public:
2225  sort operator()(context & c, Z3_ast a) {
2226  assert(Z3_get_ast_kind(c, a) == Z3_SORT_AST);
2227  return sort(c, reinterpret_cast<Z3_sort>(a));
2228  }
2229  };
2230 
2231  template<> class cast_ast<func_decl> {
2232  public:
2233  func_decl operator()(context & c, Z3_ast a) {
2234  assert(Z3_get_ast_kind(c, a) == Z3_FUNC_DECL_AST);
2235  return func_decl(c, reinterpret_cast<Z3_func_decl>(a));
2236  }
2237  };
2238 
2239  template<typename T>
2240  template<typename T2>
2241  array<T>::array(ast_vector_tpl<T2> const & v):m_array(new T[v.size()]), m_size(v.size()) {
2242  for (unsigned i = 0; i < m_size; i++) {
2243  m_array[i] = v[i];
2244  }
2245  }
2246 
2247  // Basic functions for creating quantified formulas.
2248  // The C API should be used for creating quantifiers with patterns, weights, many variables, etc.
2249  inline expr forall(expr const & x, expr const & b) {
2250  check_context(x, b);
2251  Z3_app vars[] = {(Z3_app) x};
2252  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 1, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2253  }
2254  inline expr forall(expr const & x1, expr const & x2, expr const & b) {
2255  check_context(x1, b); check_context(x2, b);
2256  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2257  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 2, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2258  }
2259  inline expr forall(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2260  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2261  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2262  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 3, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2263  }
2264  inline expr forall(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2265  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2266  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2267  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 4, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2268  }
2269  inline expr forall(expr_vector const & xs, expr const & b) {
2270  array<Z3_app> vars(xs);
2271  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, vars.size(), vars.ptr(), 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2272  }
2273  inline expr exists(expr const & x, expr const & b) {
2274  check_context(x, b);
2275  Z3_app vars[] = {(Z3_app) x};
2276  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 1, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2277  }
2278  inline expr exists(expr const & x1, expr const & x2, expr const & b) {
2279  check_context(x1, b); check_context(x2, b);
2280  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2281  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 2, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2282  }
2283  inline expr exists(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2284  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2285  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2286  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 3, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2287  }
2288  inline expr exists(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2289  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2290  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2291  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 4, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2292  }
2293  inline expr exists(expr_vector const & xs, expr const & b) {
2294  array<Z3_app> vars(xs);
2295  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, vars.size(), vars.ptr(), 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2296  }
2297  inline expr lambda(expr const & x, expr const & b) {
2298  check_context(x, b);
2299  Z3_app vars[] = {(Z3_app) x};
2300  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 1, vars, b); b.check_error(); return expr(b.ctx(), r);
2301  }
2302  inline expr lambda(expr const & x1, expr const & x2, expr const & b) {
2303  check_context(x1, b); check_context(x2, b);
2304  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2305  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 2, vars, b); b.check_error(); return expr(b.ctx(), r);
2306  }
2307  inline expr lambda(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2308  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2309  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2310  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 3, vars, b); b.check_error(); return expr(b.ctx(), r);
2311  }
2312  inline expr lambda(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2313  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2314  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2315  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 4, vars, b); b.check_error(); return expr(b.ctx(), r);
2316  }
2317  inline expr lambda(expr_vector const & xs, expr const & b) {
2318  array<Z3_app> vars(xs);
2319  Z3_ast r = Z3_mk_lambda_const(b.ctx(), vars.size(), vars.ptr(), b); b.check_error(); return expr(b.ctx(), r);
2320  }
2321 
2322  inline expr pble(expr_vector const& es, int const* coeffs, int bound) {
2323  assert(es.size() > 0);
2324  context& ctx = es[0].ctx();
2325  array<Z3_ast> _es(es);
2326  Z3_ast r = Z3_mk_pble(ctx, _es.size(), _es.ptr(), coeffs, bound);
2327  ctx.check_error();
2328  return expr(ctx, r);
2329  }
2330  inline expr pbge(expr_vector const& es, int const* coeffs, int bound) {
2331  assert(es.size() > 0);
2332  context& ctx = es[0].ctx();
2333  array<Z3_ast> _es(es);
2334  Z3_ast r = Z3_mk_pbge(ctx, _es.size(), _es.ptr(), coeffs, bound);
2335  ctx.check_error();
2336  return expr(ctx, r);
2337  }
2338  inline expr pbeq(expr_vector const& es, int const* coeffs, int bound) {
2339  assert(es.size() > 0);
2340  context& ctx = es[0].ctx();
2341  array<Z3_ast> _es(es);
2342  Z3_ast r = Z3_mk_pbeq(ctx, _es.size(), _es.ptr(), coeffs, bound);
2343  ctx.check_error();
2344  return expr(ctx, r);
2345  }
2346  inline expr atmost(expr_vector const& es, unsigned bound) {
2347  assert(es.size() > 0);
2348  context& ctx = es[0].ctx();
2349  array<Z3_ast> _es(es);
2350  Z3_ast r = Z3_mk_atmost(ctx, _es.size(), _es.ptr(), bound);
2351  ctx.check_error();
2352  return expr(ctx, r);
2353  }
2354  inline expr atleast(expr_vector const& es, unsigned bound) {
2355  assert(es.size() > 0);
2356  context& ctx = es[0].ctx();
2357  array<Z3_ast> _es(es);
2358  Z3_ast r = Z3_mk_atleast(ctx, _es.size(), _es.ptr(), bound);
2359  ctx.check_error();
2360  return expr(ctx, r);
2361  }
2362  inline expr sum(expr_vector const& args) {
2363  assert(args.size() > 0);
2364  context& ctx = args[0].ctx();
2365  array<Z3_ast> _args(args);
2366  Z3_ast r = Z3_mk_add(ctx, _args.size(), _args.ptr());
2367  ctx.check_error();
2368  return expr(ctx, r);
2369  }
2370 
2371  inline expr distinct(expr_vector const& args) {
2372  assert(args.size() > 0);
2373  context& ctx = args[0].ctx();
2374  array<Z3_ast> _args(args);
2375  Z3_ast r = Z3_mk_distinct(ctx, _args.size(), _args.ptr());
2376  ctx.check_error();
2377  return expr(ctx, r);
2378  }
2379 
2380  inline expr concat(expr const& a, expr const& b) {
2381  check_context(a, b);
2382  Z3_ast r;
2383  if (Z3_is_seq_sort(a.ctx(), a.get_sort())) {
2384  Z3_ast _args[2] = { a, b };
2385  r = Z3_mk_seq_concat(a.ctx(), 2, _args);
2386  }
2387  else if (Z3_is_re_sort(a.ctx(), a.get_sort())) {
2388  Z3_ast _args[2] = { a, b };
2389  r = Z3_mk_re_concat(a.ctx(), 2, _args);
2390  }
2391  else {
2392  r = Z3_mk_concat(a.ctx(), a, b);
2393  }
2394  a.ctx().check_error();
2395  return expr(a.ctx(), r);
2396  }
2397 
2398  inline expr concat(expr_vector const& args) {
2399  Z3_ast r;
2400  assert(args.size() > 0);
2401  if (args.size() == 1) {
2402  return args[0];
2403  }
2404  context& ctx = args[0].ctx();
2405  array<Z3_ast> _args(args);
2406  if (Z3_is_seq_sort(ctx, args[0].get_sort())) {
2407  r = Z3_mk_seq_concat(ctx, _args.size(), _args.ptr());
2408  }
2409  else if (Z3_is_re_sort(ctx, args[0].get_sort())) {
2410  r = Z3_mk_re_concat(ctx, _args.size(), _args.ptr());
2411  }
2412  else {
2413  r = _args[args.size()-1];
2414  for (unsigned i = args.size()-1; i > 0; ) {
2415  --i;
2416  r = Z3_mk_concat(ctx, _args[i], r);
2417  ctx.check_error();
2418  }
2419  }
2420  ctx.check_error();
2421  return expr(ctx, r);
2422  }
2423 
2424  inline expr mk_or(expr_vector const& args) {
2425  array<Z3_ast> _args(args);
2426  Z3_ast r = Z3_mk_or(args.ctx(), _args.size(), _args.ptr());
2427  args.check_error();
2428  return expr(args.ctx(), r);
2429  }
2430  inline expr mk_and(expr_vector const& args) {
2431  array<Z3_ast> _args(args);
2432  Z3_ast r = Z3_mk_and(args.ctx(), _args.size(), _args.ptr());
2433  args.check_error();
2434  return expr(args.ctx(), r);
2435  }
2436  inline expr mk_xor(expr_vector const& args) {
2437  if (args.empty())
2438  return args.ctx().bool_val(false);
2439  expr r = args[0];
2440  for (unsigned i = 1; i < args.size(); ++i)
2441  r = r ^ args[i];
2442  return r;
2443  }
2444 
2445 
2446  class func_entry : public object {
2447  Z3_func_entry m_entry;
2448  void init(Z3_func_entry e) {
2449  m_entry = e;
2450  Z3_func_entry_inc_ref(ctx(), m_entry);
2451  }
2452  public:
2453  func_entry(context & c, Z3_func_entry e):object(c) { init(e); }
2454  func_entry(func_entry const & s):object(s) { init(s.m_entry); }
2456  operator Z3_func_entry() const { return m_entry; }
2458  Z3_func_entry_inc_ref(s.ctx(), s.m_entry);
2459  Z3_func_entry_dec_ref(ctx(), m_entry);
2460  object::operator=(s);
2461  m_entry = s.m_entry;
2462  return *this;
2463  }
2464  expr value() const { Z3_ast r = Z3_func_entry_get_value(ctx(), m_entry); check_error(); return expr(ctx(), r); }
2465  unsigned num_args() const { unsigned r = Z3_func_entry_get_num_args(ctx(), m_entry); check_error(); return r; }
2466  expr arg(unsigned i) const { Z3_ast r = Z3_func_entry_get_arg(ctx(), m_entry, i); check_error(); return expr(ctx(), r); }
2467  };
2468 
2469  class func_interp : public object {
2470  Z3_func_interp m_interp;
2471  void init(Z3_func_interp e) {
2472  m_interp = e;
2473  Z3_func_interp_inc_ref(ctx(), m_interp);
2474  }
2475  public:
2476  func_interp(context & c, Z3_func_interp e):object(c) { init(e); }
2477  func_interp(func_interp const & s):object(s) { init(s.m_interp); }
2479  operator Z3_func_interp() const { return m_interp; }
2481  Z3_func_interp_inc_ref(s.ctx(), s.m_interp);
2482  Z3_func_interp_dec_ref(ctx(), m_interp);
2483  object::operator=(s);
2484  m_interp = s.m_interp;
2485  return *this;
2486  }
2487  expr else_value() const { Z3_ast r = Z3_func_interp_get_else(ctx(), m_interp); check_error(); return expr(ctx(), r); }
2488  unsigned num_entries() const { unsigned r = Z3_func_interp_get_num_entries(ctx(), m_interp); check_error(); return r; }
2489  func_entry entry(unsigned i) const { Z3_func_entry e = Z3_func_interp_get_entry(ctx(), m_interp, i); check_error(); return func_entry(ctx(), e); }
2490  void add_entry(expr_vector const& args, expr& value) {
2491  Z3_func_interp_add_entry(ctx(), m_interp, args, value);
2492  check_error();
2493  }
2494  void set_else(expr& value) {
2495  Z3_func_interp_set_else(ctx(), m_interp, value);
2496  check_error();
2497  }
2498  };
2499 
2500  class model : public object {
2501  Z3_model m_model;
2502  void init(Z3_model m) {
2503  m_model = m;
2504  Z3_model_inc_ref(ctx(), m);
2505  }
2506  public:
2507  struct translate {};
2508  model(context & c):object(c) { init(Z3_mk_model(c)); }
2509  model(context & c, Z3_model m):object(c) { init(m); }
2510  model(model const & s):object(s) { init(s.m_model); }
2511  model(model& src, context& dst, translate) : object(dst) { init(Z3_model_translate(src.ctx(), src, dst)); }
2512  ~model() { Z3_model_dec_ref(ctx(), m_model); }
2513  operator Z3_model() const { return m_model; }
2514  model & operator=(model const & s) {
2515  Z3_model_inc_ref(s.ctx(), s.m_model);
2516  Z3_model_dec_ref(ctx(), m_model);
2517  object::operator=(s);
2518  m_model = s.m_model;
2519  return *this;
2520  }
2521 
2522  expr eval(expr const & n, bool model_completion=false) const {
2523  check_context(*this, n);
2524  Z3_ast r = 0;
2525  bool status = Z3_model_eval(ctx(), m_model, n, model_completion, &r);
2526  check_error();
2527  if (status == false && ctx().enable_exceptions())
2528  Z3_THROW(exception("failed to evaluate expression"));
2529  return expr(ctx(), r);
2530  }
2531 
2532  unsigned num_consts() const { return Z3_model_get_num_consts(ctx(), m_model); }
2533  unsigned num_funcs() const { return Z3_model_get_num_funcs(ctx(), m_model); }
2534  func_decl get_const_decl(unsigned i) const { Z3_func_decl r = Z3_model_get_const_decl(ctx(), m_model, i); check_error(); return func_decl(ctx(), r); }
2535  func_decl get_func_decl(unsigned i) const { Z3_func_decl r = Z3_model_get_func_decl(ctx(), m_model, i); check_error(); return func_decl(ctx(), r); }
2536  unsigned size() const { return num_consts() + num_funcs(); }
2537  func_decl operator[](int i) const {
2538  assert(0 <= i);
2539  return static_cast<unsigned>(i) < num_consts() ? get_const_decl(i) : get_func_decl(i - num_consts());
2540  }
2541 
2542  // returns interpretation of constant declaration c.
2543  // If c is not assigned any value in the model it returns
2544  // an expression with a null ast reference.
2546  check_context(*this, c);
2547  Z3_ast r = Z3_model_get_const_interp(ctx(), m_model, c);
2548  check_error();
2549  return expr(ctx(), r);
2550  }
2552  check_context(*this, f);
2553  Z3_func_interp r = Z3_model_get_func_interp(ctx(), m_model, f);
2554  check_error();
2555  return func_interp(ctx(), r);
2556  }
2557 
2558  // returns true iff the model contains an interpretation
2559  // for function f.
2560  bool has_interp(func_decl f) const {
2561  check_context(*this, f);
2562  return Z3_model_has_interp(ctx(), m_model, f);
2563  }
2564 
2566  Z3_func_interp r = Z3_add_func_interp(ctx(), m_model, f, else_val);
2567  check_error();
2568  return func_interp(ctx(), r);
2569  }
2570 
2571  void add_const_interp(func_decl& f, expr& value) {
2572  Z3_add_const_interp(ctx(), m_model, f, value);
2573  check_error();
2574  }
2575 
2576  friend std::ostream & operator<<(std::ostream & out, model const & m);
2577 
2578  std::string to_string() const { return std::string(Z3_model_to_string(ctx(), m_model)); }
2579  };
2580  inline std::ostream & operator<<(std::ostream & out, model const & m) { out << Z3_model_to_string(m.ctx(), m); return out; }
2581 
2582  class stats : public object {
2583  Z3_stats m_stats;
2584  void init(Z3_stats e) {
2585  m_stats = e;
2586  Z3_stats_inc_ref(ctx(), m_stats);
2587  }
2588  public:
2589  stats(context & c):object(c), m_stats(0) {}
2590  stats(context & c, Z3_stats e):object(c) { init(e); }
2591  stats(stats const & s):object(s) { init(s.m_stats); }
2592  ~stats() { if (m_stats) Z3_stats_dec_ref(ctx(), m_stats); }
2593  operator Z3_stats() const { return m_stats; }
2594  stats & operator=(stats const & s) {
2595  Z3_stats_inc_ref(s.ctx(), s.m_stats);
2596  if (m_stats) Z3_stats_dec_ref(ctx(), m_stats);
2597  object::operator=(s);
2598  m_stats = s.m_stats;
2599  return *this;
2600  }
2601  unsigned size() const { return Z3_stats_size(ctx(), m_stats); }
2602  std::string key(unsigned i) const { Z3_string s = Z3_stats_get_key(ctx(), m_stats, i); check_error(); return s; }
2603  bool is_uint(unsigned i) const { bool r = Z3_stats_is_uint(ctx(), m_stats, i); check_error(); return r; }
2604  bool is_double(unsigned i) const { bool r = Z3_stats_is_double(ctx(), m_stats, i); check_error(); return r; }
2605  unsigned uint_value(unsigned i) const { unsigned r = Z3_stats_get_uint_value(ctx(), m_stats, i); check_error(); return r; }
2606  double double_value(unsigned i) const { double r = Z3_stats_get_double_value(ctx(), m_stats, i); check_error(); return r; }
2607  friend std::ostream & operator<<(std::ostream & out, stats const & s);
2608  };
2609  inline std::ostream & operator<<(std::ostream & out, stats const & s) { out << Z3_stats_to_string(s.ctx(), s); return out; }
2610 
2611 
2612  inline std::ostream & operator<<(std::ostream & out, check_result r) {
2613  if (r == unsat) out << "unsat";
2614  else if (r == sat) out << "sat";
2615  else out << "unknown";
2616  return out;
2617  }
2618 
2619 
2620  class solver : public object {
2621  Z3_solver m_solver;
2622  void init(Z3_solver s) {
2623  m_solver = s;
2624  Z3_solver_inc_ref(ctx(), s);
2625  }
2626  public:
2627  struct simple {};
2628  struct translate {};
2629  solver(context & c):object(c) { init(Z3_mk_solver(c)); }
2631  solver(context & c, Z3_solver s):object(c) { init(s); }
2632  solver(context & c, char const * logic):object(c) { init(Z3_mk_solver_for_logic(c, c.str_symbol(logic))); }
2633  solver(context & c, solver const& src, translate): object(c) { init(Z3_solver_translate(src.ctx(), src, c)); }
2634  solver(solver const & s):object(s) { init(s.m_solver); }
2635  ~solver() { Z3_solver_dec_ref(ctx(), m_solver); }
2636  operator Z3_solver() const { return m_solver; }
2637  solver & operator=(solver const & s) {
2638  Z3_solver_inc_ref(s.ctx(), s.m_solver);
2639  Z3_solver_dec_ref(ctx(), m_solver);
2640  object::operator=(s);
2641  m_solver = s.m_solver;
2642  return *this;
2643  }
2644  void set(params const & p) { Z3_solver_set_params(ctx(), m_solver, p); check_error(); }
2645  void set(char const * k, bool v) { params p(ctx()); p.set(k, v); set(p); }
2646  void set(char const * k, unsigned v) { params p(ctx()); p.set(k, v); set(p); }
2647  void set(char const * k, double v) { params p(ctx()); p.set(k, v); set(p); }
2648  void set(char const * k, symbol const & v) { params p(ctx()); p.set(k, v); set(p); }
2649  void set(char const * k, char const* v) { params p(ctx()); p.set(k, v); set(p); }
2650  void push() { Z3_solver_push(ctx(), m_solver); check_error(); }
2651  void pop(unsigned n = 1) { Z3_solver_pop(ctx(), m_solver, n); check_error(); }
2652  void reset() { Z3_solver_reset(ctx(), m_solver); check_error(); }
2653  void add(expr const & e) { assert(e.is_bool()); Z3_solver_assert(ctx(), m_solver, e); check_error(); }
2654  void add(expr const & e, expr const & p) {
2655  assert(e.is_bool()); assert(p.is_bool()); assert(p.is_const());
2656  Z3_solver_assert_and_track(ctx(), m_solver, e, p);
2657  check_error();
2658  }
2659  void add(expr const & e, char const * p) {
2660  add(e, ctx().bool_const(p));
2661  }
2662  void add(expr_vector const& v) {
2663  check_context(*this, v);
2664  for (unsigned i = 0; i < v.size(); ++i)
2665  add(v[i]);
2666  }
2667  void from_file(char const* file) { Z3_solver_from_file(ctx(), m_solver, file); ctx().check_parser_error(); }
2668  void from_string(char const* s) { Z3_solver_from_string(ctx(), m_solver, s); ctx().check_parser_error(); }
2669 
2671  check_result check(unsigned n, expr * const assumptions) {
2672  array<Z3_ast> _assumptions(n);
2673  for (unsigned i = 0; i < n; i++) {
2674  check_context(*this, assumptions[i]);
2675  _assumptions[i] = assumptions[i];
2676  }
2677  Z3_lbool r = Z3_solver_check_assumptions(ctx(), m_solver, n, _assumptions.ptr());
2678  check_error();
2679  return to_check_result(r);
2680  }
2681  check_result check(expr_vector const& assumptions) {
2682  unsigned n = assumptions.size();
2683  array<Z3_ast> _assumptions(n);
2684  for (unsigned i = 0; i < n; i++) {
2685  check_context(*this, assumptions[i]);
2686  _assumptions[i] = assumptions[i];
2687  }
2688  Z3_lbool r = Z3_solver_check_assumptions(ctx(), m_solver, n, _assumptions.ptr());
2689  check_error();
2690  return to_check_result(r);
2691  }
2692  model get_model() const { Z3_model m = Z3_solver_get_model(ctx(), m_solver); check_error(); return model(ctx(), m); }
2694  Z3_lbool r = Z3_solver_get_consequences(ctx(), m_solver, assumptions, vars, conseq);
2695  check_error();
2696  return to_check_result(r);
2697  }
2698  std::string reason_unknown() const { Z3_string r = Z3_solver_get_reason_unknown(ctx(), m_solver); check_error(); return r; }
2699  stats statistics() const { Z3_stats r = Z3_solver_get_statistics(ctx(), m_solver); check_error(); return stats(ctx(), r); }
2700  expr_vector unsat_core() const { Z3_ast_vector r = Z3_solver_get_unsat_core(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2701  expr_vector assertions() const { Z3_ast_vector r = Z3_solver_get_assertions(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2702  expr_vector non_units() const { Z3_ast_vector r = Z3_solver_get_non_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2703  expr_vector units() const { Z3_ast_vector r = Z3_solver_get_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2704  expr_vector trail() const { Z3_ast_vector r = Z3_solver_get_trail(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2706  Z3_ast_vector r = Z3_solver_get_trail(ctx(), m_solver);
2707  check_error();
2708  expr_vector result(ctx(), r);
2709  unsigned sz = result.size();
2710  levels.resize(sz);
2711  Z3_solver_get_levels(ctx(), m_solver, r, sz, levels.ptr());
2712  check_error();
2713  return result;
2714  }
2715  expr proof() const { Z3_ast r = Z3_solver_get_proof(ctx(), m_solver); check_error(); return expr(ctx(), r); }
2716  friend std::ostream & operator<<(std::ostream & out, solver const & s);
2717 
2718  std::string to_smt2(char const* status = "unknown") {
2719  array<Z3_ast> es(assertions());
2720  Z3_ast const* fmls = es.ptr();
2721  Z3_ast fml = 0;
2722  unsigned sz = es.size();
2723  if (sz > 0) {
2724  --sz;
2725  fml = fmls[sz];
2726  }
2727  else {
2728  fml = ctx().bool_val(true);
2729  }
2730  return std::string(Z3_benchmark_to_smtlib_string(
2731  ctx(),
2732  "", "", status, "",
2733  sz,
2734  fmls,
2735  fml));
2736  }
2737 
2738  std::string dimacs(bool include_names = true) const { return std::string(Z3_solver_to_dimacs_string(ctx(), m_solver, include_names)); }
2739 
2741 
2742 
2743  expr_vector cube(expr_vector& vars, unsigned cutoff) {
2744  Z3_ast_vector r = Z3_solver_cube(ctx(), m_solver, vars, cutoff);
2745  check_error();
2746  return expr_vector(ctx(), r);
2747  }
2748 
2750  solver& m_solver;
2751  unsigned& m_cutoff;
2752  expr_vector& m_vars;
2753  expr_vector m_cube;
2754  bool m_end;
2755  bool m_empty;
2756 
2757  void inc() {
2758  assert(!m_end && !m_empty);
2759  m_cube = m_solver.cube(m_vars, m_cutoff);
2760  m_cutoff = 0xFFFFFFFF;
2761  if (m_cube.size() == 1 && m_cube[0].is_false()) {
2762  m_cube = z3::expr_vector(m_solver.ctx());
2763  m_end = true;
2764  }
2765  else if (m_cube.empty()) {
2766  m_empty = true;
2767  }
2768  }
2769  public:
2770  cube_iterator(solver& s, expr_vector& vars, unsigned& cutoff, bool end):
2771  m_solver(s),
2772  m_cutoff(cutoff),
2773  m_vars(vars),
2774  m_cube(s.ctx()),
2775  m_end(end),
2776  m_empty(false) {
2777  if (!m_end) {
2778  inc();
2779  }
2780  }
2781 
2783  assert(!m_end);
2784  if (m_empty) {
2785  m_end = true;
2786  }
2787  else {
2788  inc();
2789  }
2790  return *this;
2791  }
2792  cube_iterator operator++(int) { assert(false); return *this; }
2793  expr_vector const * operator->() const { return &(operator*()); }
2794  expr_vector const& operator*() const noexcept { return m_cube; }
2795 
2796  bool operator==(cube_iterator const& other) noexcept {
2797  return other.m_end == m_end;
2798  };
2799  bool operator!=(cube_iterator const& other) noexcept {
2800  return other.m_end != m_end;
2801  };
2802 
2803  };
2804 
2806  solver& m_solver;
2807  unsigned m_cutoff;
2808  expr_vector m_default_vars;
2809  expr_vector& m_vars;
2810  public:
2812  m_solver(s),
2813  m_cutoff(0xFFFFFFFF),
2814  m_default_vars(s.ctx()),
2815  m_vars(m_default_vars)
2816  {}
2817 
2819  m_solver(s),
2820  m_cutoff(0xFFFFFFFF),
2821  m_default_vars(s.ctx()),
2822  m_vars(vars)
2823  {}
2824 
2825  cube_iterator begin() { return cube_iterator(m_solver, m_vars, m_cutoff, false); }
2826  cube_iterator end() { return cube_iterator(m_solver, m_vars, m_cutoff, true); }
2827  void set_cutoff(unsigned c) noexcept { m_cutoff = c; }
2828  };
2829 
2830  cube_generator cubes() { return cube_generator(*this); }
2831  cube_generator cubes(expr_vector& vars) { return cube_generator(*this, vars); }
2832 
2833  };
2834  inline std::ostream & operator<<(std::ostream & out, solver const & s) { out << Z3_solver_to_string(s.ctx(), s); return out; }
2835 
2836  class goal : public object {
2837  Z3_goal m_goal;
2838  void init(Z3_goal s) {
2839  m_goal = s;
2840  Z3_goal_inc_ref(ctx(), s);
2841  }
2842  public:
2843  goal(context & c, bool models=true, bool unsat_cores=false, bool proofs=false):object(c) { init(Z3_mk_goal(c, models, unsat_cores, proofs)); }
2844  goal(context & c, Z3_goal s):object(c) { init(s); }
2845  goal(goal const & s):object(s) { init(s.m_goal); }
2846  ~goal() { Z3_goal_dec_ref(ctx(), m_goal); }
2847  operator Z3_goal() const { return m_goal; }
2848  goal & operator=(goal const & s) {
2849  Z3_goal_inc_ref(s.ctx(), s.m_goal);
2850  Z3_goal_dec_ref(ctx(), m_goal);
2851  object::operator=(s);
2852  m_goal = s.m_goal;
2853  return *this;
2854  }
2855  void add(expr const & f) { check_context(*this, f); Z3_goal_assert(ctx(), m_goal, f); check_error(); }
2856  void add(expr_vector const& v) { check_context(*this, v); for (unsigned i = 0; i < v.size(); ++i) add(v[i]); }
2857  unsigned size() const { return Z3_goal_size(ctx(), m_goal); }
2858  expr operator[](int i) const { assert(0 <= i); Z3_ast r = Z3_goal_formula(ctx(), m_goal, i); check_error(); return expr(ctx(), r); }
2859  Z3_goal_prec precision() const { return Z3_goal_precision(ctx(), m_goal); }
2860  bool inconsistent() const { return Z3_goal_inconsistent(ctx(), m_goal); }
2861  unsigned depth() const { return Z3_goal_depth(ctx(), m_goal); }
2862  void reset() { Z3_goal_reset(ctx(), m_goal); }
2863  unsigned num_exprs() const { return Z3_goal_num_exprs(ctx(), m_goal); }
2864  bool is_decided_sat() const { return Z3_goal_is_decided_sat(ctx(), m_goal); }
2865  bool is_decided_unsat() const { return Z3_goal_is_decided_unsat(ctx(), m_goal); }
2866  model convert_model(model const & m) const {
2867  check_context(*this, m);
2868  Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, m);
2869  check_error();
2870  return model(ctx(), new_m);
2871  }
2872  model get_model() const {
2873  Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, 0);
2874  check_error();
2875  return model(ctx(), new_m);
2876  }
2877  expr as_expr() const {
2878  unsigned n = size();
2879  if (n == 0)
2880  return ctx().bool_val(true);
2881  else if (n == 1)
2882  return operator[](0);
2883  else {
2884  array<Z3_ast> args(n);
2885  for (unsigned i = 0; i < n; i++)
2886  args[i] = operator[](i);
2887  return expr(ctx(), Z3_mk_and(ctx(), n, args.ptr()));
2888  }
2889  }
2890  std::string dimacs(bool include_names = true) const { return std::string(Z3_goal_to_dimacs_string(ctx(), m_goal, include_names)); }
2891  friend std::ostream & operator<<(std::ostream & out, goal const & g);
2892  };
2893  inline std::ostream & operator<<(std::ostream & out, goal const & g) { out << Z3_goal_to_string(g.ctx(), g); return out; }
2894 
2895  class apply_result : public object {
2896  Z3_apply_result m_apply_result;
2897  void init(Z3_apply_result s) {
2898  m_apply_result = s;
2900  }
2901  public:
2902  apply_result(context & c, Z3_apply_result s):object(c) { init(s); }
2903  apply_result(apply_result const & s):object(s) { init(s.m_apply_result); }
2904  ~apply_result() { Z3_apply_result_dec_ref(ctx(), m_apply_result); }
2905  operator Z3_apply_result() const { return m_apply_result; }
2907  Z3_apply_result_inc_ref(s.ctx(), s.m_apply_result);
2908  Z3_apply_result_dec_ref(ctx(), m_apply_result);
2909  object::operator=(s);
2910  m_apply_result = s.m_apply_result;
2911  return *this;
2912  }
2913  unsigned size() const { return Z3_apply_result_get_num_subgoals(ctx(), m_apply_result); }
2914  goal operator[](int i) const { assert(0 <= i); Z3_goal r = Z3_apply_result_get_subgoal(ctx(), m_apply_result, i); check_error(); return goal(ctx(), r); }
2915  friend std::ostream & operator<<(std::ostream & out, apply_result const & r);
2916  };
2917  inline std::ostream & operator<<(std::ostream & out, apply_result const & r) { out << Z3_apply_result_to_string(r.ctx(), r); return out; }
2918 
2919  class tactic : public object {
2920  Z3_tactic m_tactic;
2921  void init(Z3_tactic s) {
2922  m_tactic = s;
2923  Z3_tactic_inc_ref(ctx(), s);
2924  }
2925  public:
2926  tactic(context & c, char const * name):object(c) { Z3_tactic r = Z3_mk_tactic(c, name); check_error(); init(r); }
2927  tactic(context & c, Z3_tactic s):object(c) { init(s); }
2928  tactic(tactic const & s):object(s) { init(s.m_tactic); }
2929  ~tactic() { Z3_tactic_dec_ref(ctx(), m_tactic); }
2930  operator Z3_tactic() const { return m_tactic; }
2931  tactic & operator=(tactic const & s) {
2932  Z3_tactic_inc_ref(s.ctx(), s.m_tactic);
2933  Z3_tactic_dec_ref(ctx(), m_tactic);
2934  object::operator=(s);
2935  m_tactic = s.m_tactic;
2936  return *this;
2937  }
2938  solver mk_solver() const { Z3_solver r = Z3_mk_solver_from_tactic(ctx(), m_tactic); check_error(); return solver(ctx(), r); }
2939  apply_result apply(goal const & g) const {
2940  check_context(*this, g);
2941  Z3_apply_result r = Z3_tactic_apply(ctx(), m_tactic, g);
2942  check_error();
2943  return apply_result(ctx(), r);
2944  }
2945  apply_result operator()(goal const & g) const {
2946  return apply(g);
2947  }
2948  std::string help() const { char const * r = Z3_tactic_get_help(ctx(), m_tactic); check_error(); return r; }
2949  friend tactic operator&(tactic const & t1, tactic const & t2);
2950  friend tactic operator|(tactic const & t1, tactic const & t2);
2951  friend tactic repeat(tactic const & t, unsigned max);
2952  friend tactic with(tactic const & t, params const & p);
2953  friend tactic try_for(tactic const & t, unsigned ms);
2954  friend tactic par_or(unsigned n, tactic const* tactics);
2955  friend tactic par_and_then(tactic const& t1, tactic const& t2);
2957  };
2958 
2959  inline tactic operator&(tactic const & t1, tactic const & t2) {
2960  check_context(t1, t2);
2961  Z3_tactic r = Z3_tactic_and_then(t1.ctx(), t1, t2);
2962  t1.check_error();
2963  return tactic(t1.ctx(), r);
2964  }
2965 
2966  inline tactic operator|(tactic const & t1, tactic const & t2) {
2967  check_context(t1, t2);
2968  Z3_tactic r = Z3_tactic_or_else(t1.ctx(), t1, t2);
2969  t1.check_error();
2970  return tactic(t1.ctx(), r);
2971  }
2972 
2973  inline tactic repeat(tactic const & t, unsigned max=UINT_MAX) {
2974  Z3_tactic r = Z3_tactic_repeat(t.ctx(), t, max);
2975  t.check_error();
2976  return tactic(t.ctx(), r);
2977  }
2978 
2979  inline tactic with(tactic const & t, params const & p) {
2980  Z3_tactic r = Z3_tactic_using_params(t.ctx(), t, p);
2981  t.check_error();
2982  return tactic(t.ctx(), r);
2983  }
2984  inline tactic try_for(tactic const & t, unsigned ms) {
2985  Z3_tactic r = Z3_tactic_try_for(t.ctx(), t, ms);
2986  t.check_error();
2987  return tactic(t.ctx(), r);
2988  }
2989  inline tactic par_or(unsigned n, tactic const* tactics) {
2990  if (n == 0) {
2991  Z3_THROW(exception("a non-zero number of tactics need to be passed to par_or"));
2992  }
2993  array<Z3_tactic> buffer(n);
2994  for (unsigned i = 0; i < n; ++i) buffer[i] = tactics[i];
2995  return tactic(tactics[0].ctx(), Z3_tactic_par_or(tactics[0].ctx(), n, buffer.ptr()));
2996  }
2997 
2998  inline tactic par_and_then(tactic const & t1, tactic const & t2) {
2999  check_context(t1, t2);
3000  Z3_tactic r = Z3_tactic_par_and_then(t1.ctx(), t1, t2);
3001  t1.check_error();
3002  return tactic(t1.ctx(), r);
3003  }
3004 
3005  class probe : public object {
3006  Z3_probe m_probe;
3007  void init(Z3_probe s) {
3008  m_probe = s;
3009  Z3_probe_inc_ref(ctx(), s);
3010  }
3011  public:
3012  probe(context & c, char const * name):object(c) { Z3_probe r = Z3_mk_probe(c, name); check_error(); init(r); }
3013  probe(context & c, double val):object(c) { Z3_probe r = Z3_probe_const(c, val); check_error(); init(r); }
3014  probe(context & c, Z3_probe s):object(c) { init(s); }
3015  probe(probe const & s):object(s) { init(s.m_probe); }
3016  ~probe() { Z3_probe_dec_ref(ctx(), m_probe); }
3017  operator Z3_probe() const { return m_probe; }
3018  probe & operator=(probe const & s) {
3019  Z3_probe_inc_ref(s.ctx(), s.m_probe);
3020  Z3_probe_dec_ref(ctx(), m_probe);
3021  object::operator=(s);
3022  m_probe = s.m_probe;
3023  return *this;
3024  }
3025  double apply(goal const & g) const { double r = Z3_probe_apply(ctx(), m_probe, g); check_error(); return r; }
3026  double operator()(goal const & g) const { return apply(g); }
3027  friend probe operator<=(probe const & p1, probe const & p2);
3028  friend probe operator<=(probe const & p1, double p2);
3029  friend probe operator<=(double p1, probe const & p2);
3030  friend probe operator>=(probe const & p1, probe const & p2);
3031  friend probe operator>=(probe const & p1, double p2);
3032  friend probe operator>=(double p1, probe const & p2);
3033  friend probe operator<(probe const & p1, probe const & p2);
3034  friend probe operator<(probe const & p1, double p2);
3035  friend probe operator<(double p1, probe const & p2);
3036  friend probe operator>(probe const & p1, probe const & p2);
3037  friend probe operator>(probe const & p1, double p2);
3038  friend probe operator>(double p1, probe const & p2);
3039  friend probe operator==(probe const & p1, probe const & p2);
3040  friend probe operator==(probe const & p1, double p2);
3041  friend probe operator==(double p1, probe const & p2);
3042  friend probe operator&&(probe const & p1, probe const & p2);
3043  friend probe operator||(probe const & p1, probe const & p2);
3044  friend probe operator!(probe const & p);
3045  };
3046 
3047  inline probe operator<=(probe const & p1, probe const & p2) {
3048  check_context(p1, p2); Z3_probe r = Z3_probe_le(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3049  }
3050  inline probe operator<=(probe const & p1, double p2) { return p1 <= probe(p1.ctx(), p2); }
3051  inline probe operator<=(double p1, probe const & p2) { return probe(p2.ctx(), p1) <= p2; }
3052  inline probe operator>=(probe const & p1, probe const & p2) {
3053  check_context(p1, p2); Z3_probe r = Z3_probe_ge(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3054  }
3055  inline probe operator>=(probe const & p1, double p2) { return p1 >= probe(p1.ctx(), p2); }
3056  inline probe operator>=(double p1, probe const & p2) { return probe(p2.ctx(), p1) >= p2; }
3057  inline probe operator<(probe const & p1, probe const & p2) {
3058  check_context(p1, p2); Z3_probe r = Z3_probe_lt(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3059  }
3060  inline probe operator<(probe const & p1, double p2) { return p1 < probe(p1.ctx(), p2); }
3061  inline probe operator<(double p1, probe const & p2) { return probe(p2.ctx(), p1) < p2; }
3062  inline probe operator>(probe const & p1, probe const & p2) {
3063  check_context(p1, p2); Z3_probe r = Z3_probe_gt(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3064  }
3065  inline probe operator>(probe const & p1, double p2) { return p1 > probe(p1.ctx(), p2); }
3066  inline probe operator>(double p1, probe const & p2) { return probe(p2.ctx(), p1) > p2; }
3067  inline probe operator==(probe const & p1, probe const & p2) {
3068  check_context(p1, p2); Z3_probe r = Z3_probe_eq(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3069  }
3070  inline probe operator==(probe const & p1, double p2) { return p1 == probe(p1.ctx(), p2); }
3071  inline probe operator==(double p1, probe const & p2) { return probe(p2.ctx(), p1) == p2; }
3072  inline probe operator&&(probe const & p1, probe const & p2) {
3073  check_context(p1, p2); Z3_probe r = Z3_probe_and(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3074  }
3075  inline probe operator||(probe const & p1, probe const & p2) {
3076  check_context(p1, p2); Z3_probe r = Z3_probe_or(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3077  }
3078  inline probe operator!(probe const & p) {
3079  Z3_probe r = Z3_probe_not(p.ctx(), p); p.check_error(); return probe(p.ctx(), r);
3080  }
3081 
3082  class optimize : public object {
3083  Z3_optimize m_opt;
3084 
3085  public:
3086  class handle final {
3087  unsigned m_h;
3088  public:
3089  handle(unsigned h): m_h(h) {}
3090  unsigned h() const { return m_h; }
3091  };
3092  optimize(context& c):object(c) { m_opt = Z3_mk_optimize(c); Z3_optimize_inc_ref(c, m_opt); }
3093  optimize(optimize const & o):object(o), m_opt(o.m_opt) {
3094  Z3_optimize_inc_ref(o.ctx(), o.m_opt);
3095  }
3097  m_opt = Z3_mk_optimize(c);
3098  Z3_optimize_inc_ref(c, m_opt);
3099  add(expr_vector(c, src.assertions()));
3100  expr_vector v(c, src.objectives());
3101  for (expr_vector::iterator it = v.begin(); it != v.end(); ++it) minimize(*it);
3102  }
3104  Z3_optimize_inc_ref(o.ctx(), o.m_opt);
3105  Z3_optimize_dec_ref(ctx(), m_opt);
3106  m_opt = o.m_opt;
3107  object::operator=(o);
3108  return *this;
3109  }
3111  operator Z3_optimize() const { return m_opt; }
3112  void add(expr const& e) {
3113  assert(e.is_bool());
3114  Z3_optimize_assert(ctx(), m_opt, e);
3115  }
3116  void add(expr_vector const& es) {
3117  for (expr_vector::iterator it = es.begin(); it != es.end(); ++it) add(*it);
3118  }
3119  void add(expr const& e, expr const& t) {
3120  assert(e.is_bool());
3121  Z3_optimize_assert_and_track(ctx(), m_opt, e, t);
3122  }
3123  void add(expr const& e, char const* p) {
3124  assert(e.is_bool());
3125  add(e, ctx().bool_const(p));
3126  }
3127  handle add_soft(expr const& e, unsigned weight) {
3128  assert(e.is_bool());
3129  auto str = std::to_string(weight);
3130  return handle(Z3_optimize_assert_soft(ctx(), m_opt, e, str.c_str(), 0));
3131  }
3132  handle add_soft(expr const& e, char const* weight) {
3133  assert(e.is_bool());
3134  return handle(Z3_optimize_assert_soft(ctx(), m_opt, e, weight, 0));
3135  }
3136  handle add(expr const& e, unsigned weight) {
3137  return add_soft(e, weight);
3138  }
3139  handle maximize(expr const& e) {
3140  return handle(Z3_optimize_maximize(ctx(), m_opt, e));
3141  }
3142  handle minimize(expr const& e) {
3143  return handle(Z3_optimize_minimize(ctx(), m_opt, e));
3144  }
3145  void push() {
3146  Z3_optimize_push(ctx(), m_opt);
3147  }
3148  void pop() {
3149  Z3_optimize_pop(ctx(), m_opt);
3150  }
3153  unsigned n = asms.size();
3154  array<Z3_ast> _asms(n);
3155  for (unsigned i = 0; i < n; i++) {
3156  check_context(*this, asms[i]);
3157  _asms[i] = asms[i];
3158  }
3159  Z3_lbool r = Z3_optimize_check(ctx(), m_opt, n, _asms.ptr());
3160  check_error();
3161  return to_check_result(r);
3162  }
3163  model get_model() const { Z3_model m = Z3_optimize_get_model(ctx(), m_opt); check_error(); return model(ctx(), m); }
3164  expr_vector unsat_core() const { Z3_ast_vector r = Z3_optimize_get_unsat_core(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3165  void set(params const & p) { Z3_optimize_set_params(ctx(), m_opt, p); check_error(); }
3166  expr lower(handle const& h) {
3167  Z3_ast r = Z3_optimize_get_lower(ctx(), m_opt, h.h());
3168  check_error();
3169  return expr(ctx(), r);
3170  }
3171  expr upper(handle const& h) {
3172  Z3_ast r = Z3_optimize_get_upper(ctx(), m_opt, h.h());
3173  check_error();
3174  return expr(ctx(), r);
3175  }
3176  expr_vector assertions() const { Z3_ast_vector r = Z3_optimize_get_assertions(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3177  expr_vector objectives() const { Z3_ast_vector r = Z3_optimize_get_objectives(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3178  stats statistics() const { Z3_stats r = Z3_optimize_get_statistics(ctx(), m_opt); check_error(); return stats(ctx(), r); }
3179  friend std::ostream & operator<<(std::ostream & out, optimize const & s);
3180  void from_file(char const* filename) { Z3_optimize_from_file(ctx(), m_opt, filename); check_error(); }
3181  void from_string(char const* constraints) { Z3_optimize_from_string(ctx(), m_opt, constraints); check_error(); }
3182  std::string help() const { char const * r = Z3_optimize_get_help(ctx(), m_opt); check_error(); return r; }
3183  };
3184  inline std::ostream & operator<<(std::ostream & out, optimize const & s) { out << Z3_optimize_to_string(s.ctx(), s.m_opt); return out; }
3185 
3186  class fixedpoint : public object {
3187  Z3_fixedpoint m_fp;
3188  public:
3190  fixedpoint(fixedpoint const & o):object(o), m_fp(o.m_fp) { Z3_fixedpoint_inc_ref(ctx(), m_fp); }
3193  Z3_fixedpoint_inc_ref(o.ctx(), o.m_fp);
3194  Z3_fixedpoint_dec_ref(ctx(), m_fp);
3195  m_fp = o.m_fp;
3196  object::operator=(o);
3197  return *this;
3198  }
3199  operator Z3_fixedpoint() const { return m_fp; }
3200  expr_vector from_string(char const* s) {
3201  Z3_ast_vector r = Z3_fixedpoint_from_string(ctx(), m_fp, s);
3202  check_error();
3203  return expr_vector(ctx(), r);
3204  }
3205  expr_vector from_file(char const* s) {
3206  Z3_ast_vector r = Z3_fixedpoint_from_file(ctx(), m_fp, s);
3207  check_error();
3208  return expr_vector(ctx(), r);
3209  }
3210  void add_rule(expr& rule, symbol const& name) { Z3_fixedpoint_add_rule(ctx(), m_fp, rule, name); check_error(); }
3211  void add_fact(func_decl& f, unsigned * args) { Z3_fixedpoint_add_fact(ctx(), m_fp, f, f.arity(), args); check_error(); }
3214  array<Z3_func_decl> rs(relations);
3215  Z3_lbool r = Z3_fixedpoint_query_relations(ctx(), m_fp, rs.size(), rs.ptr());
3216  check_error();
3217  return to_check_result(r);
3218  }
3219  expr get_answer() { Z3_ast r = Z3_fixedpoint_get_answer(ctx(), m_fp); check_error(); return expr(ctx(), r); }
3220  std::string reason_unknown() { return Z3_fixedpoint_get_reason_unknown(ctx(), m_fp); }
3221  void update_rule(expr& rule, symbol const& name) { Z3_fixedpoint_update_rule(ctx(), m_fp, rule, name); check_error(); }
3222  unsigned get_num_levels(func_decl& p) { unsigned r = Z3_fixedpoint_get_num_levels(ctx(), m_fp, p); check_error(); return r; }
3223  expr get_cover_delta(int level, func_decl& p) {
3224  Z3_ast r = Z3_fixedpoint_get_cover_delta(ctx(), m_fp, level, p);
3225  check_error();
3226  return expr(ctx(), r);
3227  }
3228  void add_cover(int level, func_decl& p, expr& property) { Z3_fixedpoint_add_cover(ctx(), m_fp, level, p, property); check_error(); }
3229  stats statistics() const { Z3_stats r = Z3_fixedpoint_get_statistics(ctx(), m_fp); check_error(); return stats(ctx(), r); }
3231  expr_vector assertions() const { Z3_ast_vector r = Z3_fixedpoint_get_assertions(ctx(), m_fp); check_error(); return expr_vector(ctx(), r); }
3232  expr_vector rules() const { Z3_ast_vector r = Z3_fixedpoint_get_rules(ctx(), m_fp); check_error(); return expr_vector(ctx(), r); }
3233  void set(params const & p) { Z3_fixedpoint_set_params(ctx(), m_fp, p); check_error(); }
3234  std::string help() const { return Z3_fixedpoint_get_help(ctx(), m_fp); }
3236  std::string to_string() { return Z3_fixedpoint_to_string(ctx(), m_fp, 0, 0); }
3237  std::string to_string(expr_vector const& queries) {
3238  array<Z3_ast> qs(queries);
3239  return Z3_fixedpoint_to_string(ctx(), m_fp, qs.size(), qs.ptr());
3240  }
3241  };
3242  inline std::ostream & operator<<(std::ostream & out, fixedpoint const & f) { return out << Z3_fixedpoint_to_string(f.ctx(), f, 0, 0); }
3243 
3244  inline tactic fail_if(probe const & p) {
3245  Z3_tactic r = Z3_tactic_fail_if(p.ctx(), p);
3246  p.check_error();
3247  return tactic(p.ctx(), r);
3248  }
3249  inline tactic when(probe const & p, tactic const & t) {
3250  check_context(p, t);
3251  Z3_tactic r = Z3_tactic_when(t.ctx(), p, t);
3252  t.check_error();
3253  return tactic(t.ctx(), r);
3254  }
3255  inline tactic cond(probe const & p, tactic const & t1, tactic const & t2) {
3256  check_context(p, t1); check_context(p, t2);
3257  Z3_tactic r = Z3_tactic_cond(t1.ctx(), p, t1, t2);
3258  t1.check_error();
3259  return tactic(t1.ctx(), r);
3260  }
3261 
3262  inline symbol context::str_symbol(char const * s) { Z3_symbol r = Z3_mk_string_symbol(m_ctx, s); check_error(); return symbol(*this, r); }
3263  inline symbol context::int_symbol(int n) { Z3_symbol r = Z3_mk_int_symbol(m_ctx, n); check_error(); return symbol(*this, r); }
3264 
3265  inline sort context::bool_sort() { Z3_sort s = Z3_mk_bool_sort(m_ctx); check_error(); return sort(*this, s); }
3266  inline sort context::int_sort() { Z3_sort s = Z3_mk_int_sort(m_ctx); check_error(); return sort(*this, s); }
3267  inline sort context::real_sort() { Z3_sort s = Z3_mk_real_sort(m_ctx); check_error(); return sort(*this, s); }
3268  inline sort context::bv_sort(unsigned sz) { Z3_sort s = Z3_mk_bv_sort(m_ctx, sz); check_error(); return sort(*this, s); }
3269  inline sort context::string_sort() { Z3_sort s = Z3_mk_string_sort(m_ctx); check_error(); return sort(*this, s); }
3270  inline sort context::char_sort() { Z3_sort s = Z3_mk_char_sort(m_ctx); check_error(); return sort(*this, s); }
3271  inline sort context::seq_sort(sort& s) { Z3_sort r = Z3_mk_seq_sort(m_ctx, s); check_error(); return sort(*this, r); }
3272  inline sort context::re_sort(sort& s) { Z3_sort r = Z3_mk_re_sort(m_ctx, s); check_error(); return sort(*this, r); }
3273  inline sort context::fpa_sort(unsigned ebits, unsigned sbits) { Z3_sort s = Z3_mk_fpa_sort(m_ctx, ebits, sbits); check_error(); return sort(*this, s); }
3274 
3275  template<>
3276  inline sort context::fpa_sort<16>() { return fpa_sort(5, 11); }
3277 
3278  template<>
3279  inline sort context::fpa_sort<32>() { return fpa_sort(8, 24); }
3280 
3281  template<>
3282  inline sort context::fpa_sort<64>() { return fpa_sort(11, 53); }
3283 
3284  template<>
3285  inline sort context::fpa_sort<128>() { return fpa_sort(15, 113); }
3286 
3287  inline sort context::fpa_rounding_mode_sort() { Z3_sort r = Z3_mk_fpa_rounding_mode_sort(m_ctx); check_error(); return sort(*this, r); }
3288 
3289  inline sort context::array_sort(sort d, sort r) { Z3_sort s = Z3_mk_array_sort(m_ctx, d, r); check_error(); return sort(*this, s); }
3291  array<Z3_sort> dom(d);
3292  Z3_sort s = Z3_mk_array_sort_n(m_ctx, dom.size(), dom.ptr(), r); check_error(); return sort(*this, s);
3293  }
3294  inline sort context::enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts) {
3295  array<Z3_symbol> _enum_names(n);
3296  for (unsigned i = 0; i < n; i++) { _enum_names[i] = Z3_mk_string_symbol(*this, enum_names[i]); }
3297  array<Z3_func_decl> _cs(n);
3298  array<Z3_func_decl> _ts(n);
3299  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3300  sort s = to_sort(*this, Z3_mk_enumeration_sort(*this, _name, n, _enum_names.ptr(), _cs.ptr(), _ts.ptr()));
3301  check_error();
3302  for (unsigned i = 0; i < n; i++) { cs.push_back(func_decl(*this, _cs[i])); ts.push_back(func_decl(*this, _ts[i])); }
3303  return s;
3304  }
3305  inline func_decl context::tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs) {
3306  array<Z3_symbol> _names(n);
3307  array<Z3_sort> _sorts(n);
3308  for (unsigned i = 0; i < n; i++) { _names[i] = Z3_mk_string_symbol(*this, names[i]); _sorts[i] = sorts[i]; }
3309  array<Z3_func_decl> _projs(n);
3310  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3311  Z3_func_decl tuple;
3312  sort _ignore_s = to_sort(*this, Z3_mk_tuple_sort(*this, _name, n, _names.ptr(), _sorts.ptr(), &tuple, _projs.ptr()));
3313  check_error();
3314  for (unsigned i = 0; i < n; i++) { projs.push_back(func_decl(*this, _projs[i])); }
3315  return func_decl(*this, tuple);
3316  }
3317 
3318  inline sort context::uninterpreted_sort(char const* name) {
3319  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3320  return to_sort(*this, Z3_mk_uninterpreted_sort(*this, _name));
3321  }
3323  return to_sort(*this, Z3_mk_uninterpreted_sort(*this, name));
3324  }
3325 
3326  inline func_decl context::function(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3327  array<Z3_sort> args(arity);
3328  for (unsigned i = 0; i < arity; i++) {
3329  check_context(domain[i], range);
3330  args[i] = domain[i];
3331  }
3332  Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, arity, args.ptr(), range);
3333  check_error();
3334  return func_decl(*this, f);
3335  }
3336 
3337  inline func_decl context::function(char const * name, unsigned arity, sort const * domain, sort const & range) {
3338  return function(range.ctx().str_symbol(name), arity, domain, range);
3339  }
3340 
3341  inline func_decl context::function(symbol const& name, sort_vector const& domain, sort const& range) {
3342  array<Z3_sort> args(domain.size());
3343  for (unsigned i = 0; i < domain.size(); i++) {
3344  check_context(domain[i], range);
3345  args[i] = domain[i];
3346  }
3347  Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, domain.size(), args.ptr(), range);
3348  check_error();
3349  return func_decl(*this, f);
3350  }
3351 
3352  inline func_decl context::function(char const * name, sort_vector const& domain, sort const& range) {
3353  return function(range.ctx().str_symbol(name), domain, range);
3354  }
3355 
3356 
3357  inline func_decl context::function(char const * name, sort const & domain, sort const & range) {
3358  check_context(domain, range);
3359  Z3_sort args[1] = { domain };
3360  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 1, args, range);
3361  check_error();
3362  return func_decl(*this, f);
3363  }
3364 
3365  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & range) {
3367  Z3_sort args[2] = { d1, d2 };
3368  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 2, args, range);
3369  check_error();
3370  return func_decl(*this, f);
3371  }
3372 
3373  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range) {
3375  Z3_sort args[3] = { d1, d2, d3 };
3376  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 3, args, range);
3377  check_error();
3378  return func_decl(*this, f);
3379  }
3380 
3381  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range) {
3383  Z3_sort args[4] = { d1, d2, d3, d4 };
3384  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 4, args, range);
3385  check_error();
3386  return func_decl(*this, f);
3387  }
3388 
3389  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & d5, sort const & range) {
3391  Z3_sort args[5] = { d1, d2, d3, d4, d5 };
3392  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 5, args, range);
3393  check_error();
3394  return func_decl(*this, f);
3395  }
3396 
3397  inline func_decl context::recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3398  array<Z3_sort> args(arity);
3399  for (unsigned i = 0; i < arity; i++) {
3400  check_context(domain[i], range);
3401  args[i] = domain[i];
3402  }
3403  Z3_func_decl f = Z3_mk_rec_func_decl(m_ctx, name, arity, args.ptr(), range);
3404  check_error();
3405  return func_decl(*this, f);
3406 
3407  }
3408 
3409  inline func_decl context::recfun(char const * name, unsigned arity, sort const * domain, sort const & range) {
3410  return recfun(str_symbol(name), arity, domain, range);
3411  }
3412 
3413  inline func_decl context::recfun(char const * name, sort const& d1, sort const & range) {
3414  return recfun(str_symbol(name), 1, &d1, range);
3415  }
3416 
3417  inline func_decl context::recfun(char const * name, sort const& d1, sort const& d2, sort const & range) {
3418  sort dom[2] = { d1, d2 };
3419  return recfun(str_symbol(name), 2, dom, range);
3420  }
3421 
3422  inline void context::recdef(func_decl f, expr_vector const& args, expr const& body) {
3423  check_context(f, args); check_context(f, body);
3424  array<Z3_ast> vars(args);
3425  Z3_add_rec_def(f.ctx(), f, vars.size(), vars.ptr(), body);
3426  }
3427 
3428  inline func_decl context::user_propagate_function(symbol const& name, sort_vector const& domain, sort const& range) {
3429  check_context(domain, range);
3430  array<Z3_sort> domain1(domain);
3431  Z3_func_decl f = Z3_solver_propagate_declare(range.ctx(), name, domain1.size(), domain1.ptr(), range);
3432  check_error();
3433  return func_decl(*this, f);
3434  }
3435 
3436  inline expr context::constant(symbol const & name, sort const & s) {
3437  Z3_ast r = Z3_mk_const(m_ctx, name, s);
3438  check_error();
3439  return expr(*this, r);
3440  }
3441  inline expr context::constant(char const * name, sort const & s) { return constant(str_symbol(name), s); }
3442  inline expr context::bool_const(char const * name) { return constant(name, bool_sort()); }
3443  inline expr context::int_const(char const * name) { return constant(name, int_sort()); }
3444  inline expr context::real_const(char const * name) { return constant(name, real_sort()); }
3445  inline expr context::string_const(char const * name) { return constant(name, string_sort()); }
3446  inline expr context::bv_const(char const * name, unsigned sz) { return constant(name, bv_sort(sz)); }
3447  inline expr context::fpa_const(char const * name, unsigned ebits, unsigned sbits) { return constant(name, fpa_sort(ebits, sbits)); }
3448 
3449  template<size_t precision>
3450  inline expr context::fpa_const(char const * name) { return constant(name, fpa_sort<precision>()); }
3451 
3452  inline void context::set_rounding_mode(rounding_mode rm) { m_rounding_mode = rm; }
3453 
3455  switch (m_rounding_mode) {
3456  case RNA: return expr(*this, Z3_mk_fpa_rna(m_ctx));
3457  case RNE: return expr(*this, Z3_mk_fpa_rne(m_ctx));
3458  case RTP: return expr(*this, Z3_mk_fpa_rtp(m_ctx));
3459  case RTN: return expr(*this, Z3_mk_fpa_rtn(m_ctx));
3460  case RTZ: return expr(*this, Z3_mk_fpa_rtz(m_ctx));
3461  default: return expr(*this);
3462  }
3463  }
3464 
3465  inline expr context::bool_val(bool b) { return b ? expr(*this, Z3_mk_true(m_ctx)) : expr(*this, Z3_mk_false(m_ctx)); }
3466 
3467  inline expr context::int_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3468  inline expr context::int_val(unsigned n) { Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3469  inline expr context::int_val(int64_t n) { Z3_ast r = Z3_mk_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3470  inline expr context::int_val(uint64_t n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3471  inline expr context::int_val(char const * n) { Z3_ast r = Z3_mk_numeral(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3472 
3473  inline expr context::real_val(int n, int d) { Z3_ast r = Z3_mk_real(m_ctx, n, d); check_error(); return expr(*this, r); }
3474  inline expr context::real_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3475  inline expr context::real_val(unsigned n) { Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3476  inline expr context::real_val(int64_t n) { Z3_ast r = Z3_mk_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3477  inline expr context::real_val(uint64_t n) { Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3478  inline expr context::real_val(char const * n) { Z3_ast r = Z3_mk_numeral(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3479 
3480  inline expr context::bv_val(int n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int(m_ctx, n, s); check_error(); return expr(*this, r); }
3481  inline expr context::bv_val(unsigned n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int(m_ctx, n, s); check_error(); return expr(*this, r); }
3482  inline expr context::bv_val(int64_t n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int64(m_ctx, n, s); check_error(); return expr(*this, r); }
3483  inline expr context::bv_val(uint64_t n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, s); check_error(); return expr(*this, r); }
3484  inline expr context::bv_val(char const * n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_numeral(m_ctx, n, s); check_error(); return expr(*this, r); }
3485  inline expr context::bv_val(unsigned n, bool const* bits) {
3486  array<bool> _bits(n);
3487  for (unsigned i = 0; i < n; ++i) _bits[i] = bits[i] ? 1 : 0;
3488  Z3_ast r = Z3_mk_bv_numeral(m_ctx, n, _bits.ptr()); check_error(); return expr(*this, r);
3489  }
3490 
3491  inline expr context::fpa_val(double n) { sort s = fpa_sort<64>(); Z3_ast r = Z3_mk_fpa_numeral_double(m_ctx, n, s); check_error(); return expr(*this, r); }
3492  inline expr context::fpa_val(float n) { sort s = fpa_sort<32>(); Z3_ast r = Z3_mk_fpa_numeral_float(m_ctx, n, s); check_error(); return expr(*this, r); }
3493  inline expr context::fpa_nan(sort const & s) { Z3_ast r = Z3_mk_fpa_nan(m_ctx, s); check_error(); return expr(*this, r); }
3494  inline expr context::fpa_inf(sort const & s, bool sgn) { Z3_ast r = Z3_mk_fpa_inf(m_ctx, s, sgn); check_error(); return expr(*this, r); }
3495 
3496  inline expr context::string_val(char const* s, unsigned n) { Z3_ast r = Z3_mk_lstring(m_ctx, n, s); check_error(); return expr(*this, r); }
3497  inline expr context::string_val(char const* s) { Z3_ast r = Z3_mk_string(m_ctx, s); check_error(); return expr(*this, r); }
3498  inline expr context::string_val(std::string const& s) { Z3_ast r = Z3_mk_string(m_ctx, s.c_str()); check_error(); return expr(*this, r); }
3499  inline expr context::string_val(std::u32string const& s) { Z3_ast r = Z3_mk_u32string(m_ctx, (unsigned)s.size(), (unsigned const*)s.c_str()); check_error(); return expr(*this, r); }
3500 
3501  inline expr context::num_val(int n, sort const & s) { Z3_ast r = Z3_mk_int(m_ctx, n, s); check_error(); return expr(*this, r); }
3502 
3503  inline expr func_decl::operator()(unsigned n, expr const * args) const {
3504  array<Z3_ast> _args(n);
3505  for (unsigned i = 0; i < n; i++) {
3506  check_context(*this, args[i]);
3507  _args[i] = args[i];
3508  }
3509  Z3_ast r = Z3_mk_app(ctx(), *this, n, _args.ptr());
3510  check_error();
3511  return expr(ctx(), r);
3512 
3513  }
3514  inline expr func_decl::operator()(expr_vector const& args) const {
3515  array<Z3_ast> _args(args.size());
3516  for (unsigned i = 0; i < args.size(); i++) {
3517  check_context(*this, args[i]);
3518  _args[i] = args[i];
3519  }
3520  Z3_ast r = Z3_mk_app(ctx(), *this, args.size(), _args.ptr());
3521  check_error();
3522  return expr(ctx(), r);
3523  }
3524  inline expr func_decl::operator()() const {
3525  Z3_ast r = Z3_mk_app(ctx(), *this, 0, 0);
3526  ctx().check_error();
3527  return expr(ctx(), r);
3528  }
3529  inline expr func_decl::operator()(expr const & a) const {
3530  check_context(*this, a);
3531  Z3_ast args[1] = { a };
3532  Z3_ast r = Z3_mk_app(ctx(), *this, 1, args);
3533  ctx().check_error();
3534  return expr(ctx(), r);
3535  }
3536  inline expr func_decl::operator()(int a) const {
3537  Z3_ast args[1] = { ctx().num_val(a, domain(0)) };
3538  Z3_ast r = Z3_mk_app(ctx(), *this, 1, args);
3539  ctx().check_error();
3540  return expr(ctx(), r);
3541  }
3542  inline expr func_decl::operator()(expr const & a1, expr const & a2) const {
3543  check_context(*this, a1); check_context(*this, a2);
3544  Z3_ast args[2] = { a1, a2 };
3545  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3546  ctx().check_error();
3547  return expr(ctx(), r);
3548  }
3549  inline expr func_decl::operator()(expr const & a1, int a2) const {
3550  check_context(*this, a1);
3551  Z3_ast args[2] = { a1, ctx().num_val(a2, domain(1)) };
3552  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3553  ctx().check_error();
3554  return expr(ctx(), r);
3555  }
3556  inline expr func_decl::operator()(int a1, expr const & a2) const {
3557  check_context(*this, a2);
3558  Z3_ast args[2] = { ctx().num_val(a1, domain(0)), a2 };
3559  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3560  ctx().check_error();
3561  return expr(ctx(), r);
3562  }
3563  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3) const {
3564  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3);
3565  Z3_ast args[3] = { a1, a2, a3 };
3566  Z3_ast r = Z3_mk_app(ctx(), *this, 3, args);
3567  ctx().check_error();
3568  return expr(ctx(), r);
3569  }
3570  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4) const {
3571  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3); check_context(*this, a4);
3572  Z3_ast args[4] = { a1, a2, a3, a4 };
3573  Z3_ast r = Z3_mk_app(ctx(), *this, 4, args);
3574  ctx().check_error();
3575  return expr(ctx(), r);
3576  }
3577  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4, expr const & a5) const {
3578  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3); check_context(*this, a4); check_context(*this, a5);
3579  Z3_ast args[5] = { a1, a2, a3, a4, a5 };
3580  Z3_ast r = Z3_mk_app(ctx(), *this, 5, args);
3581  ctx().check_error();
3582  return expr(ctx(), r);
3583  }
3584 
3585  inline expr to_real(expr const & a) { Z3_ast r = Z3_mk_int2real(a.ctx(), a); a.check_error(); return expr(a.ctx(), r); }
3586 
3587  inline func_decl function(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3588  return range.ctx().function(name, arity, domain, range);
3589  }
3590  inline func_decl function(char const * name, unsigned arity, sort const * domain, sort const & range) {
3591  return range.ctx().function(name, arity, domain, range);
3592  }
3593  inline func_decl function(char const * name, sort const & domain, sort const & range) {
3594  return range.ctx().function(name, domain, range);
3595  }
3596  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & range) {
3597  return range.ctx().function(name, d1, d2, range);
3598  }
3599  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range) {
3600  return range.ctx().function(name, d1, d2, d3, range);
3601  }
3602  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range) {
3603  return range.ctx().function(name, d1, d2, d3, d4, range);
3604  }
3605  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & d5, sort const & range) {
3606  return range.ctx().function(name, d1, d2, d3, d4, d5, range);
3607  }
3608  inline func_decl function(char const* name, sort_vector const& domain, sort const& range) {
3609  return range.ctx().function(name, domain, range);
3610  }
3611  inline func_decl function(std::string const& name, sort_vector const& domain, sort const& range) {
3612  return range.ctx().function(name.c_str(), domain, range);
3613  }
3614 
3615  inline func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3616  return range.ctx().recfun(name, arity, domain, range);
3617  }
3618  inline func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range) {
3619  return range.ctx().recfun(name, arity, domain, range);
3620  }
3621  inline func_decl recfun(char const * name, sort const& d1, sort const & range) {
3622  return range.ctx().recfun(name, d1, range);
3623  }
3624  inline func_decl recfun(char const * name, sort const& d1, sort const& d2, sort const & range) {
3625  return range.ctx().recfun(name, d1, d2, range);
3626  }
3627 
3628  inline expr select(expr const & a, expr const & i) {
3629  check_context(a, i);
3630  Z3_ast r = Z3_mk_select(a.ctx(), a, i);
3631  a.check_error();
3632  return expr(a.ctx(), r);
3633  }
3634  inline expr select(expr const & a, int i) {
3635  return select(a, a.ctx().num_val(i, a.get_sort().array_domain()));
3636  }
3637  inline expr select(expr const & a, expr_vector const & i) {
3638  check_context(a, i);
3639  array<Z3_ast> idxs(i);
3640  Z3_ast r = Z3_mk_select_n(a.ctx(), a, idxs.size(), idxs.ptr());
3641  a.check_error();
3642  return expr(a.ctx(), r);
3643  }
3644 
3645  inline expr store(expr const & a, expr const & i, expr const & v) {
3646  check_context(a, i); check_context(a, v);
3647  Z3_ast r = Z3_mk_store(a.ctx(), a, i, v);
3648  a.check_error();
3649  return expr(a.ctx(), r);
3650  }
3651 
3652  inline expr store(expr const & a, int i, expr const & v) { return store(a, a.ctx().num_val(i, a.get_sort().array_domain()), v); }
3653  inline expr store(expr const & a, expr i, int v) { return store(a, i, a.ctx().num_val(v, a.get_sort().array_range())); }
3654  inline expr store(expr const & a, int i, int v) {
3655  return store(a, a.ctx().num_val(i, a.get_sort().array_domain()), a.ctx().num_val(v, a.get_sort().array_range()));
3656  }
3657  inline expr store(expr const & a, expr_vector const & i, expr const & v) {
3658  check_context(a, i); check_context(a, v);
3659  array<Z3_ast> idxs(i);
3660  Z3_ast r = Z3_mk_store_n(a.ctx(), a, idxs.size(), idxs.ptr(), v);
3661  a.check_error();
3662  return expr(a.ctx(), r);
3663  }
3664 
3665  inline expr as_array(func_decl & f) {
3666  Z3_ast r = Z3_mk_as_array(f.ctx(), f);
3667  f.check_error();
3668  return expr(f.ctx(), r);
3669  }
3670 
3671 #define MK_EXPR1(_fn, _arg) \
3672  Z3_ast r = _fn(_arg.ctx(), _arg); \
3673  _arg.check_error(); \
3674  return expr(_arg.ctx(), r);
3675 
3676 #define MK_EXPR2(_fn, _arg1, _arg2) \
3677  check_context(_arg1, _arg2); \
3678  Z3_ast r = _fn(_arg1.ctx(), _arg1, _arg2); \
3679  _arg1.check_error(); \
3680  return expr(_arg1.ctx(), r);
3681 
3682  inline expr const_array(sort const & d, expr const & v) {
3683  MK_EXPR2(Z3_mk_const_array, d, v);
3684  }
3685 
3686  inline expr empty_set(sort const& s) {
3688  }
3689 
3690  inline expr full_set(sort const& s) {
3692  }
3693 
3694  inline expr set_add(expr const& s, expr const& e) {
3695  MK_EXPR2(Z3_mk_set_add, s, e);
3696  }
3697 
3698  inline expr set_del(expr const& s, expr const& e) {
3699  MK_EXPR2(Z3_mk_set_del, s, e);
3700  }
3701 
3702  inline expr set_union(expr const& a, expr const& b) {
3703  check_context(a, b);
3704  Z3_ast es[2] = { a, b };
3705  Z3_ast r = Z3_mk_set_union(a.ctx(), 2, es);
3706  a.check_error();
3707  return expr(a.ctx(), r);
3708  }
3709 
3710  inline expr set_intersect(expr const& a, expr const& b) {
3711  check_context(a, b);
3712  Z3_ast es[2] = { a, b };
3713  Z3_ast r = Z3_mk_set_intersect(a.ctx(), 2, es);
3714  a.check_error();
3715  return expr(a.ctx(), r);
3716  }
3717 
3718  inline expr set_difference(expr const& a, expr const& b) {
3720  }
3721 
3722  inline expr set_complement(expr const& a) {
3724  }
3725 
3726  inline expr set_member(expr const& s, expr const& e) {
3727  MK_EXPR2(Z3_mk_set_member, s, e);
3728  }
3729 
3730  inline expr set_subset(expr const& a, expr const& b) {
3731  MK_EXPR2(Z3_mk_set_subset, a, b);
3732  }
3733 
3734  // sequence and regular expression operations.
3735  // union is +
3736  // concat is overloaded to handle sequences and regular expressions
3737 
3738  inline expr empty(sort const& s) {
3739  Z3_ast r = Z3_mk_seq_empty(s.ctx(), s);
3740  s.check_error();
3741  return expr(s.ctx(), r);
3742  }
3743  inline expr suffixof(expr const& a, expr const& b) {
3744  check_context(a, b);
3745  Z3_ast r = Z3_mk_seq_suffix(a.ctx(), a, b);
3746  a.check_error();
3747  return expr(a.ctx(), r);
3748  }
3749  inline expr prefixof(expr const& a, expr const& b) {
3750  check_context(a, b);
3751  Z3_ast r = Z3_mk_seq_prefix(a.ctx(), a, b);
3752  a.check_error();
3753  return expr(a.ctx(), r);
3754  }
3755  inline expr indexof(expr const& s, expr const& substr, expr const& offset) {
3756  check_context(s, substr); check_context(s, offset);
3757  Z3_ast r = Z3_mk_seq_index(s.ctx(), s, substr, offset);
3758  s.check_error();
3759  return expr(s.ctx(), r);
3760  }
3761  inline expr last_indexof(expr const& s, expr const& substr) {
3762  check_context(s, substr);
3763  Z3_ast r = Z3_mk_seq_last_index(s.ctx(), s, substr);
3764  s.check_error();
3765  return expr(s.ctx(), r);
3766  }
3767  inline expr to_re(expr const& s) {
3769  }
3770  inline expr in_re(expr const& s, expr const& re) {
3771  MK_EXPR2(Z3_mk_seq_in_re, s, re);
3772  }
3773  inline expr plus(expr const& re) {
3774  MK_EXPR1(Z3_mk_re_plus, re);
3775  }
3776  inline expr option(expr const& re) {
3778  }
3779  inline expr star(expr const& re) {
3780  MK_EXPR1(Z3_mk_re_star, re);
3781  }
3782  inline expr re_empty(sort const& s) {
3783  Z3_ast r = Z3_mk_re_empty(s.ctx(), s);
3784  s.check_error();
3785  return expr(s.ctx(), r);
3786  }
3787  inline expr re_full(sort const& s) {
3788  Z3_ast r = Z3_mk_re_full(s.ctx(), s);
3789  s.check_error();
3790  return expr(s.ctx(), r);
3791  }
3792  inline expr re_intersect(expr_vector const& args) {
3793  assert(args.size() > 0);
3794  context& ctx = args[0].ctx();
3795  array<Z3_ast> _args(args);
3796  Z3_ast r = Z3_mk_re_intersect(ctx, _args.size(), _args.ptr());
3797  ctx.check_error();
3798  return expr(ctx, r);
3799  }
3800  inline expr re_diff(expr const& a, expr const& b) {
3801  check_context(a, b);
3802  context& ctx = a.ctx();
3803  Z3_ast r = Z3_mk_re_diff(ctx, a, b);
3804  ctx.check_error();
3805  return expr(ctx, r);
3806  }
3807  inline expr re_complement(expr const& a) {
3809  }
3810  inline expr range(expr const& lo, expr const& hi) {
3811  check_context(lo, hi);
3812  Z3_ast r = Z3_mk_re_range(lo.ctx(), lo, hi);
3813  lo.check_error();
3814  return expr(lo.ctx(), r);
3815  }
3816 
3817 
3818 
3819 
3820 
3821  inline expr_vector context::parse_string(char const* s) {
3822  Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, 0, 0, 0, 0, 0, 0);
3823  check_error();
3824  return expr_vector(*this, r);
3825 
3826  }
3827  inline expr_vector context::parse_file(char const* s) {
3828  Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, 0, 0, 0, 0, 0, 0);
3829  check_error();
3830  return expr_vector(*this, r);
3831  }
3832 
3833  inline expr_vector context::parse_string(char const* s, sort_vector const& sorts, func_decl_vector const& decls) {
3834  array<Z3_symbol> sort_names(sorts.size());
3835  array<Z3_symbol> decl_names(decls.size());
3836  array<Z3_sort> sorts1(sorts);
3837  array<Z3_func_decl> decls1(decls);
3838  for (unsigned i = 0; i < sorts.size(); ++i) {
3839  sort_names[i] = sorts[i].name();
3840  }
3841  for (unsigned i = 0; i < decls.size(); ++i) {
3842  decl_names[i] = decls[i].name();
3843  }
3844 
3845  Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
3846  check_error();
3847  return expr_vector(*this, r);
3848  }
3849 
3850  inline expr_vector context::parse_file(char const* s, sort_vector const& sorts, func_decl_vector const& decls) {
3851  array<Z3_symbol> sort_names(sorts.size());
3852  array<Z3_symbol> decl_names(decls.size());
3853  array<Z3_sort> sorts1(sorts);
3854  array<Z3_func_decl> decls1(decls);
3855  for (unsigned i = 0; i < sorts.size(); ++i) {
3856  sort_names[i] = sorts[i].name();
3857  }
3858  for (unsigned i = 0; i < decls.size(); ++i) {
3859  decl_names[i] = decls[i].name();
3860  }
3861  Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
3862  check_error();
3863  return expr_vector(*this, r);
3864  }
3865 
3866 
3867  inline expr expr::substitute(expr_vector const& src, expr_vector const& dst) {
3868  assert(src.size() == dst.size());
3869  array<Z3_ast> _src(src.size());
3870  array<Z3_ast> _dst(dst.size());
3871  for (unsigned i = 0; i < src.size(); ++i) {
3872  _src[i] = src[i];
3873  _dst[i] = dst[i];
3874  }
3875  Z3_ast r = Z3_substitute(ctx(), m_ast, src.size(), _src.ptr(), _dst.ptr());
3876  check_error();
3877  return expr(ctx(), r);
3878  }
3879 
3880  inline expr expr::substitute(expr_vector const& dst) {
3881  array<Z3_ast> _dst(dst.size());
3882  for (unsigned i = 0; i < dst.size(); ++i) {
3883  _dst[i] = dst[i];
3884  }
3885  Z3_ast r = Z3_substitute_vars(ctx(), m_ast, dst.size(), _dst.ptr());
3886  check_error();
3887  return expr(ctx(), r);
3888  }
3889 
3890 
3892 
3893  typedef std::function<void(unsigned, expr const&)> fixed_eh_t;
3894  typedef std::function<void(void)> final_eh_t;
3895  typedef std::function<void(unsigned, unsigned)> eq_eh_t;
3896  typedef std::function<void(unsigned, expr const&)> created_eh_t;
3897 
3898  final_eh_t m_final_eh;
3899  eq_eh_t m_eq_eh;
3900  fixed_eh_t m_fixed_eh;
3901  created_eh_t m_created_eh;
3902  solver* s;
3903  Z3_context c;
3904  Z3_solver_callback cb { nullptr };
3905 
3906  Z3_context ctx() {
3907  return c ? c : (Z3_context)s->ctx();
3908  }
3909 
3910  struct scoped_cb {
3912  scoped_cb(void* _p, Z3_solver_callback cb):p(*static_cast<user_propagator_base*>(_p)) {
3913  p.cb = cb;
3914  }
3915  ~scoped_cb() {
3916  p.cb = nullptr;
3917  }
3918  };
3919 
3920  static void push_eh(void* p) {
3921  static_cast<user_propagator_base*>(p)->push();
3922  }
3923 
3924  static void pop_eh(void* p, unsigned num_scopes) {
3925  static_cast<user_propagator_base*>(p)->pop(num_scopes);
3926  }
3927 
3928  static void* fresh_eh(void* p, Z3_context ctx) {
3929  return static_cast<user_propagator_base*>(p)->fresh(ctx);
3930  }
3931 
3932  static void fixed_eh(void* _p, Z3_solver_callback cb, unsigned id, Z3_ast _value) {
3933  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
3934  scoped_cb _cb(p, cb);
3935  scoped_context ctx(p->ctx());
3936  expr value(ctx(), _value);
3937  static_cast<user_propagator_base*>(p)->m_fixed_eh(id, value);
3938  }
3939 
3940  static void eq_eh(void* p, Z3_solver_callback cb, unsigned x, unsigned y) {
3941  scoped_cb _cb(p, cb);
3942  static_cast<user_propagator_base*>(p)->m_eq_eh(x, y);
3943  }
3944 
3945  static void final_eh(void* p, Z3_solver_callback cb) {
3946  scoped_cb _cb(p, cb);
3947  static_cast<user_propagator_base*>(p)->m_final_eh();
3948  }
3949 
3950  static void created_eh(void* _p, Z3_solver_callback cb, Z3_ast _e, unsigned id) {
3951  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
3952  scoped_cb _cb(p, cb);
3953  scoped_context ctx(p->ctx());
3954  expr e(ctx(), _e);
3955  static_cast<user_propagator_base*>(p)->m_created_eh(id, e);
3956  }
3957 
3958 
3959  public:
3960  user_propagator_base(Z3_context c) : s(nullptr), c(c) {}
3961 
3962  user_propagator_base(solver* s): s(s), c(nullptr) {
3963  Z3_solver_propagate_init(ctx(), *s, this, push_eh, pop_eh, fresh_eh);
3964  }
3965 
3966  virtual void push() = 0;
3967  virtual void pop(unsigned num_scopes) = 0;
3968 
3969  virtual ~user_propagator_base() = default;
3970 
3979  virtual user_propagator_base* fresh(Z3_context ctx) = 0;
3980 
3987  void register_fixed(fixed_eh_t& f) {
3988  assert(s);
3989  m_fixed_eh = f;
3990  Z3_solver_propagate_fixed(ctx(), *s, fixed_eh);
3991  }
3992 
3994  assert(s);
3995  m_fixed_eh = [this](unsigned id, expr const& e) {
3996  fixed(id, e);
3997  };
3998  Z3_solver_propagate_fixed(ctx(), *s, fixed_eh);
3999  }
4000 
4001  void register_eq(eq_eh_t& f) {
4002  assert(s);
4003  m_eq_eh = f;
4004  Z3_solver_propagate_eq(ctx(), *s, eq_eh);
4005  }
4006 
4007  void register_eq() {
4008  assert(s);
4009  m_eq_eh = [this](unsigned x, unsigned y) {
4010  eq(x, y);
4011  };
4012  Z3_solver_propagate_eq(ctx(), *s, eq_eh);
4013  }
4014 
4023  void register_final(final_eh_t& f) {
4024  assert(s);
4025  m_final_eh = f;
4026  Z3_solver_propagate_final(ctx(), *s, final_eh);
4027  }
4028 
4029  void register_final() {
4030  assert(s);
4031  m_final_eh = [this]() {
4032  final();
4033  };
4034  Z3_solver_propagate_final(ctx(), *s, final_eh);
4035  }
4036 
4037  void register_created(created_eh_t& c) {
4038  assert(s);
4039  m_created_eh = c;
4040  Z3_solver_propagate_created(ctx(), *s, created_eh);
4041  }
4042 
4044  m_created_eh = [this](unsigned id, expr const& e) {
4045  created(id, e);
4046  };
4047  Z3_solver_propagate_created(ctx(), *s, created_eh);
4048  }
4049 
4050  virtual void fixed(unsigned /*id*/, expr const& /*e*/) { }
4051 
4052  virtual void eq(unsigned /*x*/, unsigned /*y*/) { }
4053 
4054  virtual void final() { }
4055 
4056  virtual void created(unsigned /*id*/, expr const& /*e*/) {}
4057 
4072  unsigned add(expr const& e) {
4073  if (cb)
4074  return Z3_solver_propagate_register_cb(ctx(), cb, e);
4075  if (s)
4076  return Z3_solver_propagate_register(ctx(), *s, e);
4077  assert(false);
4078  return 0;
4079  }
4080 
4081  void conflict(unsigned num_fixed, unsigned const* fixed) {
4082  assert(cb);
4083  scoped_context _ctx(ctx());
4084  expr conseq = _ctx().bool_val(false);
4085  Z3_solver_propagate_consequence(ctx(), cb, num_fixed, fixed, 0, nullptr, nullptr, conseq);
4086  }
4087 
4088  void propagate(unsigned num_fixed, unsigned const* fixed, expr const& conseq) {
4089  assert(cb);
4090  assert(conseq.ctx() == ctx());
4091  Z3_solver_propagate_consequence(ctx(), cb, num_fixed, fixed, 0, nullptr, nullptr, conseq);
4092  }
4093 
4094  void propagate(unsigned num_fixed, unsigned const* fixed,
4095  unsigned num_eqs, unsigned const* lhs, unsigned const * rhs,
4096  expr const& conseq) {
4097  assert(cb);
4098  assert(conseq.ctx() == ctx());
4099  Z3_solver_propagate_consequence(ctx(), cb, num_fixed, fixed, num_eqs, lhs, rhs, conseq);
4100  }
4101  };
4102 
4103 
4104 
4105 
4106 }
4107 
4110 #undef Z3_THROW
4111 
unsigned size() const
Definition: z3++.h:2913
apply_result & operator=(apply_result const &s)
Definition: z3++.h:2906
apply_result(context &c, Z3_apply_result s)
Definition: z3++.h:2902
goal operator[](int i) const
Definition: z3++.h:2914
apply_result(apply_result const &s)
Definition: z3++.h:2903
friend std::ostream & operator<<(std::ostream &out, apply_result const &r)
Definition: z3++.h:2917
T & operator[](int i)
Definition: z3++.h:418
unsigned size() const
Definition: z3++.h:417
void resize(unsigned sz)
Definition: z3++.h:416
T * ptr()
Definition: z3++.h:421
array(unsigned sz)
Definition: z3++.h:413
T const * ptr() const
Definition: z3++.h:420
T const & operator[](int i) const
Definition: z3++.h:419
iterator(ast_vector_tpl const *v, unsigned i)
Definition: z3++.h:582
bool operator==(iterator const &other) const noexcept
Definition: z3++.h:584
iterator operator++(int) noexcept
Definition: z3++.h:597
T * operator->() const
Definition: z3++.h:598
iterator & operator++() noexcept
Definition: z3++.h:590
bool operator!=(iterator const &other) const noexcept
Definition: z3++.h:587
void pop_back()
Definition: z3++.h:557
friend std::ostream & operator<<(std::ostream &out, ast_vector_tpl const &v)
Definition: z3++.h:603
ast_vector_tpl & set(unsigned idx, ast &a)
Definition: z3++.h:566
unsigned size() const
Definition: z3++.h:552
void resize(unsigned sz)
Definition: z3++.h:555
ast_vector_tpl(ast_vector_tpl const &s)
Definition: z3++.h:547
bool empty() const
Definition: z3++.h:558
iterator end() const
Definition: z3++.h:602
ast_vector_tpl(context &c, Z3_ast_vector v)
Definition: z3++.h:546
void push_back(T const &e)
Definition: z3++.h:554
T back() const
Definition: z3++.h:556
std::string to_string() const
Definition: z3++.h:604
ast_vector_tpl & operator=(ast_vector_tpl const &s)
Definition: z3++.h:559
T operator[](int i) const
Definition: z3++.h:553
ast_vector_tpl(context &c, ast_vector_tpl const &src)
Definition: z3++.h:548
ast_vector_tpl(context &c)
Definition: z3++.h:545
iterator begin() const noexcept
Definition: z3++.h:601
Definition: z3++.h:505
~ast()
Definition: z3++.h:512
ast(ast const &s)
Definition: z3++.h:511
ast & operator=(ast const &s)
Definition: z3++.h:515
friend bool eq(ast const &a, ast const &b)
Return true if the ASTs are structurally identical.
Definition: z3++.h:538
Z3_ast_kind kind() const
Definition: z3++.h:523
Z3_ast m_ast
Definition: z3++.h:507
ast(context &c)
Definition: z3++.h:509
std::string to_string() const
Definition: z3++.h:526
ast(context &c, Z3_ast n)
Definition: z3++.h:510
unsigned hash() const
Definition: z3++.h:524
friend std::ostream & operator<<(std::ostream &out, ast const &n)
Definition: z3++.h:534
ast operator()(context &c, Z3_ast a)
Definition: z3++.h:2209
expr operator()(context &c, Z3_ast a)
Definition: z3++.h:2214
func_decl operator()(context &c, Z3_ast a)
Definition: z3++.h:2233
sort operator()(context &c, Z3_ast a)
Definition: z3++.h:2225
Z3 global configuration object.
Definition: z3++.h:107
~config()
Definition: z3++.h:113
void set(char const *param, int value)
Set global parameter param with integer value.
Definition: z3++.h:126
void set(char const *param, char const *value)
Set global parameter param with string value.
Definition: z3++.h:118
config()
Definition: z3++.h:112
void set(char const *param, bool value)
Set global parameter param with Boolean value.
Definition: z3++.h:122
A Context manages all other Z3 objects, global configuration options, etc.
Definition: z3++.h:156
expr real_val(int n, int d)
Definition: z3++.h:3473
symbol str_symbol(char const *s)
Create a Z3 symbol based on the given string.
Definition: z3++.h:3262
expr num_val(int n, sort const &s)
Definition: z3++.h:3501
expr fpa_rounding_mode()
Definition: z3++.h:3454
context()
Definition: z3++.h:180
expr bv_val(int n, unsigned sz)
Definition: z3++.h:3480
func_decl recfun(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3397
expr bool_val(bool b)
Definition: z3++.h:3465
expr fpa_const(char const *name, unsigned ebits, unsigned sbits)
Definition: z3++.h:3447
expr string_val(char const *s)
Definition: z3++.h:3497
sort real_sort()
Return the Real sort.
Definition: z3++.h:3267
Z3_error_code check_error() const
Auxiliary method used to check for API usage errors.
Definition: z3++.h:188
expr bv_const(char const *name, unsigned sz)
Definition: z3++.h:3446
expr string_const(char const *name)
Definition: z3++.h:3445
sort array_sort(sort d, sort r)
Return an array sort for arrays from d to r.
Definition: z3++.h:3289
void set_enable_exceptions(bool f)
The C++ API uses by defaults exceptions on errors. For applications that don't work well with excepti...
Definition: z3++.h:206
sort string_sort()
Return the sort for Unicode strings.
Definition: z3++.h:3269
sort re_sort(sort &seq_sort)
Return a regular expression sort over sequences seq_sort.
Definition: z3++.h:3272
sort uninterpreted_sort(char const *name)
create an uninterpreted sort with the name given by the string or symbol.
Definition: z3++.h:3318
sort enumeration_sort(char const *name, unsigned n, char const *const *enum_names, func_decl_vector &cs, func_decl_vector &ts)
Return an enumeration sort: enum_names[0], ..., enum_names[n-1]. cs and ts are output parameters....
Definition: z3++.h:3294
void set(char const *param, int value)
Update global parameter param with Integer value.
Definition: z3++.h:221
sort bool_sort()
Return the Boolean sort.
Definition: z3++.h:3265
void set(char const *param, char const *value)
Update global parameter param with string value.
Definition: z3++.h:213
~context()
Definition: z3++.h:182
expr bool_const(char const *name)
Definition: z3++.h:3442
void check_parser_error() const
Definition: z3++.h:195
expr_vector parse_string(char const *s)
parsing
Definition: z3++.h:3821
sort fpa_sort()
Definition: z3++.h:3276
symbol int_symbol(int n)
Create a Z3 symbol based on the given integer.
Definition: z3++.h:3263
expr real_const(char const *name)
Definition: z3++.h:3444
expr int_const(char const *name)
Definition: z3++.h:3443
expr fpa_nan(sort const &s)
Definition: z3++.h:3493
expr fpa_val(double n)
Definition: z3++.h:3491
bool enable_exceptions() const
Definition: z3++.h:208
sort bv_sort(unsigned sz)
Return the Bit-vector sort of size sz. That is, the sort for bit-vectors of size sz.
Definition: z3++.h:3268
expr int_val(int n)
Definition: z3++.h:3467
expr fpa_inf(sort const &s, bool sgn)
Definition: z3++.h:3494
func_decl function(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3326
sort fpa_rounding_mode_sort()
Return a RoundingMode sort.
Definition: z3++.h:3287
expr_vector parse_file(char const *file)
Definition: z3++.h:3827
expr constant(symbol const &name, sort const &s)
Definition: z3++.h:3436
sort char_sort()
Return the sort for Unicode characters.
Definition: z3++.h:3270
func_decl tuple_sort(char const *name, unsigned n, char const *const *names, sort const *sorts, func_decl_vector &projs)
Return a tuple constructor. name is the name of the returned constructor, n are the number of argumen...
Definition: z3++.h:3305
void set(char const *param, bool value)
Update global parameter param with Boolean value.
Definition: z3++.h:217
sort int_sort()
Return the integer sort.
Definition: z3++.h:3266
void interrupt()
Interrupt the current procedure being executed by any object managed by this context....
Definition: z3++.h:230
void set_rounding_mode(rounding_mode rm)
Sets RoundingMode of FloatingPoints.
Definition: z3++.h:3452
func_decl user_propagate_function(symbol const &name, sort_vector const &domain, sort const &range)
Definition: z3++.h:3428
sort fpa_sort()
Return a FloatingPoint sort with given precision bitwidth (16, 32, 64 or 128).
context(config &c)
Definition: z3++.h:181
void recdef(func_decl, expr_vector const &args, expr const &body)
Definition: z3++.h:3422
sort seq_sort(sort &s)
Return a sequence sort over base sort s.
Definition: z3++.h:3271
Exception used to sign API usage errors.
Definition: z3++.h:85
friend std::ostream & operator<<(std::ostream &out, exception const &e)
Definition: z3++.h:94
char const * msg() const
Definition: z3++.h:90
virtual ~exception()
Definition: z3++.h:88
exception(char const *msg)
Definition: z3++.h:89
char const * what() const
Definition: z3++.h:91
iterator operator++(int)
Definition: z3++.h:1540
bool operator!=(iterator const &other) noexcept
Definition: z3++.h:1535
iterator(expr &e, unsigned i)
Definition: z3++.h:1531
bool operator==(iterator const &other) noexcept
Definition: z3++.h:1532
expr operator*() const
Definition: z3++.h:1538
iterator & operator++()
Definition: z3++.h:1539
A Z3 expression is used to represent formulas and terms. For Z3, a formula is any expression of sort ...
Definition: z3++.h:756
bool is_lambda() const
Return true if this expression is a lambda expression.
Definition: z3++.h:865
expr numerator() const
Definition: z3++.h:1082
friend expr pw(expr const &a, expr const &b)
Definition: z3++.h:1563
friend expr sbv_to_fpa(expr const &t, sort s)
Conversion of a signed bit-vector term into a floating-point.
Definition: z3++.h:1985
friend expr bvneg_no_overflow(expr const &a)
Definition: z3++.h:2178
expr loop(unsigned lo, unsigned hi)
Definition: z3++.h:1486
expr body() const
Return the 'body' of this quantifier.
Definition: z3++.h:1160
friend expr bvadd_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2166
expr ubvtos() const
Definition: z3++.h:1446
friend expr sum(expr_vector const &args)
Definition: z3++.h:2362
expr substitute(expr_vector const &src, expr_vector const &dst)
Apply substitution. Replace src expressions by dst.
Definition: z3++.h:3867
bool is_quantifier() const
Return true if this expression is a quantifier.
Definition: z3++.h:852
bool is_exists() const
Return true if this expression is an existential quantifier.
Definition: z3++.h:861
bool is_numeral_u64(uint64_t &i) const
Definition: z3++.h:828
bool is_int() const
Return true if this is an integer expression.
Definition: z3++.h:773
expr rotate_left(unsigned i)
Definition: z3++.h:1337
friend expr operator/(expr const &a, expr const &b)
Definition: z3++.h:1729
friend expr fp_eq(expr const &a, expr const &b)
Definition: z3++.h:1946
friend expr concat(expr const &a, expr const &b)
Definition: z3++.h:2380
friend expr bvmul_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2184
int64_t get_numeral_int64() const
Return int64_t value of numeral, throw if result cannot fit in int64_t.
Definition: z3++.h:1050
bool is_app() const
Return true if this expression is an application.
Definition: z3++.h:844
friend expr fpa_to_fpa(expr const &t, sort s)
Conversion of a floating-point term into another floating-point.
Definition: z3++.h:1999
friend expr operator&&(expr const &a, expr const &b)
Return an expression representing a and b.
Definition: z3++.h:1607
friend expr operator!=(expr const &a, expr const &b)
Definition: z3++.h:1643
friend expr operator+(expr const &a, expr const &b)
Definition: z3++.h:1655
std::string get_string() const
for a string value expression return an escaped string value.
Definition: z3++.h:1109
bool is_numeral(std::string &s) const
Definition: z3++.h:831
expr char_to_int() const
Definition: z3++.h:1456
bool is_var() const
Return true if this expression is a variable.
Definition: z3++.h:870
bool is_numeral_u(unsigned &i) const
Definition: z3++.h:830
friend expr min(expr const &a, expr const &b)
Definition: z3++.h:1877
expr at(expr const &index) const
Definition: z3++.h:1419
expr denominator() const
Definition: z3++.h:1090
bool is_real() const
Return true if this is a real expression.
Definition: z3++.h:777
bool is_numeral_i(int &i) const
Definition: z3++.h:829
friend expr operator>(expr const &a, expr const &b)
Definition: z3++.h:1840
expr mk_is_nan() const
Return Boolean expression to test for whether an FP expression is a NaN.
Definition: z3++.h:894
int get_numeral_int() const
Return int value of numeral, throw if result cannot fit in machine int.
Definition: z3++.h:1014
expr is_digit() const
Definition: z3++.h:1471
friend expr bv2int(expr const &a, bool is_signed)
bit-vector and integer conversions.
Definition: z3++.h:2157
friend expr operator~(expr const &a)
Definition: z3++.h:1953
unsigned num_args() const
Return the number of arguments in this application. This method assumes the expression is an applicat...
Definition: z3++.h:1145
friend expr nor(expr const &a, expr const &b)
Definition: z3++.h:1875
friend expr fpa_fp(expr const &sgn, expr const &exp, expr const &sig)
Create an expression of FloatingPoint sort from three bit-vector expressions.
Definition: z3++.h:1963
expr arg(unsigned i) const
Return the i-th argument of this application. This method assumes the expression is an application.
Definition: z3++.h:1153
expr mk_is_normal() const
Return Boolean expression to test for whether an FP expression is a normal.
Definition: z3++.h:904
friend expr bvsub_no_underflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2172
bool is_true() const
Definition: z3++.h:1226
expr(context &c)
Definition: z3++.h:758
friend expr mk_xor(expr_vector const &args)
Definition: z3++.h:2436
bool is_numeral(std::string &s, unsigned precision) const
Definition: z3++.h:832
unsigned get_numeral_uint() const
Return uint value of numeral, throw if result cannot fit in machine uint.
Definition: z3++.h:1033
bool is_distinct() const
Definition: z3++.h:1235
bool is_numeral(double &d) const
Definition: z3++.h:833
friend expr operator*(expr const &a, expr const &b)
Definition: z3++.h:1685
sort get_sort() const
Return the sort of this expression.
Definition: z3++.h:764
friend expr nand(expr const &a, expr const &b)
Definition: z3++.h:1874
bool is_and() const
Definition: z3++.h:1229
friend expr fpa_to_ubv(expr const &t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.
Definition: z3++.h:1978
friend expr bvredor(expr const &a)
Definition: z3++.h:1907
expr extract(unsigned hi, unsigned lo) const
Definition: z3++.h:1349
friend expr int2bv(unsigned n, expr const &a)
Definition: z3++.h:2158
friend expr max(expr const &a, expr const &b)
Definition: z3++.h:1892
bool is_relation() const
Return true if this is a Relation expression.
Definition: z3++.h:797
friend expr xnor(expr const &a, expr const &b)
Definition: z3++.h:1876
friend expr abs(expr const &a)
Definition: z3++.h:1919
friend expr pbge(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2330
bool is_well_sorted() const
Return true if this expression is well sorted (aka type correct).
Definition: z3++.h:879
bool is_or() const
Definition: z3++.h:1230
friend expr round_fpa_to_closest_integer(expr const &t)
Round a floating-point term into its closest integer.
Definition: z3++.h:2006
friend expr distinct(expr_vector const &args)
Definition: z3++.h:2371
friend expr bvmul_no_overflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2181
friend expr bvsub_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2169
bool is_const() const
Return true if this expression is a constant (i.e., an application with 0 arguments).
Definition: z3++.h:848
expr length() const
Definition: z3++.h:1431
friend expr mod(expr const &a, expr const &b)
Definition: z3++.h:1567
friend expr fma(expr const &a, expr const &b, expr const &c, expr const &rm)
FloatingPoint fused multiply-add.
Definition: z3++.h:1955
bool is_bool() const
Return true if this is a Boolean expression.
Definition: z3++.h:769
friend expr mk_or(expr_vector const &args)
Definition: z3++.h:2424
expr contains(expr const &s) const
Definition: z3++.h:1413
friend expr ite(expr const &c, expr const &t, expr const &e)
Create the if-then-else expression ite(c, t, e)
Definition: z3++.h:2018
expr algebraic_lower(unsigned precision) const
Definition: z3++.h:965
unsigned hi() const
Definition: z3++.h:1351
expr simplify() const
Return a simplified version of this expression.
Definition: z3++.h:1510
bool is_arith() const
Return true if this is an integer or real expression.
Definition: z3++.h:781
expr mk_is_inf() const
Return Boolean expression to test for whether an FP expression is inf.
Definition: z3++.h:884
expr stoi() const
Definition: z3++.h:1436
expr_vector algebraic_poly() const
Return coefficients for p of an algebraic number (root-obj p i)
Definition: z3++.h:982
bool is_ite() const
Definition: z3++.h:1234
bool is_bv() const
Return true if this is a Bit-vector expression.
Definition: z3++.h:785
friend expr pbeq(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2338
friend expr operator^(expr const &a, expr const &b)
Definition: z3++.h:1866
friend expr operator<=(expr const &a, expr const &b)
Definition: z3++.h:1793
friend expr operator>=(expr const &a, expr const &b)
Definition: z3++.h:1709
friend expr sqrt(expr const &a, expr const &rm)
Definition: z3++.h:1939
friend expr pble(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2322
friend expr operator==(expr const &a, expr const &b)
Definition: z3++.h:1632
bool is_finite_domain() const
Return true if this is a Finite-domain expression.
Definition: z3++.h:815
expr operator[](expr_vector const &index) const
Definition: z3++.h:1503
bool is_forall() const
Return true if this expression is a universal quantifier.
Definition: z3++.h:857
bool is_implies() const
Definition: z3++.h:1232
uint64_t as_uint64() const
Definition: z3++.h:837
friend expr implies(expr const &a, expr const &b)
Definition: z3++.h:1555
expr mk_is_subnormal() const
Return Boolean expression to test for whether an FP expression is a subnormal.
Definition: z3++.h:914
uint64_t get_numeral_uint64() const
Return uint64_t value of numeral, throw if result cannot fit in uint64_t.
Definition: z3++.h:1067
expr(context &c, Z3_ast n)
Definition: z3++.h:759
friend expr bvadd_no_overflow(expr const &a, expr const &b, bool is_signed)
bit-vector overflow/underflow checks
Definition: z3++.h:2163
bool is_datatype() const
Return true if this is a Datatype expression.
Definition: z3++.h:793
bool is_not() const
Definition: z3++.h:1228
bool is_string_value() const
Return true if this expression is a string literal. The string can be accessed using get_string() and...
Definition: z3++.h:1102
expr simplify(params const &p) const
Return a simplified version of this expression. The parameter p is a set of parameters for the Z3 sim...
Definition: z3++.h:1514
expr loop(unsigned lo)
create a looping regular expression.
Definition: z3++.h:1481
expr sbvtos() const
Definition: z3++.h:1451
expr mk_from_ieee_bv(sort const &s) const
Convert this IEEE BV into a fpa.
Definition: z3++.h:944
friend expr bvredand(expr const &a)
Definition: z3++.h:1913
friend expr operator&(expr const &a, expr const &b)
Definition: z3++.h:1862
friend expr operator-(expr const &a)
Definition: z3++.h:1751
friend expr bvsdiv_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2175
expr extract(expr const &offset, expr const &length) const
sequence and regular expression operations.
Definition: z3++.h:1398
bool is_eq() const
Definition: z3++.h:1233
expr rotate_right(unsigned i)
Definition: z3++.h:1338
expr unit() const
Definition: z3++.h:1408
bool is_re() const
Return true if this is a regular expression.
Definition: z3++.h:805
bool is_numeral_i64(int64_t &i) const
Definition: z3++.h:827
bool as_binary(std::string &s) const
Definition: z3++.h:834
unsigned id() const
retrieve unique identifier for expression.
Definition: z3++.h:1002
friend expr rem(expr const &a, expr const &b)
Definition: z3++.h:1583
friend expr operator!(expr const &a)
Return an expression representing not(a).
Definition: z3++.h:1601
bool is_algebraic() const
Return true if expression is an algebraic number.
Definition: z3++.h:874
expr repeat(unsigned i)
Definition: z3++.h:1339
friend expr mk_and(expr_vector const &args)
Definition: z3++.h:2430
expr itos() const
Definition: z3++.h:1441
bool is_false() const
Definition: z3++.h:1227
int64_t as_int64() const
Definition: z3++.h:838
double as_double() const
Definition: z3++.h:836
iterator end()
Definition: z3++.h:1544
expr mk_is_zero() const
Return Boolean expression to test for whether an FP expression is a zero.
Definition: z3++.h:924
std::u32string get_u32string() const
for a string value expression return an unespaced string value.
Definition: z3++.h:1121
std::string get_decimal_string(int precision) const
Return string representation of numeral or algebraic number This method assumes the expression is num...
Definition: z3++.h:957
Z3_lbool bool_value() const
Definition: z3++.h:1078
expr replace(expr const &src, expr const &dst) const
Definition: z3++.h:1402
iterator begin()
Definition: z3++.h:1543
friend expr operator||(expr const &a, expr const &b)
Return an expression representing a or b.
Definition: z3++.h:1619
bool is_array() const
Return true if this is a Array expression.
Definition: z3++.h:789
bool is_xor() const
Definition: z3++.h:1231
unsigned algebraic_i() const
Return i of an algebraic number (root-obj p i)
Definition: z3++.h:992
unsigned lo() const
Definition: z3++.h:1350
friend expr ubv_to_fpa(expr const &t, sort s)
Conversion of an unsigned bit-vector term into a floating-point.
Definition: z3++.h:1992
expr nth(expr const &index) const
Definition: z3++.h:1425
friend expr fpa_to_sbv(expr const &t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.
Definition: z3++.h:1971
bool is_seq() const
Return true if this is a sequence expression.
Definition: z3++.h:801
friend expr operator|(expr const &a, expr const &b)
Definition: z3++.h:1870
friend expr atmost(expr_vector const &es, unsigned bound)
Definition: z3++.h:2346
friend expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3810
expr char_from_bv() const
Definition: z3++.h:1466
friend expr atleast(expr_vector const &es, unsigned bound)
Definition: z3++.h:2354
friend expr operator<(expr const &a, expr const &b)
Definition: z3++.h:1818
expr mk_to_ieee_bv() const
Convert this fpa into an IEEE BV.
Definition: z3++.h:934
expr operator[](expr const &index) const
Definition: z3++.h:1495
expr algebraic_upper(unsigned precision) const
Definition: z3++.h:972
bool is_numeral() const
Return true if this expression is a numeral. Specialized functions also return representations for th...
Definition: z3++.h:826
bool is_fpa() const
Return true if this is a FloatingPoint expression. .
Definition: z3++.h:819
func_decl decl() const
Return the declaration associated with this application. This method assumes the expression is an app...
Definition: z3++.h:1138
expr char_to_bv() const
Definition: z3++.h:1461
std::string to_string(expr_vector const &queries)
Definition: z3++.h:3237
std::string help() const
Definition: z3++.h:3234
expr_vector from_string(char const *s)
Definition: z3++.h:3200
void add_fact(func_decl &f, unsigned *args)
Definition: z3++.h:3211
fixedpoint & operator=(fixedpoint const &o)
Definition: z3++.h:3192
void add_cover(int level, func_decl &p, expr &property)
Definition: z3++.h:3228
expr_vector rules() const
Definition: z3++.h:3232
stats statistics() const
Definition: z3++.h:3229
expr get_answer()
Definition: z3++.h:3219
expr get_cover_delta(int level, func_decl &p)
Definition: z3++.h:3223
fixedpoint(context &c)
Definition: z3++.h:3189
std::string reason_unknown()
Definition: z3++.h:3220
check_result query(func_decl_vector &relations)
Definition: z3++.h:3213
void register_relation(func_decl &p)
Definition: z3++.h:3230
std::string to_string()
Definition: z3++.h:3236
check_result query(expr &q)
Definition: z3++.h:3212
param_descrs get_param_descrs()
Definition: z3++.h:3235
expr_vector from_file(char const *s)
Definition: z3++.h:3205
void update_rule(expr &rule, symbol const &name)
Definition: z3++.h:3221
expr_vector assertions() const
Definition: z3++.h:3231
fixedpoint(fixedpoint const &o)
Definition: z3++.h:3190
unsigned get_num_levels(func_decl &p)
Definition: z3++.h:3222
void add_rule(expr &rule, symbol const &name)
Definition: z3++.h:3210
void set(params const &p)
Definition: z3++.h:3233
Function declaration (aka function definition). It is the signature of interpreted and uninterpreted ...
Definition: z3++.h:710
func_decl transitive_closure(func_decl const &)
Definition: z3++.h:727
func_decl(context &c, Z3_func_decl n)
Definition: z3++.h:713
symbol name() const
Definition: z3++.h:724
expr operator()() const
Definition: z3++.h:3524
bool is_const() const
Definition: z3++.h:731
sort range() const
Definition: z3++.h:723
func_decl(context &c)
Definition: z3++.h:712
Z3_decl_kind decl_kind() const
Definition: z3++.h:725
sort domain(unsigned i) const
Definition: z3++.h:722
unsigned id() const
retrieve unique identifier for func_decl.
Definition: z3++.h:719
unsigned arity() const
Definition: z3++.h:721
Definition: z3++.h:2446
~func_entry()
Definition: z3++.h:2455
func_entry & operator=(func_entry const &s)
Definition: z3++.h:2457
unsigned num_args() const
Definition: z3++.h:2465
expr arg(unsigned i) const
Definition: z3++.h:2466
func_entry(context &c, Z3_func_entry e)
Definition: z3++.h:2453
expr value() const
Definition: z3++.h:2464
func_entry(func_entry const &s)
Definition: z3++.h:2454
expr else_value() const
Definition: z3++.h:2487
void set_else(expr &value)
Definition: z3++.h:2494
func_interp(context &c, Z3_func_interp e)
Definition: z3++.h:2476
func_interp(func_interp const &s)
Definition: z3++.h:2477
func_interp & operator=(func_interp const &s)
Definition: z3++.h:2480
func_entry entry(unsigned i) const
Definition: z3++.h:2489
void add_entry(expr_vector const &args, expr &value)
Definition: z3++.h:2490
unsigned num_entries() const
Definition: z3++.h:2488
void add(expr const &f)
Definition: z3++.h:2855
unsigned size() const
Definition: z3++.h:2857
Z3_goal_prec precision() const
Definition: z3++.h:2859
model convert_model(model const &m) const
Definition: z3++.h:2866
bool is_decided_unsat() const
Definition: z3++.h:2865
goal(goal const &s)
Definition: z3++.h:2845
friend std::ostream & operator<<(std::ostream &out, goal const &g)
Definition: z3++.h:2893
bool inconsistent() const
Definition: z3++.h:2860
model get_model() const
Definition: z3++.h:2872
std::string dimacs(bool include_names=true) const
Definition: z3++.h:2890
unsigned num_exprs() const
Definition: z3++.h:2863
goal(context &c, Z3_goal s)
Definition: z3++.h:2844
goal & operator=(goal const &s)
Definition: z3++.h:2848
goal(context &c, bool models=true, bool unsat_cores=false, bool proofs=false)
Definition: z3++.h:2843
void add(expr_vector const &v)
Definition: z3++.h:2856
~goal()
Definition: z3++.h:2846
void reset()
Definition: z3++.h:2862
unsigned depth() const
Definition: z3++.h:2861
bool is_decided_sat() const
Definition: z3++.h:2864
expr as_expr() const
Definition: z3++.h:2877
expr operator[](int i) const
Definition: z3++.h:2858
expr eval(expr const &n, bool model_completion=false) const
Definition: z3++.h:2522
unsigned size() const
Definition: z3++.h:2536
~model()
Definition: z3++.h:2512
expr get_const_interp(func_decl c) const
Definition: z3++.h:2545
unsigned num_consts() const
Definition: z3++.h:2532
unsigned num_funcs() const
Definition: z3++.h:2533
friend std::ostream & operator<<(std::ostream &out, model const &m)
Definition: z3++.h:2580
model & operator=(model const &s)
Definition: z3++.h:2514
func_interp get_func_interp(func_decl f) const
Definition: z3++.h:2551
func_decl get_func_decl(unsigned i) const
Definition: z3++.h:2535
func_interp add_func_interp(func_decl &f, expr &else_val)
Definition: z3++.h:2565
func_decl operator[](int i) const
Definition: z3++.h:2537
model(model const &s)
Definition: z3++.h:2510
model(context &c)
Definition: z3++.h:2508
void add_const_interp(func_decl &f, expr &value)
Definition: z3++.h:2571
func_decl get_const_decl(unsigned i) const
Definition: z3++.h:2534
bool has_interp(func_decl f) const
Definition: z3++.h:2560
std::string to_string() const
Definition: z3++.h:2578
model(model &src, context &dst, translate)
Definition: z3++.h:2511
model(context &c, Z3_model m)
Definition: z3++.h:2509
context * m_ctx
Definition: z3++.h:426
context & ctx() const
Definition: z3++.h:429
Z3_error_code check_error() const
Definition: z3++.h:430
object(context &c)
Definition: z3++.h:428
friend void check_context(object const &a, object const &b)
Definition: z3++.h:433
handle(unsigned h)
Definition: z3++.h:3089
unsigned h() const
Definition: z3++.h:3090
std::string help() const
Definition: z3++.h:3182
handle add_soft(expr const &e, char const *weight)
Definition: z3++.h:3132
void add(expr const &e, expr const &t)
Definition: z3++.h:3119
expr lower(handle const &h)
Definition: z3++.h:3166
void pop()
Definition: z3++.h:3148
expr_vector objectives() const
Definition: z3++.h:3177
void add(expr_vector const &es)
Definition: z3++.h:3116
void add(expr const &e, char const *p)
Definition: z3++.h:3123
model get_model() const
Definition: z3++.h:3163
handle add(expr const &e, unsigned weight)
Definition: z3++.h:3136
check_result check()
Definition: z3++.h:3151
check_result check(expr_vector const &asms)
Definition: z3++.h:3152
stats statistics() const
Definition: z3++.h:3178
void add(expr const &e)
Definition: z3++.h:3112
friend std::ostream & operator<<(std::ostream &out, optimize const &s)
Definition: z3++.h:3184
void push()
Definition: z3++.h:3145
handle add_soft(expr const &e, unsigned weight)
Definition: z3++.h:3127
handle maximize(expr const &e)
Definition: z3++.h:3139
~optimize()
Definition: z3++.h:3110
optimize(optimize const &o)
Definition: z3++.h:3093
void from_file(char const *filename)
Definition: z3++.h:3180
expr_vector assertions() const
Definition: z3++.h:3176
void from_string(char const *constraints)
Definition: z3++.h:3181
expr upper(handle const &h)
Definition: z3++.h:3171
optimize(context &c, optimize &src)
Definition: z3++.h:3096
handle minimize(expr const &e)
Definition: z3++.h:3142
optimize & operator=(optimize const &o)
Definition: z3++.h:3103
optimize(context &c)
Definition: z3++.h:3092
void set(params const &p)
Definition: z3++.h:3165
expr_vector unsat_core() const
Definition: z3++.h:3164
param_descrs(param_descrs const &o)
Definition: z3++.h:459
param_descrs(context &c, Z3_param_descrs d)
Definition: z3++.h:458
Z3_param_kind kind(symbol const &s)
Definition: z3++.h:472
std::string documentation(symbol const &s)
Definition: z3++.h:473
symbol name(unsigned i)
Definition: z3++.h:471
static param_descrs simplify_param_descrs(context &c)
Definition: z3++.h:468
unsigned size()
Definition: z3++.h:470
param_descrs & operator=(param_descrs const &o)
Definition: z3++.h:460
std::string to_string() const
Definition: z3++.h:474
void set(char const *k, char const *s)
Definition: z3++.h:497
params(context &c)
Definition: z3++.h:482
params(params const &s)
Definition: z3++.h:483
~params()
Definition: z3++.h:484
void set(char const *k, bool b)
Definition: z3++.h:493
void set(char const *k, unsigned n)
Definition: z3++.h:494
void set(char const *k, symbol const &s)
Definition: z3++.h:496
params & operator=(params const &s)
Definition: z3++.h:486
friend std::ostream & operator<<(std::ostream &out, params const &p)
Definition: z3++.h:501
void set(char const *k, double n)
Definition: z3++.h:495
friend probe operator<(probe const &p1, probe const &p2)
Definition: z3++.h:3057
double operator()(goal const &g) const
Definition: z3++.h:3026
probe & operator=(probe const &s)
Definition: z3++.h:3018
friend probe operator==(probe const &p1, probe const &p2)
Definition: z3++.h:3067
friend probe operator<=(probe const &p1, probe const &p2)
Definition: z3++.h:3047
probe(context &c, Z3_probe s)
Definition: z3++.h:3014
probe(context &c, double val)
Definition: z3++.h:3013
probe(context &c, char const *name)
Definition: z3++.h:3012
friend probe operator&&(probe const &p1, probe const &p2)
Definition: z3++.h:3072
probe(probe const &s)
Definition: z3++.h:3015
~probe()
Definition: z3++.h:3016
friend probe operator!(probe const &p)
Definition: z3++.h:3078
double apply(goal const &g) const
Definition: z3++.h:3025
friend probe operator>=(probe const &p1, probe const &p2)
Definition: z3++.h:3052
friend probe operator>(probe const &p1, probe const &p2)
Definition: z3++.h:3062
friend probe operator||(probe const &p1, probe const &p2)
Definition: z3++.h:3075
context & operator()()
Definition: z3++.h:402
scoped_context(Z3_context c)
Definition: z3++.h:400
cube_iterator end()
Definition: z3++.h:2826
cube_generator(solver &s, expr_vector &vars)
Definition: z3++.h:2818
cube_iterator begin()
Definition: z3++.h:2825
cube_generator(solver &s)
Definition: z3++.h:2811
void set_cutoff(unsigned c) noexcept
Definition: z3++.h:2827
expr_vector const & operator*() const noexcept
Definition: z3++.h:2794
cube_iterator & operator++()
Definition: z3++.h:2782
cube_iterator operator++(int)
Definition: z3++.h:2792
expr_vector const * operator->() const
Definition: z3++.h:2793
bool operator!=(cube_iterator const &other) noexcept
Definition: z3++.h:2799
cube_iterator(solver &s, expr_vector &vars, unsigned &cutoff, bool end)
Definition: z3++.h:2770
bool operator==(cube_iterator const &other) noexcept
Definition: z3++.h:2796
void from_string(char const *s)
Definition: z3++.h:2668
expr proof() const
Definition: z3++.h:2715
~solver()
Definition: z3++.h:2635
cube_generator cubes(expr_vector &vars)
Definition: z3++.h:2831
solver(context &c, solver const &src, translate)
Definition: z3++.h:2633
expr_vector non_units() const
Definition: z3++.h:2702
solver(context &c, simple)
Definition: z3++.h:2630
solver(context &c, Z3_solver s)
Definition: z3++.h:2631
solver(context &c, char const *logic)
Definition: z3++.h:2632
void set(char const *k, bool v)
Definition: z3++.h:2645
void add(expr const &e, expr const &p)
Definition: z3++.h:2654
void add(expr const &e, char const *p)
Definition: z3++.h:2659
check_result consequences(expr_vector &assumptions, expr_vector &vars, expr_vector &conseq)
Definition: z3++.h:2693
void set(char const *k, char const *v)
Definition: z3++.h:2649
check_result check(unsigned n, expr *const assumptions)
Definition: z3++.h:2671
model get_model() const
Definition: z3++.h:2692
std::string dimacs(bool include_names=true) const
Definition: z3++.h:2738
check_result check()
Definition: z3++.h:2670
stats statistics() const
Definition: z3++.h:2699
expr_vector units() const
Definition: z3++.h:2703
expr_vector trail() const
Definition: z3++.h:2704
void add(expr const &e)
Definition: z3++.h:2653
solver & operator=(solver const &s)
Definition: z3++.h:2637
friend std::ostream & operator<<(std::ostream &out, solver const &s)
Definition: z3++.h:2834
void set(char const *k, double v)
Definition: z3++.h:2647
void pop(unsigned n=1)
Definition: z3++.h:2651
void push()
Definition: z3++.h:2650
std::string to_smt2(char const *status="unknown")
Definition: z3++.h:2718
solver(context &c)
Definition: z3++.h:2629
param_descrs get_param_descrs()
Definition: z3++.h:2740
void set(char const *k, unsigned v)
Definition: z3++.h:2646
void add(expr_vector const &v)
Definition: z3++.h:2662
expr_vector assertions() const
Definition: z3++.h:2701
void from_file(char const *file)
Definition: z3++.h:2667
expr_vector trail(array< unsigned > &levels) const
Definition: z3++.h:2705
void reset()
Definition: z3++.h:2652
std::string reason_unknown() const
Definition: z3++.h:2698
void set(params const &p)
Definition: z3++.h:2644
expr_vector cube(expr_vector &vars, unsigned cutoff)
Definition: z3++.h:2743
cube_generator cubes()
Definition: z3++.h:2830
expr_vector unsat_core() const
Definition: z3++.h:2700
solver(solver const &s)
Definition: z3++.h:2634
void set(char const *k, symbol const &v)
Definition: z3++.h:2648
check_result check(expr_vector const &assumptions)
Definition: z3++.h:2681
A Z3 sort (aka type). Every expression (i.e., formula or term) in Z3 has a sort.
Definition: z3++.h:611
sort(context &c, Z3_sort s)
Definition: z3++.h:614
Z3_sort_kind sort_kind() const
Return the internal sort kind.
Definition: z3++.h:626
unsigned bv_size() const
Return the size of this Bit-vector sort.
Definition: z3++.h:685
bool is_int() const
Return true if this sort is the Integer sort.
Definition: z3++.h:638
sort(context &c)
Definition: z3++.h:613
bool is_real() const
Return true if this sort is the Real sort.
Definition: z3++.h:642
sort(context &c, Z3_ast a)
Definition: z3++.h:615
symbol name() const
Return name of sort.
Definition: z3++.h:630
bool is_relation() const
Return true if this sort is a Relation sort.
Definition: z3++.h:662
unsigned fpa_ebits() const
Definition: z3++.h:687
sort array_range() const
Return the range of this Array sort.
Definition: z3++.h:701
bool is_bool() const
Return true if this sort is the Boolean sort.
Definition: z3++.h:634
bool is_arith() const
Return true if this sort is the Integer or Real sort.
Definition: z3++.h:646
bool is_bv() const
Return true if this sort is a Bit-vector sort.
Definition: z3++.h:650
sort array_domain() const
Return the domain of this Array sort.
Definition: z3++.h:695
bool is_finite_domain() const
Return true if this sort is a Finite domain sort.
Definition: z3++.h:674
bool is_datatype() const
Return true if this sort is a Datatype sort.
Definition: z3++.h:658
bool is_re() const
Return true if this sort is a regular expression sort.
Definition: z3++.h:670
unsigned id() const
retrieve unique identifier for func_decl.
Definition: z3++.h:621
friend std::ostream & operator<<(std::ostream &out, sort const &s)
Definition: z3++.h:703
bool is_array() const
Return true if this sort is a Array sort.
Definition: z3++.h:654
bool is_seq() const
Return true if this sort is a Sequence sort.
Definition: z3++.h:666
unsigned fpa_sbits() const
Definition: z3++.h:689
bool is_fpa() const
Return true if this sort is a Floating point sort.
Definition: z3++.h:678
unsigned size() const
Definition: z3++.h:2601
bool is_uint(unsigned i) const
Definition: z3++.h:2603
bool is_double(unsigned i) const
Definition: z3++.h:2604
~stats()
Definition: z3++.h:2592
stats(stats const &s)
Definition: z3++.h:2591
double double_value(unsigned i) const
Definition: z3++.h:2606
unsigned uint_value(unsigned i) const
Definition: z3++.h:2605
stats & operator=(stats const &s)
Definition: z3++.h:2594
stats(context &c, Z3_stats e)
Definition: z3++.h:2590
std::string key(unsigned i) const
Definition: z3++.h:2602
stats(context &c)
Definition: z3++.h:2589
friend std::ostream & operator<<(std::ostream &out, stats const &s)
Definition: z3++.h:2609
friend std::ostream & operator<<(std::ostream &out, symbol const &s)
Definition: z3++.h:446
Z3_symbol_kind kind() const
Definition: z3++.h:440
symbol(context &c, Z3_symbol s)
Definition: z3++.h:438
int to_int() const
Definition: z3++.h:442
std::string str() const
Definition: z3++.h:441
friend tactic par_or(unsigned n, tactic const *tactics)
Definition: z3++.h:2989
friend tactic par_and_then(tactic const &t1, tactic const &t2)
Definition: z3++.h:2998
std::string help() const
Definition: z3++.h:2948
solver mk_solver() const
Definition: z3++.h:2938
tactic & operator=(tactic const &s)
Definition: z3++.h:2931
tactic(context &c, char const *name)
Definition: z3++.h:2926
tactic(context &c, Z3_tactic s)
Definition: z3++.h:2927
friend tactic repeat(tactic const &t, unsigned max)
Definition: z3++.h:2973
~tactic()
Definition: z3++.h:2929
friend tactic with(tactic const &t, params const &p)
Definition: z3++.h:2979
apply_result apply(goal const &g) const
Definition: z3++.h:2939
friend tactic operator&(tactic const &t1, tactic const &t2)
Definition: z3++.h:2959
friend tactic try_for(tactic const &t, unsigned ms)
Definition: z3++.h:2984
param_descrs get_param_descrs()
Definition: z3++.h:2956
apply_result operator()(goal const &g) const
Definition: z3++.h:2945
tactic(tactic const &s)
Definition: z3++.h:2928
friend tactic operator|(tactic const &t1, tactic const &t2)
Definition: z3++.h:2966
void register_created(created_eh_t &c)
Definition: z3++.h:4037
virtual void eq(unsigned, unsigned)
Definition: z3++.h:4052
virtual user_propagator_base * fresh(Z3_context ctx)=0
user_propagators created using fresh() are created during search and their lifetimes are restricted t...
void register_eq(eq_eh_t &f)
Definition: z3++.h:4001
virtual void fixed(unsigned, expr const &)
Definition: z3++.h:4050
virtual void created(unsigned, expr const &)
Definition: z3++.h:4056
virtual void push()=0
void register_final(final_eh_t &f)
register a callback on final-check. During the final check stage, all propagations have been processe...
Definition: z3++.h:4023
virtual void pop(unsigned num_scopes)=0
void propagate(unsigned num_fixed, unsigned const *fixed, unsigned num_eqs, unsigned const *lhs, unsigned const *rhs, expr const &conseq)
Definition: z3++.h:4094
unsigned add(expr const &e)
tracks e by a unique identifier that is returned by the call.
Definition: z3++.h:4072
user_propagator_base(solver *s)
Definition: z3++.h:3962
virtual ~user_propagator_base()=default
void conflict(unsigned num_fixed, unsigned const *fixed)
Definition: z3++.h:4081
user_propagator_base(Z3_context c)
Definition: z3++.h:3960
void propagate(unsigned num_fixed, unsigned const *fixed, expr const &conseq)
Definition: z3++.h:4088
void register_fixed(fixed_eh_t &f)
register callbacks. Callbacks can only be registered with user_propagators that were created using a ...
Definition: z3++.h:3987
Z3_ast Z3_API Z3_mk_exists_const(Z3_context c, unsigned weight, unsigned num_bound, Z3_app const bound[], unsigned num_patterns, Z3_pattern const patterns[], Z3_ast body)
Similar to Z3_mk_forall_const.
Z3_ast Z3_API Z3_mk_pbeq(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
Z3_ast_vector Z3_API Z3_optimize_get_assertions(Z3_context c, Z3_optimize o)
Return the set of asserted formulas on the optimization context.
Z3_ast_kind
The different kinds of Z3 AST (abstract syntax trees). That is, terms, formulas and types.
Definition: z3_api.h:181
Z3_ast Z3_API Z3_model_get_const_interp(Z3_context c, Z3_model m, Z3_func_decl a)
Return the interpretation (i.e., assignment) of constant a in the model m. Return NULL,...
Z3_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
Z3_ast Z3_API Z3_mk_fpa_is_infinite(Z3_context c, Z3_ast t)
Predicate indicating whether t is a floating-point number representing +oo or -oo.
Z3_probe Z3_API Z3_probe_lt(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is less than the value returned...
Z3_sort Z3_API Z3_mk_array_sort_n(Z3_context c, unsigned n, Z3_sort const *domain, Z3_sort range)
Create an array type with N arguments.
Z3_ast Z3_API Z3_mk_bvxnor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise xnor.
Z3_string Z3_API Z3_get_error_msg(Z3_context c, Z3_error_code err)
Return a string describing the given error code.
bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s)
Check if s is a sequence sort.
Z3_ast Z3_API Z3_mk_bvnor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nor.
Z3_ast Z3_API Z3_get_denominator(Z3_context c, Z3_ast a)
Return the denominator (as a numeral AST) of a numeral AST of sort Real.
Z3_probe Z3_API Z3_probe_not(Z3_context x, Z3_probe p)
Return a probe that evaluates to "true" when p does not evaluate to true.
Z3_decl_kind Z3_API Z3_get_decl_kind(Z3_context c, Z3_func_decl d)
Return declaration kind corresponding to declaration.
void Z3_API Z3_solver_assert_and_track(Z3_context c, Z3_solver s, Z3_ast a, Z3_ast p)
Assert a constraint a into the solver, and track it (in the unsat) core using the Boolean constant p.
Z3_ast Z3_API Z3_func_interp_get_else(Z3_context c, Z3_func_interp f)
Return the 'else' value of the given function interpretation.
Z3_ast Z3_API Z3_mk_char_to_bv(Z3_context c, Z3_ast ch)
Create a bit-vector (code point) from character.
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.
void Z3_API Z3_fixedpoint_inc_ref(Z3_context c, Z3_fixedpoint d)
Increment the reference counter of the given fixedpoint context.
Z3_tactic Z3_API Z3_tactic_using_params(Z3_context c, Z3_tactic t, Z3_params p)
Return a tactic that applies t using the given set of parameters.
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
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_probe Z3_API Z3_probe_eq(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is equal to the value returned ...
Z3_ast_vector Z3_API Z3_optimize_get_unsat_core(Z3_context c, Z3_optimize o)
Retrieve the unsat core for the last Z3_optimize_check The unsat core is a subset of the assumptions ...
Z3_sort Z3_API Z3_mk_char_sort(Z3_context c)
Create a sort for unicode characters.
Z3_ast Z3_API Z3_mk_unsigned_int(Z3_context c, unsigned v, Z3_sort ty)
Create a numeral of a int, bit-vector, or finite-domain sort.
Z3_ast Z3_API Z3_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
Z3_ast Z3_API Z3_mk_bvsle(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than or equal to.
Z3_func_decl Z3_API Z3_get_app_decl(Z3_context c, Z3_app a)
Return the declaration of a constant or function application.
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
Z3_ast Z3_API Z3_substitute(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const from[], Z3_ast const to[])
Substitute every occurrence of from[i] in a with to[i], for i smaller than num_exprs....
Z3_ast Z3_API Z3_mk_mul(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] * ... * args[num_args-1].
Z3_goal_prec
A Goal is essentially a set of formulas. Z3 provide APIs for building strategies/tactics for solving ...
Definition: z3_api.h:1425
Z3_ast Z3_API Z3_mk_fpa_to_fp_bv(Z3_context c, Z3_ast bv, Z3_sort s)
Conversion of a single IEEE 754-2008 bit-vector into a floating-point number.
Z3_ast Z3_API Z3_mk_seq_replace(Z3_context c, Z3_ast s, Z3_ast src, Z3_ast dst)
Replace the first occurrence of src with dst in s.
Z3_string Z3_API Z3_param_descrs_to_string(Z3_context c, Z3_param_descrs p)
Convert a parameter description set into a string. This function is mainly used for printing the cont...
Z3_ast Z3_API Z3_mk_zero_ext(Z3_context c, unsigned i, Z3_ast t1)
Extend the given bit-vector with zeros to the (unsigned) equivalent bit-vector of size m+i,...
void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p)
Set the given solver using the given parameters.
Z3_ast Z3_API Z3_mk_set_intersect(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the intersection of a list of sets.
Z3_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_ast Z3_API Z3_mk_fpa_is_subnormal(Z3_context c, Z3_ast t)
Predicate indicating whether t is a subnormal floating-point number.
unsigned Z3_API Z3_get_decl_num_parameters(Z3_context c, Z3_func_decl d)
Return the number of parameters associated with a declaration.
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
Z3_ast Z3_API Z3_mk_int(Z3_context c, int v, Z3_sort ty)
Create a numeral of an int, bit-vector, or finite-domain sort.
Z3_ast Z3_API Z3_mk_fpa_to_ieee_bv(Z3_context c, Z3_ast t)
Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format.
Z3_lbool Z3_API Z3_solver_get_consequences(Z3_context c, Z3_solver s, Z3_ast_vector assumptions, Z3_ast_vector variables, Z3_ast_vector consequences)
retrieve consequences from solver that determine values of the supplied function symbols.
Z3_ast_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....
void Z3_API Z3_get_string_contents(Z3_context c, Z3_ast s, unsigned length, unsigned contents[])
Retrieve the unescaped string constant stored in s.
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
Z3_param_kind Z3_API Z3_param_descrs_get_kind(Z3_context c, Z3_param_descrs p, Z3_symbol n)
Return the kind associated with the given parameter name n.
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.
unsigned Z3_API Z3_solver_propagate_register(Z3_context c, Z3_solver s, Z3_ast e)
register an expression to propagate on with the solver. Only expressions of type Bool and type Bit-Ve...
bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t *i)
Similar to Z3_get_numeral_string, but only succeeds if the value can fit in a machine int64_t int....
void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body)
Define the body of a recursive function.
Z3_param_descrs Z3_API Z3_solver_get_param_descrs(Z3_context c, Z3_solver s)
Return the parameter description set for the given solver object.
Z3_ast Z3_API Z3_mk_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.
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
Z3_ast Z3_API Z3_optimize_get_lower(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve lower bound value or approximation for the i'th optimization objective.
Z3_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.
Z3_model Z3_API Z3_optimize_get_model(Z3_context c, Z3_optimize o)
Retrieve the model for the last Z3_optimize_check.
unsigned Z3_API Z3_solver_propagate_register_cb(Z3_context c, Z3_solver_callback cb, Z3_ast e)
register an expression to propagate on with the solver. Only expressions of type Bool and type Bit-Ve...
void Z3_API Z3_apply_result_inc_ref(Z3_context c, Z3_apply_result r)
Increment the reference counter of the given Z3_apply_result object.
Z3_func_interp Z3_API Z3_add_func_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast default_value)
Create a fresh func_interp object, add it to a model for a specified function. It has reference count...
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_decl_kind
The different kinds of interpreted function kinds.
Definition: z3_api.h:1001
unsigned Z3_API Z3_get_arity(Z3_context c, Z3_func_decl d)
Alias for Z3_get_domain_size.
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.
Z3_ast Z3_API Z3_mk_bvxor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise exclusive-or.
Z3_string Z3_API Z3_stats_to_string(Z3_context c, Z3_stats s)
Convert a statistics into a string.
Z3_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.
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
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....
Z3_ast Z3_API Z3_mk_le(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than or equal to.
bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g)
Return true if the given goal contains the formula false.
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c, unsigned num_bound, Z3_app const bound[], Z3_ast body)
Create a lambda expression using a list of constants that form the set of bound variables.
Z3_tactic Z3_API Z3_tactic_par_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal and then t2 to every subgoal produced by t1....
void Z3_API Z3_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.
void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s)
Decrement the reference counter of the given solver.
Z3_ast Z3_API Z3_mk_bvslt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than.
Z3_func_decl Z3_API Z3_model_get_func_decl(Z3_context c, Z3_model m, unsigned i)
Return the declaration of the i-th function in the given model.
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
unsigned Z3_API Z3_func_entry_get_num_args(Z3_context c, Z3_func_entry e)
Return the number of arguments in a Z3_func_entry object.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
Z3_ast Z3_API Z3_get_numerator(Z3_context c, Z3_ast a)
Return the numerator (as a numeral AST) of a numeral AST of sort Real.
Z3_ast Z3_API Z3_mk_unary_minus(Z3_context c, Z3_ast arg)
Create an AST node representing - arg.
Z3_ast Z3_API Z3_mk_fpa_rna(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
Z3_probe Z3_API Z3_probe_ge(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is greater than or equal to the...
Z3_ast Z3_API Z3_mk_and(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] and ... and args[num_args-1].
void Z3_API Z3_interrupt(Z3_context c)
Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers,...
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
Z3_ast Z3_API Z3_mk_fpa_sub(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point subtraction.
void Z3_API Z3_goal_assert(Z3_context c, Z3_goal g, Z3_ast a)
Add a new formula a to the given goal. The formula is split according to the following procedure that...
Z3_symbol Z3_API Z3_param_descrs_get_name(Z3_context c, Z3_param_descrs p, unsigned i)
Return the name of the parameter at given index i.
Z3_ast Z3_API Z3_func_entry_get_value(Z3_context c, Z3_func_entry e)
Return the value of this point.
bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a)
Determine if ast is an existential quantifier.
Z3_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_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
void Z3_API Z3_optimize_pop(Z3_context c, Z3_optimize d)
Backtrack one level.
Z3_ast Z3_API Z3_mk_fpa_is_normal(Z3_context c, Z3_ast t)
Predicate indicating whether t is a normal floating-point number.
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
Z3_lbool Z3_API Z3_solver_check(Z3_context c, Z3_solver s)
Check whether the assertions in a given solver are consistent or not.
Z3_ast Z3_API Z3_mk_fpa_to_ubv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.
Z3_ast Z3_API Z3_mk_rotate_right(Z3_context c, unsigned i, Z3_ast t1)
Rotate bits of t1 to the right i times.
Z3_ast Z3_API Z3_mk_bvmul(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement multiplication.
Z3_ast Z3_API Z3_mk_seq_at(Z3_context c, Z3_ast s, Z3_ast index)
Retrieve from s the unit sequence positioned at position index. The sequence is empty if the index is...
Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m)
Convert a model of the formulas of a goal to a model of an original goal. The model may be null,...
Z3_ast Z3_API Z3_mk_bvsgt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than.
Z3_string Z3_API Z3_ast_to_string(Z3_context c, Z3_ast a)
Convert the given AST node into a string.
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
Z3_ast_vector Z3_API Z3_fixedpoint_get_assertions(Z3_context c, Z3_fixedpoint f)
Retrieve set of background assertions from fixedpoint context.
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....
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_ast_vector Z3_API Z3_solver_get_assertions(Z3_context c, Z3_solver s)
Return the set of asserted formulas on the solver.
Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t)
Create a new solver that is implemented using the given tactic. The solver supports the commands Z3_s...
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
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.
bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx)
Return true if the given statistical data is a double.
Z3_ast Z3_API Z3_mk_fpa_rtn(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardNegative rounding mode.
unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m)
Return the number of constants assigned by the given model.
Z3_ast Z3_API Z3_get_algebraic_number_lower(Z3_context c, Z3_ast a, unsigned precision)
Return a lower bound for the given real algebraic number. The interval isolating the number is smalle...
Z3_ast Z3_API Z3_mk_extract(Z3_context c, unsigned high, unsigned low, Z3_ast t1)
Extract the bits high down to low from a bit-vector of size m to yield a new bit-vector of size n,...
Z3_ast Z3_API Z3_mk_mod(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 mod arg2.
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
Z3_ast Z3_API Z3_mk_ge(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than or equal to.
Z3_ast Z3_API Z3_mk_bvadd_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed addition of t1 and t2 does not underflow.
Z3_ast Z3_API Z3_mk_fpa_rtp(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardPositive rounding mode.
void Z3_API Z3_update_param_value(Z3_context c, Z3_string param_id, Z3_string param_value)
Set a value of a context parameter.
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise addition of t1 and t2 does not overflow.
void Z3_API Z3_set_ast_print_mode(Z3_context c, Z3_ast_print_mode mode)
Select mode for the format used for pretty-printing AST nodes.
unsigned Z3_API Z3_fpa_get_sbits(Z3_context c, Z3_sort s)
Retrieves the number of bits reserved for the significand in a FloatingPoint sort.
Z3_ast Z3_API Z3_mk_forall_const(Z3_context c, unsigned weight, unsigned num_bound, Z3_app const bound[], unsigned num_patterns, Z3_pattern const patterns[], Z3_ast body)
Create a universal quantifier using a list of constants that will form the set of bound variables.
Z3_param_kind
The different kinds of parameters that can be associated with parameter sets. (see Z3_mk_params).
Definition: z3_api.h:1333
const char * Z3_string
Z3 string type. It is just an alias for const char *.
Definition: z3_api.h:84
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_sort Z3_API Z3_mk_tuple_sort(Z3_context c, Z3_symbol mk_tuple_name, unsigned num_fields, Z3_symbol const field_names[], Z3_sort const field_sorts[], Z3_func_decl *mk_tuple_decl, Z3_func_decl proj_decl[])
Create a tuple type.
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.
void Z3_API Z3_func_entry_inc_ref(Z3_context c, Z3_func_entry e)
Increment the reference counter of the given Z3_func_entry object.
Z3_ast Z3_API Z3_mk_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.
Z3_sort_kind
The different kinds of Z3 types (See Z3_get_sort_kind).
Definition: z3_api.h:150
void Z3_API Z3_solver_push(Z3_context c, Z3_solver s)
Create a backtracking point.
Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise subtraction of t1 and t2 does not underflow.
Z3_ast Z3_API Z3_mk_fpa_max(Z3_context c, Z3_ast t1, Z3_ast t2)
Maximum of floating-point numbers.
void Z3_API Z3_optimize_assert_and_track(Z3_context c, Z3_optimize o, Z3_ast a, Z3_ast t)
Assert tracked hard constraint to the optimization context.
unsigned Z3_API Z3_optimize_assert_soft(Z3_context c, Z3_optimize o, Z3_ast a, Z3_string weight, Z3_symbol id)
Assert soft constraint to the optimization context.
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.
Z3_string Z3_API Z3_ast_vector_to_string(Z3_context c, Z3_ast_vector v)
Convert AST vector into a string.
Z3_ast_vector Z3_API Z3_solver_get_trail(Z3_context c, Z3_solver s)
Return the trail modulo model conversion, in order of decision level The decision level can be retrie...
Z3_ast Z3_API Z3_mk_bvshl(Z3_context c, Z3_ast t1, Z3_ast t2)
Shift left.
Z3_func_decl Z3_API Z3_mk_tree_order(Z3_context c, Z3_sort a, unsigned id)
create a tree ordering relation over signature a identified using index id.
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
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.
unsigned Z3_API Z3_goal_num_exprs(Z3_context c, Z3_goal g)
Return the number of formulas, subformulas and terms in the given goal.
Z3_solver Z3_API Z3_mk_solver_for_logic(Z3_context c, Z3_symbol logic)
Create a new solver customized for the given logic. It behaves like Z3_mk_solver if the logic is unkn...
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, bool v)
Add a Boolean parameter k with value v to the parameter set p.
unsigned Z3_API Z3_apply_result_get_num_subgoals(Z3_context c, Z3_apply_result r)
Return the number of subgoals in the Z3_apply_result object returned by Z3_tactic_apply.
Z3_ast Z3_API Z3_mk_ite(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_ast t3)
Create an AST node representing an if-then-else: ite(t1, t2, t3).
Z3_ast Z3_API Z3_mk_select(Z3_context c, Z3_ast a, Z3_ast i)
Array read. The argument a is the array and i is the index of the array that gets read.
Z3_ast Z3_API Z3_mk_sign_ext(Z3_context c, unsigned i, Z3_ast t1)
Sign-extend of the given bit-vector to the (signed) equivalent bit-vector of size m+i,...
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
Z3_ast_vector Z3_API Z3_solver_cube(Z3_context c, Z3_solver s, Z3_ast_vector vars, unsigned backtrack_level)
extract a next cube for a solver. The last cube is the constant true or false. The number of (non-con...
Z3_ast Z3_API Z3_mk_u32string(Z3_context c, unsigned len, unsigned const chars[])
Create a string constant out of the string that is passed in It takes the length of the string as wel...
void Z3_API Z3_fixedpoint_add_fact(Z3_context c, Z3_fixedpoint d, Z3_func_decl r, unsigned num_args, unsigned args[])
Add a Database fact.
unsigned Z3_API Z3_goal_size(Z3_context c, Z3_goal g)
Return the number of formulas in the given goal.
Z3_func_decl Z3_API Z3_solver_propagate_declare(Z3_context c, Z3_symbol name, unsigned n, Z3_sort *domain, Z3_sort range)
void Z3_API Z3_stats_inc_ref(Z3_context c, Z3_stats s)
Increment the reference counter of the given statistics object.
Z3_ast Z3_API Z3_mk_select_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs)
n-ary Array read. The argument a is the array and idxs are the indices of the array that gets read.
Z3_ast_vector Z3_API Z3_algebraic_get_poly(Z3_context c, Z3_ast a)
Return the coefficients of the defining polynomial.
Z3_ast Z3_API Z3_mk_div(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 div arg2.
Z3_ast Z3_API Z3_mk_pbge(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
Z3_sort Z3_API Z3_mk_re_sort(Z3_context c, Z3_sort seq)
Create a regular expression sort out of a sequence sort.
Z3_ast Z3_API Z3_mk_pble(Z3_context c, unsigned num_args, Z3_ast const args[], int const coeffs[], int k)
Pseudo-Boolean relations.
void Z3_API Z3_optimize_inc_ref(Z3_context c, Z3_optimize d)
Increment the reference counter of the given optimize context.
void Z3_API Z3_model_dec_ref(Z3_context c, Z3_model m)
Decrement the reference counter of the given model.
Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative)
Create a floating-point infinity of sort s.
void Z3_API Z3_func_interp_inc_ref(Z3_context c, Z3_func_interp f)
Increment the reference counter of the given Z3_func_interp object.
Z3_func_decl Z3_API Z3_mk_piecewise_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a piecewise linear ordering relation over signature a and index id.
void Z3_API Z3_params_set_double(Z3_context c, Z3_params p, Z3_symbol k, double v)
Add a double parameter k with value v to the parameter set p.
Z3_string Z3_API Z3_param_descrs_get_documentation(Z3_context c, Z3_param_descrs p, Z3_symbol s)
Retrieve documentation string corresponding to parameter name s.
Z3_solver Z3_API Z3_mk_solver(Z3_context c)
Create a new solver. This solver is a "combined solver" (see combined_solver module) that internally ...
Z3_model Z3_API Z3_solver_get_model(Z3_context c, Z3_solver s)
Retrieve the model for the last Z3_solver_check or Z3_solver_check_assumptions.
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
void Z3_API Z3_goal_inc_ref(Z3_context c, Z3_goal g)
Increment the reference counter of the given goal.
Z3_tactic Z3_API Z3_tactic_par_or(Z3_context c, unsigned num, Z3_tactic const ts[])
Return a tactic that applies the given tactics in parallel.
Z3_ast Z3_API Z3_mk_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
Z3_ast Z3_API Z3_optimize_get_upper(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve upper bound value or approximation for the i'th optimization objective.
void Z3_API Z3_params_set_uint(Z3_context c, Z3_params p, Z3_symbol k, unsigned v)
Add a unsigned parameter k with value v to the parameter set p.
Z3_lbool Z3_API Z3_solver_check_assumptions(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[])
Check whether the assertions in the given solver and optional assumptions are consistent or not.
Z3_ast Z3_API Z3_mk_fpa_gt(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point greater than.
Z3_ast Z3_API Z3_mk_bvashr(Z3_context c, Z3_ast t1, Z3_ast t2)
Arithmetic shift right.
Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast t1, bool is_signed)
Create an integer from the bit-vector argument t1. If is_signed is false, then the bit-vector t1 is t...
Z3_ast Z3_API Z3_mk_sbv_to_str(Z3_context c, Z3_ast s)
Signed bit-vector to string conversion.
Z3_ast Z3_API Z3_mk_fpa_is_zero(Z3_context c, Z3_ast t)
Predicate indicating whether t is a floating-point number with zero value, i.e., +zero or -zero.
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise multiplication of t1 and t2 does not overflow.
Z3_ast Z3_API Z3_mk_re_union(Z3_context c, unsigned n, Z3_ast const args[])
Create the union of the regular languages.
void Z3_API Z3_optimize_set_params(Z3_context c, Z3_optimize o, Z3_params p)
Set parameters on optimization context.
Z3_ast Z3_API Z3_mk_bvor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise or.
int Z3_API Z3_get_decl_int_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the integer value associated with an integer parameter.
void Z3_API Z3_ast_vector_resize(Z3_context c, Z3_ast_vector v, unsigned n)
Resize the AST vector v.
Z3_lbool
Lifted Boolean type: false, undefined, true.
Definition: z3_api.h:102
Z3_ast Z3_API Z3_mk_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
Z3_probe Z3_API Z3_mk_probe(Z3_context c, Z3_string name)
Return a probe associated with the given name. The complete list of probes may be obtained using the ...
Z3_tactic Z3_API Z3_tactic_when(Z3_context c, Z3_probe p, Z3_tactic t)
Return a tactic that applies t to a given goal is the probe p evaluates to true. If p evaluates to fa...
Z3_ast Z3_API Z3_mk_seq_suffix(Z3_context c, Z3_ast suffix, Z3_ast s)
Check if suffix is a suffix of s.
Z3_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...
bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a)
Determine if ast is a lambda expression.
Z3_solver Z3_API Z3_solver_translate(Z3_context source, Z3_solver s, Z3_context target)
Copy a solver s from the context source to the context target.
void Z3_API Z3_optimize_push(Z3_context c, Z3_optimize d)
Create a backtracking point.
unsigned Z3_API Z3_stats_get_uint_value(Z3_context c, Z3_stats s, unsigned idx)
Return the unsigned value of the given statistical data.
void Z3_API Z3_probe_inc_ref(Z3_context c, Z3_probe p)
Increment the reference counter of the given probe.
Z3_sort Z3_API Z3_get_array_sort_domain(Z3_context c, Z3_sort t)
Return the domain of the given array sort. In the case of a multi-dimensional array,...
Z3_ast Z3_API Z3_mk_fpa_eq(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point equality.
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...
bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t *u)
Similar to Z3_get_numeral_string, but only succeeds if the value can fit in a machine uint64_t int....
void Z3_API Z3_add_const_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast a)
Add a constant interpretation.
Z3_string Z3_API Z3_sort_to_string(Z3_context c, Z3_sort s)
Z3_ast Z3_API Z3_mk_bvadd(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement addition.
unsigned Z3_API Z3_algebraic_get_i(Z3_context c, Z3_ast a)
Return which root of the polynomial the algebraic number represents.
void Z3_API Z3_params_dec_ref(Z3_context c, Z3_params p)
Decrement the reference counter of the given parameter set.
void Z3_API Z3_fixedpoint_dec_ref(Z3_context c, Z3_fixedpoint d)
Decrement the reference counter of the given fixedpoint context.
Z3_ast Z3_API Z3_get_app_arg(Z3_context c, Z3_app a, unsigned i)
Return the i-th argument of the given application.
Z3_string Z3_API Z3_model_to_string(Z3_context c, Z3_model m)
Convert the given model into a string.
unsigned Z3_API Z3_get_string_length(Z3_context c, Z3_ast s)
Retrieve the length of the unescaped string constant stored in s.
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.
void Z3_API Z3_solver_propagate_final(Z3_context c, Z3_solver s, Z3_final_eh final_eh)
register a callback on final check. This provides freedom to the propagator to delay actions or imple...
unsigned Z3_API Z3_param_descrs_size(Z3_context c, Z3_param_descrs p)
Return the number of parameters in the given parameter description set.
Z3_ast_vector Z3_API Z3_parse_smtlib2_string(Z3_context c, Z3_string str, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Parse the given string using the SMT-LIB2 parser.
Z3_ast Z3_API Z3_mk_fpa_geq(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point greater than or equal.
Z3_string Z3_API Z3_goal_to_dimacs_string(Z3_context c, Z3_goal g, bool include_names)
Convert a goal into a DIMACS formatted string. The goal must be in CNF. You can convert a goal to CNF...
Z3_ast Z3_API Z3_mk_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than.
double Z3_API Z3_stats_get_double_value(Z3_context c, Z3_stats s, unsigned idx)
Return the double value of the given statistical data.
Z3_ast Z3_API Z3_mk_fpa_numeral_float(Z3_context c, float v, Z3_sort ty)
Create a numeral of FloatingPoint sort from a float.
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
Z3_lbool Z3_API Z3_fixedpoint_query(Z3_context c, Z3_fixedpoint d, Z3_ast query)
Pose a query against the asserted rules.
unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g)
Return the depth of the given goal. It tracks how many transformations were applied to it.
Z3_ast Z3_API Z3_mk_fpa_rtz(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardZero rounding mode.
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.
Z3_lbool Z3_API Z3_get_bool_value(Z3_context c, Z3_ast a)
Return Z3_L_TRUE if a is true, Z3_L_FALSE if it is false, and Z3_L_UNDEF otherwise.
Z3_ast Z3_API Z3_mk_bvnot(Z3_context c, Z3_ast t1)
Bitwise negation.
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
Z3_ast_vector Z3_API Z3_solver_get_non_units(Z3_context c, Z3_solver s)
Return the set of non units in the solver state.
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement subtraction.
Z3_ast_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...
Z3_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of first occurrence of substr in s starting from offset offset. If s does not contain su...
Z3_ast Z3_API Z3_get_algebraic_number_upper(Z3_context c, Z3_ast a, unsigned precision)
Return a upper bound for the given real algebraic number. The interval isolating the number is smalle...
Z3_ast Z3_API Z3_mk_power(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 ^ arg2.
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, Z3_symbol name, unsigned n, Z3_symbol const enum_names[], Z3_func_decl enum_consts[], Z3_func_decl enum_testers[])
Create a enumeration sort.
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.
unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t)
Return the size of the given bit-vector sort.
Z3_ast_vector Z3_API Z3_fixedpoint_get_rules(Z3_context c, Z3_fixedpoint f)
Retrieve set of rules from fixedpoint context.
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
void Z3_API Z3_ast_vector_dec_ref(Z3_context c, Z3_ast_vector v)
Decrement the reference counter of the given AST vector.
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p)
Return a tactic that fails if the probe p evaluates to false.
void Z3_API Z3_goal_reset(Z3_context c, Z3_goal g)
Erase all formulas from the given goal.
void Z3_API Z3_func_interp_dec_ref(Z3_context c, Z3_func_interp f)
Decrement the reference counter of the given Z3_func_interp object.
void Z3_API Z3_probe_dec_ref(Z3_context c, Z3_probe p)
Decrement the reference counter of the given probe.
void Z3_API Z3_params_inc_ref(Z3_context c, Z3_params p)
Increment the reference counter of the given parameter set.
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.
Z3_ast Z3_API Z3_mk_distinct(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing distinct(args[0], ..., args[num_args-1]).
Z3_ast Z3_API Z3_mk_seq_prefix(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if prefix is a prefix of s.
Z3_config Z3_API Z3_mk_config(void)
Create a configuration object for the Z3 context object.
void Z3_API Z3_set_param_value(Z3_config c, Z3_string param_id, Z3_string param_value)
Set a configuration parameter.
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
Z3_ast Z3_API Z3_mk_fpa_rem(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point remainder.
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
Z3_probe Z3_API Z3_probe_or(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when p1 or p2 evaluates to true.
Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c)
Create a new fixedpoint context.
Z3_string Z3_API Z3_params_to_string(Z3_context c, Z3_params p)
Convert a parameter set into a string. This function is mainly used for printing the contents of a pa...
void Z3_API Z3_solver_propagate_init(Z3_context c, Z3_solver s, void *user_context, Z3_push_eh push_eh, Z3_pop_eh pop_eh, Z3_fresh_eh fresh_eh)
register a user-properator with the solver.
Z3_func_decl Z3_API Z3_model_get_const_decl(Z3_context c, Z3_model m, unsigned i)
Return the i-th constant in the given model.
void Z3_API Z3_tactic_dec_ref(Z3_context c, Z3_tactic g)
Decrement the reference counter of the given tactic.
Z3_ast Z3_API Z3_mk_bvnand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nand.
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
Z3_sort Z3_API Z3_get_range(Z3_context c, Z3_func_decl d)
Return the range of the given declaration.
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.
void Z3_API Z3_optimize_assert(Z3_context c, Z3_optimize o, Z3_ast a)
Assert hard constraint to the optimization context.
Z3_string Z3_API Z3_benchmark_to_smtlib_string(Z3_context c, Z3_string name, Z3_string logic, Z3_string status, Z3_string attributes, unsigned num_assumptions, Z3_ast const assumptions[], Z3_ast formula)
Convert the given benchmark into SMT-LIB formatted string.
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, bool const *bits)
create a bit-vector numeral from a vector of Booleans.
void Z3_API Z3_func_entry_dec_ref(Z3_context c, Z3_func_entry e)
Decrement the reference counter of the given Z3_func_entry object.
unsigned Z3_API Z3_stats_size(Z3_context c, Z3_stats s)
Return the number of statistical data in s.
Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o)
Print the current context as a string.
Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a)
Return body of quantifier.
void Z3_API Z3_param_descrs_dec_ref(Z3_context c, Z3_param_descrs p)
Decrement the reference counter of the given parameter description set.
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
Z3_ast Z3_API Z3_mk_fpa_min(Z3_context c, Z3_ast t1, Z3_ast t2)
Minimum of floating-point numbers.
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
Z3_symbol Z3_API Z3_get_decl_name(Z3_context c, Z3_func_decl d)
Return the constant declaration name as a symbol.
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector.
Z3_ast Z3_API Z3_mk_fpa_round_to_integral(Z3_context c, Z3_ast rm, Z3_ast t)
Floating-point roundToIntegral. Rounds a floating-point number to the closest integer,...
Z3_string Z3_API Z3_stats_get_key(Z3_context c, Z3_stats s, unsigned idx)
Return the key (a string) for a particular statistical data.
Z3_ast Z3_API Z3_mk_re_diff(Z3_context c, Z3_ast re1, Z3_ast re2)
Create the difference of regular expressions.
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_ast Z3_API Z3_mk_int64(Z3_context c, int64_t v, Z3_sort ty)
Create a numeral of a int, bit-vector, or finite-domain sort.
Z3_symbol_kind
The different kinds of symbol. In Z3, a symbol can be represented using integers and strings (See Z3_...
Definition: z3_api.h:116
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a string.
Z3_ast Z3_API Z3_mk_fpa_add(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point addition.
Z3_ast Z3_API Z3_mk_bvand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise and.
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g)
Return true if the goal contains false, and it is precise or the product of an over approximation.
Z3_ast Z3_API Z3_mk_add(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] + ... + args[num_args-1].
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.
Z3_ast_vector Z3_API Z3_parse_smtlib2_file(Z3_context c, Z3_string file_name, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Similar to Z3_parse_smtlib2_string, but reads the benchmark from a file.
Z3_ast Z3_API Z3_mk_bvsmod(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows divisor).
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context dst)
translate model from context c to context dst.
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.
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...
Z3_ast Z3_API Z3_fixedpoint_get_cover_delta(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred)
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort.
Z3_ast Z3_API Z3_mk_int2bv(Z3_context c, unsigned n, Z3_ast t1)
Create an n bit bit-vector from the integer argument t1.
void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a)
Assert a constraint into the solver.
Z3_tactic Z3_API Z3_mk_tactic(Z3_context c, Z3_string name)
Return a tactic associated with the given name. The complete list of tactics may be obtained using th...
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
unsigned Z3_API Z3_ast_vector_size(Z3_context c, Z3_ast_vector v)
Return the size of the given AST vector.
Z3_optimize Z3_API Z3_mk_optimize(Z3_context c)
Create a new optimize context.
void Z3_API Z3_solver_propagate_consequence(Z3_context c, Z3_solver_callback, unsigned num_fixed, unsigned const *fixed_ids, unsigned num_eqs, unsigned const *eq_lhs, unsigned const *eq_rhs, Z3_ast conseq)
propagate a consequence based on fixed values. This is a callback a client may invoke during the fixe...
Z3_sort Z3_API Z3_get_array_sort_range(Z3_context c, Z3_sort t)
Return the range of the given array sort.
unsigned Z3_API Z3_get_app_num_args(Z3_context c, Z3_app a)
Return the number of argument of an application. If t is an constant, then the number of arguments is...
Z3_ast Z3_API Z3_mk_real(Z3_context c, int num, int den)
Create a real from a fraction.
Z3_ast Z3_API Z3_func_entry_get_arg(Z3_context c, Z3_func_entry e, unsigned i)
Return an argument of a Z3_func_entry object.
Z3_error_code
Z3 error codes (See Z3_get_error_code).
Definition: z3_api.h:1375
Z3_ast Z3_API Z3_mk_eq(Z3_context c, Z3_ast l, Z3_ast r)
Create an AST node representing l = r.
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
void Z3_API Z3_ast_vector_inc_ref(Z3_context c, Z3_ast_vector v)
Increment the reference counter of the given AST vector.
unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m)
Return the number of function interpretations in the given model.
void Z3_API Z3_dec_ref(Z3_context c, Z3_ast a)
Decrement the reference counter of the given AST. The context c should have been created using Z3_mk_...
Z3_ast_vector Z3_API Z3_solver_get_unsat_core(Z3_context c, Z3_solver s)
Retrieve the unsat core for the last Z3_solver_check_assumptions The unsat core is a subset of the as...
Z3_ast_vector Z3_API Z3_mk_ast_vector(Z3_context c)
Return an empty AST vector.
void Z3_API Z3_optimize_dec_ref(Z3_context c, Z3_optimize d)
Decrement the reference counter of the given optimize context.
Z3_string Z3_API Z3_get_string(Z3_context c, Z3_ast s)
Retrieve the string constant stored in s. Characters outside the basic printiable ASCII range are esc...
Z3_ast Z3_API Z3_mk_fpa_is_nan(Z3_context c, Z3_ast t)
Predicate indicating whether t is a NaN.
bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int *i)
Similar to Z3_get_numeral_string, but only succeeds if the value can fit in a machine int....
Z3_error_code Z3_API Z3_get_error_code(Z3_context c)
Return the error code for the last API call.
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_func_decl Z3_API Z3_mk_partial_order(Z3_context c, Z3_sort a, unsigned id)
create a partial ordering relation over signature a and index id.
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
bool Z3_API Z3_is_string(Z3_context c, Z3_ast s)
Determine if s is a string constant.
Z3_ast Z3_API Z3_mk_re_loop(Z3_context c, Z3_ast r, unsigned lo, unsigned hi)
Create a regular expression loop. The supplied regular expression r is repeated between lo and hi tim...
Z3_ast Z3_API Z3_mk_char_to_int(Z3_context c, Z3_ast ch)
Create an integer (code point) from character.
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
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 Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
Z3_goal_prec Z3_API Z3_goal_precision(Z3_context c, Z3_goal g)
Return the "precision" of the given goal. Goals can be transformed using over and under approximation...
void Z3_API Z3_solver_pop(Z3_context c, Z3_solver s, unsigned n)
Backtrack n backtracking points.
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.
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...
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 but two different AST objects can m...
Z3_ast Z3_API Z3_mk_fpa_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point less than.
Z3_ast Z3_API Z3_mk_unsigned_int64(Z3_context c, uint64_t v, Z3_sort ty)
Create a numeral of a int, bit-vector, or finite-domain sort.
Z3_string Z3_API Z3_optimize_get_help(Z3_context c, Z3_optimize t)
Return a string containing a description of parameters accepted by optimize.
Z3_symbol Z3_API Z3_get_sort_name(Z3_context c, Z3_sort d)
Return the sort name as a symbol.
void Z3_API Z3_global_param_reset_all(void)
Restore the value of all global (and module) parameters. This command will not affect already created...
Z3_ast Z3_API Z3_mk_gt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than.
Z3_stats Z3_API Z3_optimize_get_statistics(Z3_context c, Z3_optimize d)
Retrieve statistics information from the last call to Z3_optimize_check.
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
Z3_probe Z3_API Z3_probe_gt(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is greater than the value retur...
Z3_ast Z3_API Z3_solver_get_proof(Z3_context c, Z3_solver s)
Retrieve the proof for the last Z3_solver_check or Z3_solver_check_assumptions.
unsigned Z3_API Z3_optimize_minimize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a minimization constraint.
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.
bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a)
Test if there exists an interpretation (i.e., assignment) for a in the model m.
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.
bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast t1, Z3_ast t2)
Compare terms.
bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a)
Determine if an ast is a universal quantifier.
void Z3_API Z3_tactic_inc_ref(Z3_context c, Z3_tactic t)
Increment the reference counter of the given tactic.
void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a file.
Z3_ast Z3_API Z3_mk_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
void Z3_API Z3_solver_propagate_eq(Z3_context c, Z3_solver s, Z3_eq_eh eq_eh)
register a callback on expression equalities.
Z3_ast Z3_API Z3_mk_string(Z3_context c, Z3_string s)
Create a string constant out of the string that is passed in The string may contain escape encoding f...
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
Z3_tactic Z3_API Z3_tactic_try_for(Z3_context c, Z3_tactic t, unsigned ms)
Return a tactic that applies t to a given goal for ms milliseconds. If t does not terminate in ms mil...
Z3_ast Z3_API Z3_mk_rotate_left(Z3_context c, unsigned i, Z3_ast t1)
Rotate bits of t1 to the left i times.
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_sort Z3_API Z3_mk_seq_sort(Z3_context c, Z3_sort s)
Create a sequence sort out of the sort for the elements.
unsigned Z3_API Z3_optimize_maximize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a maximization constraint.
Z3_ast_vector Z3_API Z3_solver_get_units(Z3_context c, Z3_solver s)
Return the set of units modulo model conversion.
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
Z3_ast Z3_API Z3_mk_seq_last_index(Z3_context c, Z3_ast, Z3_ast substr)
Return the last occurrence of substr in s. If s does not contain substr, then the value is -1,...
void Z3_API Z3_param_descrs_inc_ref(Z3_context c, Z3_param_descrs p)
Increment the reference counter of the given parameter description set.
Z3_goal Z3_API Z3_apply_result_get_subgoal(Z3_context c, Z3_apply_result r, unsigned i)
Return one of the subgoals in the Z3_apply_result object returned by Z3_tactic_apply.
Z3_probe Z3_API Z3_probe_le(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is less than or equal to the va...
void Z3_API Z3_stats_dec_ref(Z3_context c, Z3_stats s)
Decrement the reference counter of the given statistics object.
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
Z3_func_entry Z3_API Z3_func_interp_get_entry(Z3_context c, Z3_func_interp f, unsigned i)
Return a "point" of the given function interpretation. It represents the value of f in a particular p...
Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a recursive function.
unsigned Z3_API Z3_get_ast_id(Z3_context c, Z3_ast t)
Return a unique identifier for t. The identifier is unique up to structural equality....
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
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_apply_result Z3_API Z3_tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g)
Apply tactic t to the goal g.
Z3_ast Z3_API Z3_mk_fpa_leq(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point less than or equal.
void Z3_API Z3_solver_propagate_created(Z3_context c, Z3_solver s, Z3_created_eh created_eh)
register a callback when a new expression with a registered function is used by the solver The regist...
Z3_ast Z3_API Z3_mk_fpa_numeral_double(Z3_context c, double v, Z3_sort ty)
Create a numeral of FloatingPoint sort from a double.
unsigned Z3_API Z3_get_sort_id(Z3_context c, Z3_sort s)
Return a unique identifier for s.
Z3_ast Z3_API Z3_mk_fpa_mul(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point multiplication.
Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const args[])
Create a constant or function application.
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).
Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s)
Return statistics for the given solver.
Z3_ast Z3_API Z3_mk_bvneg(Z3_context c, Z3_ast t1)
Standard two's complement unary minus.
Z3_ast Z3_API Z3_mk_store_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs, Z3_ast v)
n-ary Array update.
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_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_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint f)
Return a string describing all fixedpoint available parameters.
Z3_sort Z3_API Z3_get_domain(Z3_context c, Z3_func_decl d, unsigned i)
Return the sort of the i-th parameter of the given function declaration.
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
Z3_ast Z3_API Z3_mk_sub(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] - ... - args[num_args - 1].
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_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_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.
unsigned Z3_API Z3_get_func_decl_id(Z3_context c, Z3_func_decl f)
Return a unique identifier for f.
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
Z3_ast Z3_API Z3_mk_lstring(Z3_context c, unsigned len, Z3_string s)
Create a string constant out of the string that is passed in It takes the length of the string as wel...
Z3_ast Z3_API Z3_mk_bvsdiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed division.
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
double Z3_API Z3_probe_apply(Z3_context c, Z3_probe p, Z3_goal g)
Execute the probe over the goal. The probe always produce a double value. "Boolean" probes return 0....
void Z3_API Z3_func_interp_set_else(Z3_context c, Z3_func_interp f, Z3_ast else_value)
Return the 'else' value of the given function interpretation.
void Z3_API Z3_goal_dec_ref(Z3_context c, Z3_goal g)
Decrement the reference counter of the given goal.
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the free variables in a with the expressions in to. For every i smaller than num_exprs,...
Z3_ast Z3_API Z3_mk_or(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] or ... or args[num_args-1].
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
Z3_tactic Z3_API Z3_tactic_or_else(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that first applies t1 to a given goal, if it fails then returns the result of t2 appl...
void Z3_API Z3_model_inc_ref(Z3_context c, Z3_model m)
Increment the reference counter of the given model.
Z3_ast Z3_API Z3_mk_seq_extract(Z3_context c, Z3_ast s, Z3_ast offset, Z3_ast length)
Extract subsequence starting at offset of length.
Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, bool model_completion, Z3_ast *v)
Evaluate the AST node t in the given model. Return true if succeeded, and store the result in v.
Z3_ast Z3_API Z3_mk_fpa_div(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point division.
Z3_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
Z3_ast Z3_API Z3_mk_fpa_sqrt(Z3_context c, Z3_ast rm, Z3_ast t)
Floating-point square root.
bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g)
Return true if the goal is empty, and it is precise or the product of a under approximation.
void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint f, Z3_params p)
Set parameters on fixedpoint context.
void Z3_API Z3_optimize_from_string(Z3_context c, Z3_optimize o, Z3_string s)
Parse an SMT-LIB2 string with assertions, soft constraints and optimization objectives....
Z3_ast Z3_API Z3_mk_rem(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 rem arg2.
Z3_ast Z3_API Z3_fixedpoint_get_answer(Z3_context c, Z3_fixedpoint d)
Retrieve a formula that encodes satisfying answers to the query.
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned *u)
Similar to Z3_get_numeral_string, but only succeeds if the value can fit in a machine unsigned int....
Z3_string Z3_API Z3_get_numeral_string(Z3_context c, Z3_ast a)
Return numeral value, as a decimal string of a numeric constant term.
void Z3_API Z3_solver_propagate_fixed(Z3_context c, Z3_solver s, Z3_fixed_eh fixed_eh)
register a callback for when an expression is bound to a fixed value. The supported expression types ...
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...
Z3_ast Z3_API Z3_mk_char_is_digit(Z3_context c, Z3_ast ch)
Create a check if the character is a digit.
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...
void Z3_API Z3_func_interp_add_entry(Z3_context c, Z3_func_interp fi, Z3_ast_vector args, Z3_ast value)
add a function entry to a function interpretation.
bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t)
Return true if the given expression t is well sorted.
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
Z3_lbool Z3_API Z3_fixedpoint_query_relations(Z3_context c, Z3_fixedpoint d, unsigned num_relations, Z3_func_decl const relations[])
Pose multiple queries against the asserted rules.
Z3_ast Z3_API Z3_mk_as_array(Z3_context c, Z3_func_decl f)
Create array with the same interpretation as a function. The array satisfies the property (f x) = (se...
Z3_string Z3_API Z3_apply_result_to_string(Z3_context c, Z3_apply_result r)
Convert the Z3_apply_result object returned by Z3_tactic_apply into a string.
Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s)
Convert a solver into a string.
Z3_string Z3_API Z3_solver_get_reason_unknown(Z3_context c, Z3_solver s)
Return a brief justification for an "unknown" result (i.e., Z3_L_UNDEF) for the commands Z3_solver_ch...
Z3_ast Z3_API Z3_mk_fpa_fma(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2, Z3_ast t3)
Floating-point fused multiply-add.
Z3_string Z3_API Z3_get_numeral_binary_string(Z3_context c, Z3_ast a)
Return numeral value, as a binary string of a numeric constant term.
Z3_tactic Z3_API Z3_tactic_repeat(Z3_context c, Z3_tactic t, unsigned max)
Return a tactic that keeps applying t until the goal is not modified anymore or the maximum number of...
Z3_ast Z3_API Z3_goal_formula(Z3_context c, Z3_goal g, unsigned idx)
Return a formula from the given goal.
Z3_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_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
Z3_ast Z3_API Z3_mk_char_from_bv(Z3_context c, Z3_ast bv)
Create a character from a bit-vector (code point).
unsigned Z3_API Z3_func_interp_get_num_entries(Z3_context c, Z3_func_interp f)
Return the number of entries in the given function interpretation.
Z3_probe Z3_API Z3_probe_const(Z3_context x, double val)
Return a probe that always evaluates to val.
Z3_sort Z3_API Z3_mk_fpa_rounding_mode_sort(Z3_context c)
Create the RoundingMode sort.
Z3_string Z3_API Z3_goal_to_string(Z3_context c, Z3_goal g)
Convert a goal into a string.
Z3_ast Z3_API Z3_mk_fpa_rne(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode.
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
void Z3_API Z3_del_config(Z3_config c)
Delete the given configuration object.
double Z3_API Z3_get_numeral_double(Z3_context c, Z3_ast a)
Return numeral as a double.
void Z3_API Z3_inc_ref(Z3_context c, Z3_ast a)
Increment the reference counter of the given AST. The context c should have been created using Z3_mk_...
Z3_tactic Z3_API Z3_tactic_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal and t2 to every subgoal produced by t1.
Z3_func_interp Z3_API Z3_model_get_func_interp(Z3_context c, Z3_model m, Z3_func_decl f)
Return the interpretation of the function f in the model m. Return NULL, if the model does not assign...
void Z3_API Z3_solver_inc_ref(Z3_context c, Z3_solver s)
Increment the reference counter of the given solver.
Z3_probe Z3_API Z3_probe_and(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when p1 and p2 evaluates to true.
bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s)
Check if s is a regular expression sort.
Z3_ast Z3_API Z3_mk_ubv_to_str(Z3_context c, Z3_ast s)
Unsigned bit-vector to string conversion.
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for unicode strings.
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_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
Z3_ast Z3_API Z3_mk_seq_nth(Z3_context c, Z3_ast s, Z3_ast index)
Retrieve from s the element positioned at position index. The function is under-specified if the inde...
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s)
Remove all assertions from the solver.
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a)
Return true if the given AST is a real algebraic number.
@ Z3_PRINT_SMTLIB2_COMPLIANT
Definition: z3_api.h:1353
@ Z3_APP_AST
Definition: z3_api.h:183
@ Z3_VAR_AST
Definition: z3_api.h:184
@ Z3_SORT_AST
Definition: z3_api.h:186
@ Z3_NUMERAL_AST
Definition: z3_api.h:182
@ Z3_FUNC_DECL_AST
Definition: z3_api.h:187
@ Z3_QUANTIFIER_AST
Definition: z3_api.h:185
@ Z3_OP_DISTINCT
Definition: z3_api.h:1006
@ Z3_OP_AND
Definition: z3_api.h:1008
@ Z3_OP_FALSE
Definition: z3_api.h:1004
@ Z3_OP_XOR
Definition: z3_api.h:1011
@ Z3_OP_IMPLIES
Definition: z3_api.h:1013
@ Z3_OP_ITE
Definition: z3_api.h:1007
@ Z3_OP_EQ
Definition: z3_api.h:1005
@ Z3_OP_OR
Definition: z3_api.h:1009
@ Z3_OP_NOT
Definition: z3_api.h:1012
@ Z3_OP_TRUE
Definition: z3_api.h:1003
@ Z3_RELATION_SORT
Definition: z3_api.h:158
@ Z3_BOOL_SORT
Definition: z3_api.h:152
@ Z3_BV_SORT
Definition: z3_api.h:155
@ Z3_DATATYPE_SORT
Definition: z3_api.h:157
@ Z3_INT_SORT
Definition: z3_api.h:153
@ Z3_FINITE_DOMAIN_SORT
Definition: z3_api.h:159
@ Z3_RE_SORT
Definition: z3_api.h:163
@ Z3_FLOATING_POINT_SORT
Definition: z3_api.h:160
@ Z3_ARRAY_SORT
Definition: z3_api.h:156
@ Z3_REAL_SORT
Definition: z3_api.h:154
@ Z3_SEQ_SORT
Definition: z3_api.h:162
@ Z3_L_TRUE
Definition: z3_api.h:105
@ Z3_L_FALSE
Definition: z3_api.h:103
@ Z3_STRING_SYMBOL
Definition: z3_api.h:118
@ Z3_INT_SYMBOL
Definition: z3_api.h:117
@ Z3_OK
Definition: z3_api.h:1376
Z3 C++ namespace.
Definition: z3++.h:49
expr re_intersect(expr_vector const &args)
Definition: z3++.h:3792
expr indexof(expr const &s, expr const &substr, expr const &offset)
Definition: z3++.h:3755
expr mk_and(expr_vector const &args)
Definition: z3++.h:2430
expr fpa_to_ubv(expr const &t, unsigned sz)
Definition: z3++.h:1978
expr star(expr const &re)
Definition: z3++.h:3779
void check_context(object const &a, object const &b)
Definition: z3++.h:433
expr bvsub_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2169
expr operator==(expr const &a, expr const &b)
Definition: z3++.h:1632
expr operator>=(expr const &a, expr const &b)
Definition: z3++.h:1709
expr srem(expr const &a, expr const &b)
signed remainder operator for bitvectors
Definition: z3++.h:2110
expr bvadd_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2166
expr pble(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2322
expr store(expr const &a, expr const &i, expr const &v)
Definition: z3++.h:3645
expr mod(expr const &a, expr const &b)
Definition: z3++.h:1567
expr fma(expr const &a, expr const &b, expr const &c, expr const &rm)
Definition: z3++.h:1955
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3810
expr round_fpa_to_closest_integer(expr const &t)
Definition: z3++.h:2006
expr distinct(expr_vector const &args)
Definition: z3++.h:2371
expr bvmul_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2184
expr operator|(expr const &a, expr const &b)
Definition: z3++.h:1870
expr pbeq(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2338
ast_vector_tpl< func_decl > func_decl_vector
Definition: z3++.h:75
expr lshr(expr const &a, expr const &b)
logic shift right operator for bitvectors
Definition: z3++.h:2138
expr bv2int(expr const &a, bool is_signed)
bit-vector and integer conversions.
Definition: z3++.h:2157
expr max(expr const &a, expr const &b)
Definition: z3++.h:1892
expr operator^(expr const &a, expr const &b)
Definition: z3++.h:1866
func_decl linear_order(sort const &a, unsigned index)
Definition: z3++.h:2194
check_result
Definition: z3++.h:132
@ unknown
Definition: z3++.h:133
@ sat
Definition: z3++.h:133
@ unsat
Definition: z3++.h:133
expr operator<(expr const &a, expr const &b)
Definition: z3++.h:1818
expr set_intersect(expr const &a, expr const &b)
Definition: z3++.h:3710
func_decl tree_order(sort const &a, unsigned index)
Definition: z3++.h:2203
expr forall(expr const &x, expr const &b)
Definition: z3++.h:2249
expr bvneg_no_overflow(expr const &a)
Definition: z3++.h:2178
expr set_member(expr const &s, expr const &e)
Definition: z3++.h:3726
expr set_difference(expr const &a, expr const &b)
Definition: z3++.h:3718
func_decl recfun(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3615
expr sext(expr const &a, unsigned i)
Sign-extend of the given bit-vector to the (signed) equivalent bitvector of size m+i,...
Definition: z3++.h:2192
expr bvadd_no_overflow(expr const &a, expr const &b, bool is_signed)
bit-vector overflow/underflow checks
Definition: z3++.h:2163
expr slt(expr const &a, expr const &b)
signed less than operator for bitvectors.
Definition: z3++.h:2059
expr bvsdiv_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2175
expr empty_set(sort const &s)
Definition: z3++.h:3686
expr plus(expr const &re)
Definition: z3++.h:3773
expr rem(expr const &a, expr const &b)
Definition: z3++.h:1583
expr re_diff(expr const &a, expr const &b)
Definition: z3++.h:3800
expr operator!(expr const &a)
Definition: z3++.h:1601
expr fpa_fp(expr const &sgn, expr const &exp, expr const &sig)
Definition: z3++.h:1963
expr mk_xor(expr_vector const &args)
Definition: z3++.h:2436
void set_param(char const *param, char const *value)
Definition: z3++.h:77
expr full_set(sort const &s)
Definition: z3++.h:3690
ast_vector_tpl< sort > sort_vector
Definition: z3++.h:74
expr as_array(func_decl &f)
Definition: z3++.h:3665
tactic when(probe const &p, tactic const &t)
Definition: z3++.h:3249
expr operator*(expr const &a, expr const &b)
Definition: z3++.h:1685
expr uge(expr const &a, expr const &b)
unsigned greater than or equal to operator for bitvectors.
Definition: z3++.h:2091
expr nand(expr const &a, expr const &b)
Definition: z3++.h:1874
expr zext(expr const &a, unsigned i)
Extend the given bit-vector with zeros to the (unsigned) equivalent bitvector of size m+i,...
Definition: z3++.h:2152
expr is_int(expr const &e)
Definition: z3++.h:1603
expr empty(sort const &s)
Definition: z3++.h:3738
expr operator-(expr const &a)
Definition: z3++.h:1751
expr re_complement(expr const &a)
Definition: z3++.h:3807
expr set_del(expr const &s, expr const &e)
Definition: z3++.h:3698
expr mk_or(expr_vector const &args)
Definition: z3++.h:2424
expr concat(expr const &a, expr const &b)
Definition: z3++.h:2380
tactic with(tactic const &t, params const &p)
Definition: z3++.h:2979
expr operator%(expr const &a, expr const &b)
Definition: z3++.h:1578
expr re_full(sort const &s)
Definition: z3++.h:3787
func_decl partial_order(sort const &a, unsigned index)
Definition: z3++.h:2197
std::ostream & operator<<(std::ostream &out, exception const &e)
Definition: z3++.h:94
tactic par_and_then(tactic const &t1, tactic const &t2)
Definition: z3++.h:2998
bool eq(ast const &a, ast const &b)
Definition: z3++.h:538
expr operator~(expr const &a)
Definition: z3++.h:1953
expr exists(expr const &x, expr const &b)
Definition: z3++.h:2273
expr ite(expr const &c, expr const &t, expr const &e)
Create the if-then-else expression ite(c, t, e)
Definition: z3++.h:2018
expr bvsub_no_underflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2172
expr set_add(expr const &s, expr const &e)
Definition: z3++.h:3694
expr sum(expr_vector const &args)
Definition: z3++.h:2362
expr last_indexof(expr const &s, expr const &substr)
Definition: z3++.h:3761
expr pbge(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2330
expr set_union(expr const &a, expr const &b)
Definition: z3++.h:3702
func_decl to_func_decl(context &c, Z3_func_decl f)
Definition: z3++.h:2045
tactic cond(probe const &p, tactic const &t1, tactic const &t2)
Definition: z3++.h:3255
expr sbv_to_fpa(expr const &t, sort s)
Definition: z3++.h:1985
expr ubv_to_fpa(expr const &t, sort s)
Definition: z3++.h:1992
expr operator||(expr const &a, expr const &b)
Definition: z3++.h:1619
expr const_array(sort const &d, expr const &v)
Definition: z3++.h:3682
tactic par_or(unsigned n, tactic const *tactics)
Definition: z3++.h:2989
func_decl piecewise_linear_order(sort const &a, unsigned index)
Definition: z3++.h:2200
expr operator&&(expr const &a, expr const &b)
Definition: z3++.h:1607
func_decl function(std::string const &name, sort_vector const &domain, sort const &range)
Definition: z3++.h:3611
expr atleast(expr_vector const &es, unsigned bound)
Definition: z3++.h:2354
expr atmost(expr_vector const &es, unsigned bound)
Definition: z3++.h:2346
expr operator>(expr const &a, expr const &b)
Definition: z3++.h:1840
tactic repeat(tactic const &t, unsigned max=UINT_MAX)
Definition: z3++.h:2973
expr re_empty(sort const &s)
Definition: z3++.h:3782
expr select(expr const &a, expr const &i)
forward declarations
Definition: z3++.h:3628
expr urem(expr const &a, expr const &b)
unsigned reminder operator for bitvectors
Definition: z3++.h:2124
expr in_re(expr const &s, expr const &re)
Definition: z3++.h:3770
expr to_re(expr const &s)
Definition: z3++.h:3767
expr operator/(expr const &a, expr const &b)
Definition: z3++.h:1729
expr fp_eq(expr const &a, expr const &b)
Definition: z3++.h:1946
expr bvredor(expr const &a)
Definition: z3++.h:1907
expr nor(expr const &a, expr const &b)
Definition: z3++.h:1875
expr bvmul_no_overflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2181
expr min(expr const &a, expr const &b)
Definition: z3++.h:1877
expr sle(expr const &a, expr const &b)
signed less than or equal to operator for bitvectors.
Definition: z3++.h:2053
sort to_sort(context &c, Z3_sort s)
Definition: z3++.h:2040
check_result to_check_result(Z3_lbool l)
Definition: z3++.h:144
expr ugt(expr const &a, expr const &b)
unsigned greater than operator for bitvectors.
Definition: z3++.h:2097
ast_vector_tpl< expr > expr_vector
Definition: z3++.h:73
expr sgt(expr const &a, expr const &b)
signed greater than operator for bitvectors.
Definition: z3++.h:2071
expr lambda(expr const &x, expr const &b)
Definition: z3++.h:2297
expr to_real(expr const &a)
Definition: z3++.h:3585
rounding_mode
Definition: z3++.h:136
@ RNE
Definition: z3++.h:138
@ RNA
Definition: z3++.h:137
@ RTZ
Definition: z3++.h:141
@ RTN
Definition: z3++.h:140
@ RTP
Definition: z3++.h:139
expr operator+(expr const &a, expr const &b)
Definition: z3++.h:1655
expr int2bv(unsigned n, expr const &a)
Definition: z3++.h:2158
expr udiv(expr const &a, expr const &b)
unsigned division operator for bitvectors.
Definition: z3++.h:2103
expr prefixof(expr const &a, expr const &b)
Definition: z3++.h:3749
expr suffixof(expr const &a, expr const &b)
Definition: z3++.h:3743
expr set_complement(expr const &a)
Definition: z3++.h:3722
expr abs(expr const &a)
Definition: z3++.h:1919
expr fpa_to_sbv(expr const &t, unsigned sz)
Definition: z3++.h:1971
expr ule(expr const &a, expr const &b)
unsigned less than or equal to operator for bitvectors.
Definition: z3++.h:2079
void reset_params()
Definition: z3++.h:80
expr operator<=(expr const &a, expr const &b)
Definition: z3++.h:1793
expr option(expr const &re)
Definition: z3++.h:3776
expr to_expr(context &c, Z3_ast a)
Wraps a Z3_ast as an expr object. It also checks for errors. This function allows the user to use the...
Definition: z3++.h:2031
expr operator!=(expr const &a, expr const &b)
Definition: z3++.h:1643
tactic fail_if(probe const &p)
Definition: z3++.h:3244
ast_vector_tpl< ast > ast_vector
Definition: z3++.h:71
expr sqrt(expr const &a, expr const &rm)
Definition: z3++.h:1939
expr shl(expr const &a, expr const &b)
shift left operator for bitvectors
Definition: z3++.h:2131
expr implies(expr const &a, expr const &b)
Definition: z3++.h:1555
expr operator&(expr const &a, expr const &b)
Definition: z3++.h:1862
expr sge(expr const &a, expr const &b)
signed greater than or equal to operator for bitvectors.
Definition: z3++.h:2065
expr smod(expr const &a, expr const &b)
signed modulus operator for bitvectors
Definition: z3++.h:2117
expr set_subset(expr const &a, expr const &b)
Definition: z3++.h:3730
expr ult(expr const &a, expr const &b)
unsigned less than operator for bitvectors.
Definition: z3++.h:2085
expr pw(expr const &a, expr const &b)
Definition: z3++.h:1563
expr ashr(expr const &a, expr const &b)
arithmetic shift right operator for bitvectors
Definition: z3++.h:2145
expr xnor(expr const &a, expr const &b)
Definition: z3++.h:1876
expr bvredand(expr const &a)
Definition: z3++.h:1913
tactic try_for(tactic const &t, unsigned ms)
Definition: z3++.h:2984
expr fpa_to_fpa(expr const &t, sort s)
Definition: z3++.h:1999
def tactics(ctx=None)
Definition: z3py.py:8334
#define _Z3_MK_BIN_(a, b, binop)
Definition: z3++.h:1548
#define MK_EXPR1(_fn, _arg)
Definition: z3++.h:3671
#define MK_EXPR2(_fn, _arg1, _arg2)
Definition: z3++.h:3676
#define Z3_THROW(x)
Definition: z3++.h:100
#define _Z3_MK_UN_(a, mkun)
Definition: z3++.h:1595