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<ostream>
25 #include<string>
26 #include<memory>
27 #include<vector>
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 constructors;
60  class constructor_list;
61  class func_decl;
62  class expr;
63  class solver;
64  class goal;
65  class tactic;
66  class simplifier;
67  class probe;
68  class model;
69  class func_interp;
70  class func_entry;
71  class statistics;
72  class apply_result;
73  template<typename T> class cast_ast;
74  template<typename T> class ast_vector_tpl;
79 
80  inline void set_param(char const * param, char const * value) { Z3_global_param_set(param, value); }
81  inline void set_param(char const * param, bool value) { Z3_global_param_set(param, value ? "true" : "false"); }
82  inline void set_param(char const * param, int value) { auto str = std::to_string(value); Z3_global_param_set(param, str.c_str()); }
84 
88  class exception : public std::exception {
89  std::string m_msg;
90  public:
91  virtual ~exception() throw() = default;
92  exception(char const * msg):m_msg(msg) {}
93  char const * msg() const { return m_msg.c_str(); }
94  char const * what() const throw() { return m_msg.c_str(); }
95  friend std::ostream & operator<<(std::ostream & out, exception const & e);
96  };
97  inline std::ostream & operator<<(std::ostream & out, exception const & e) { out << e.msg(); return out; }
98 
99 #if !defined(Z3_THROW)
100 #if __cpp_exceptions || _CPPUNWIND || __EXCEPTIONS
101 #define Z3_THROW(x) throw x
102 #else
103 #define Z3_THROW(x) {}
104 #endif
105 #endif // !defined(Z3_THROW)
106 
110  class config {
111  Z3_config m_cfg;
112  config(config const &) = delete;
113  config & operator=(config const &) = delete;
114  public:
115  config() { m_cfg = Z3_mk_config(); }
116  ~config() { Z3_del_config(m_cfg); }
117  operator Z3_config() const { return m_cfg; }
121  void set(char const * param, char const * value) { Z3_set_param_value(m_cfg, param, value); }
125  void set(char const * param, bool value) { Z3_set_param_value(m_cfg, param, value ? "true" : "false"); }
129  void set(char const * param, int value) {
130  auto str = std::to_string(value);
131  Z3_set_param_value(m_cfg, param, str.c_str());
132  }
133  };
134 
137  };
138 
145  };
146 
148  if (l == Z3_L_TRUE) return sat;
149  else if (l == Z3_L_FALSE) return unsat;
150  return unknown;
151  }
152 
153 
154 
160  class context {
161  private:
162  friend class user_propagator_base;
163  bool m_enable_exceptions = true;
164  rounding_mode m_rounding_mode;
165  Z3_context m_ctx = nullptr;
166  void init(config & c) {
167  set_context(Z3_mk_context_rc(c));
168  }
169  void set_context(Z3_context ctx) {
170  m_ctx = ctx;
171  m_enable_exceptions = true;
172  m_rounding_mode = RNE;
173  Z3_set_error_handler(m_ctx, 0);
175  }
176 
177 
178  context(context const &) = delete;
179  context & operator=(context const &) = delete;
180 
181  context(Z3_context c) { set_context(c); }
182  void detach() { m_ctx = nullptr; }
183  public:
184  context() { config c; init(c); }
185  context(config & c) { init(c); }
186  ~context() { if (m_ctx) Z3_del_context(m_ctx); }
187  operator Z3_context() const { return m_ctx; }
188 
193  Z3_error_code e = Z3_get_error_code(m_ctx);
194  if (e != Z3_OK && enable_exceptions())
195  Z3_THROW(exception(Z3_get_error_msg(m_ctx, e)));
196  return e;
197  }
198 
199  void check_parser_error() const {
200  check_error();
201  }
202 
210  void set_enable_exceptions(bool f) { m_enable_exceptions = f; }
211 
212  bool enable_exceptions() const { return m_enable_exceptions; }
213 
217  void set(char const * param, char const * value) { Z3_update_param_value(m_ctx, param, value); }
221  void set(char const * param, bool value) { Z3_update_param_value(m_ctx, param, value ? "true" : "false"); }
225  void set(char const * param, int value) {
226  auto str = std::to_string(value);
227  Z3_update_param_value(m_ctx, param, str.c_str());
228  }
229 
234  void interrupt() { Z3_interrupt(m_ctx); }
235 
239  symbol str_symbol(char const * s);
243  symbol int_symbol(int n);
247  sort bool_sort();
251  sort int_sort();
255  sort real_sort();
259  sort bv_sort(unsigned sz);
260 
264  sort char_sort();
268  sort string_sort();
272  sort seq_sort(sort& s);
282  sort array_sort(sort d, sort r);
283  sort array_sort(sort_vector const& d, sort r);
290  sort fpa_sort(unsigned ebits, unsigned sbits);
294  template<size_t precision>
295  sort fpa_sort();
309  sort enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts);
310 
317  func_decl tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs);
318 
319 
328  sort datatype(symbol const& name, constructors const& cs);
329 
336  sort_vector datatypes(unsigned n, symbol const* names,
337  constructor_list *const* cons);
338 
339 
344  sort datatype_sort(symbol const& name);
345 
346 
350  sort uninterpreted_sort(char const* name);
351  sort uninterpreted_sort(symbol const& name);
352 
353  func_decl function(symbol const & name, unsigned arity, sort const * domain, sort const & range);
354  func_decl function(char const * name, unsigned arity, sort const * domain, sort const & range);
355  func_decl function(symbol const& name, sort_vector const& domain, sort const& range);
356  func_decl function(char const * name, sort_vector const& domain, sort const& range);
357  func_decl function(char const * name, sort const & domain, sort const & range);
358  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & range);
359  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range);
360  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range);
361  func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & d5, sort const & range);
362 
363  func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range);
364  func_decl recfun(symbol const & name, const sort_vector& domain, sort const & range);
365  func_decl recfun(char const * name, sort_vector const& domain, sort const & range);
366  func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range);
367  func_decl recfun(char const * name, sort const & domain, sort const & range);
368  func_decl recfun(char const * name, sort const & d1, sort const & d2, sort const & range);
369 
376  void recdef(func_decl decl, expr_vector const& args, expr const& body);
377  func_decl user_propagate_function(symbol const& name, sort_vector const& domain, sort const& range);
378 
382  expr constant(symbol const & name, sort const & s);
383  expr constant(char const * name, sort const & s);
387  expr bool_const(char const * name);
388  expr int_const(char const * name);
389  expr real_const(char const * name);
390  expr string_const(char const * name);
391  expr bv_const(char const * name, unsigned sz);
392  expr fpa_const(char const * name, unsigned ebits, unsigned sbits);
393 
394  template<size_t precision>
395  expr fpa_const(char const * name);
396 
400  expr variable(unsigned index, sort const& s);
401 
402 
404 
405  expr bool_val(bool b);
406 
407  expr int_val(int n);
408  expr int_val(unsigned n);
409  expr int_val(int64_t n);
410  expr int_val(uint64_t n);
411  expr int_val(char const * n);
412 
413  expr real_val(int n);
414  expr real_val(unsigned n);
415  expr real_val(int64_t n);
416  expr real_val(uint64_t n);
417  expr real_val(int64_t n, int64_t d);
418  expr real_val(char const * n);
419 
420  expr bv_val(int n, unsigned sz);
421  expr bv_val(unsigned n, unsigned sz);
422  expr bv_val(int64_t n, unsigned sz);
423  expr bv_val(uint64_t n, unsigned sz);
424  expr bv_val(char const * n, unsigned sz);
425  expr bv_val(unsigned n, bool const* bits);
426 
427  expr fpa_val(double n);
428  expr fpa_val(float n);
429  expr fpa_nan(sort const & s);
430  expr fpa_inf(sort const & s, bool sgn);
431 
432  expr string_val(char const* s);
433  expr string_val(char const* s, unsigned n);
434  expr string_val(std::string const& s);
435  expr string_val(std::u32string const& s);
436 
437  expr num_val(int n, sort const & s);
438 
442  expr_vector parse_string(char const* s);
443  expr_vector parse_file(char const* file);
444 
445  expr_vector parse_string(char const* s, sort_vector const& sorts, func_decl_vector const& decls);
446  expr_vector parse_file(char const* s, sort_vector const& sorts, func_decl_vector const& decls);
447  };
448 
449 
450  template<typename T>
451  class array {
452  std::unique_ptr<T[]> m_array;
453  unsigned m_size;
454  array(array const &) = delete;
455  array & operator=(array const &) = delete;
456  public:
457  array(unsigned sz):m_array(new T[sz]),m_size(sz) {}
458  template<typename T2>
459  array(ast_vector_tpl<T2> const & v);
460  void resize(unsigned sz) { m_array.reset(new T[sz]); m_size = sz; }
461  unsigned size() const { return m_size; }
462  T & operator[](int i) { assert(0 <= i); assert(static_cast<unsigned>(i) < m_size); return m_array[i]; }
463  T const & operator[](int i) const { assert(0 <= i); assert(static_cast<unsigned>(i) < m_size); return m_array[i]; }
464  T const * ptr() const { return m_array.get(); }
465  T * ptr() { return m_array.get(); }
466  };
467 
468  class object {
469  protected:
471  public:
472  object(context & c):m_ctx(&c) {}
473  context & ctx() const { return *m_ctx; }
474  Z3_error_code check_error() const { return m_ctx->check_error(); }
475  friend void check_context(object const & a, object const & b);
476  };
477  inline void check_context(object const & a, object const & b) { (void)a; (void)b; assert(a.m_ctx == b.m_ctx); }
478 
479  class symbol : public object {
480  Z3_symbol m_sym;
481  public:
482  symbol(context & c, Z3_symbol s):object(c), m_sym(s) {}
483  operator Z3_symbol() const { return m_sym; }
484  Z3_symbol_kind kind() const { return Z3_get_symbol_kind(ctx(), m_sym); }
485  std::string str() const { assert(kind() == Z3_STRING_SYMBOL); return Z3_get_symbol_string(ctx(), m_sym); }
486  int to_int() const { assert(kind() == Z3_INT_SYMBOL); return Z3_get_symbol_int(ctx(), m_sym); }
487  friend std::ostream & operator<<(std::ostream & out, symbol const & s);
488  };
489 
490  inline std::ostream & operator<<(std::ostream & out, symbol const & s) {
491  if (s.kind() == Z3_INT_SYMBOL)
492  out << "k!" << s.to_int();
493  else
494  out << s.str();
495  return out;
496  }
497 
498 
499  class param_descrs : public object {
500  Z3_param_descrs m_descrs;
501  public:
502  param_descrs(context& c, Z3_param_descrs d): object(c), m_descrs(d) { Z3_param_descrs_inc_ref(c, d); }
503  param_descrs(param_descrs const& o): object(o.ctx()), m_descrs(o.m_descrs) { Z3_param_descrs_inc_ref(ctx(), m_descrs); }
505  Z3_param_descrs_inc_ref(o.ctx(), o.m_descrs);
506  Z3_param_descrs_dec_ref(ctx(), m_descrs);
507  m_descrs = o.m_descrs;
508  object::operator=(o);
509  return *this;
510  }
514 
515  unsigned size() { return Z3_param_descrs_size(ctx(), m_descrs); }
516  symbol name(unsigned i) { return symbol(ctx(), Z3_param_descrs_get_name(ctx(), m_descrs, i)); }
517  Z3_param_kind kind(symbol const& s) { return Z3_param_descrs_get_kind(ctx(), m_descrs, s); }
518  std::string documentation(symbol const& s) { char const* r = Z3_param_descrs_get_documentation(ctx(), m_descrs, s); check_error(); return r; }
519  std::string to_string() const { return Z3_param_descrs_to_string(ctx(), m_descrs); }
520  };
521 
522  inline std::ostream& operator<<(std::ostream & out, param_descrs const & d) { return out << d.to_string(); }
523 
524  class params : public object {
525  Z3_params m_params;
526  public:
527  params(context & c):object(c) { m_params = Z3_mk_params(c); Z3_params_inc_ref(ctx(), m_params); }
528  params(params const & s):object(s), m_params(s.m_params) { Z3_params_inc_ref(ctx(), m_params); }
529  ~params() { Z3_params_dec_ref(ctx(), m_params); }
530  operator Z3_params() const { return m_params; }
531  params & operator=(params const & s) {
532  Z3_params_inc_ref(s.ctx(), s.m_params);
533  Z3_params_dec_ref(ctx(), m_params);
534  object::operator=(s);
535  m_params = s.m_params;
536  return *this;
537  }
538  void set(char const * k, bool b) { Z3_params_set_bool(ctx(), m_params, ctx().str_symbol(k), b); }
539  void set(char const * k, unsigned n) { Z3_params_set_uint(ctx(), m_params, ctx().str_symbol(k), n); }
540  void set(char const * k, double n) { Z3_params_set_double(ctx(), m_params, ctx().str_symbol(k), n); }
541  void set(char const * k, symbol const & s) { Z3_params_set_symbol(ctx(), m_params, ctx().str_symbol(k), s); }
542  void set(char const * k, char const* s) { Z3_params_set_symbol(ctx(), m_params, ctx().str_symbol(k), ctx().str_symbol(s)); }
543  friend std::ostream & operator<<(std::ostream & out, params const & p);
544  };
545 
546  inline std::ostream & operator<<(std::ostream & out, params const & p) {
547  out << Z3_params_to_string(p.ctx(), p); return out;
548  }
549 
550  class ast : public object {
551  protected:
552  Z3_ast m_ast;
553  public:
554  ast(context & c):object(c), m_ast(0) {}
555  ast(context & c, Z3_ast n):object(c), m_ast(n) { Z3_inc_ref(ctx(), m_ast); }
556  ast(ast const & s) :object(s), m_ast(s.m_ast) { Z3_inc_ref(ctx(), m_ast); }
557  ~ast() { if (m_ast) { Z3_dec_ref(*m_ctx, m_ast); } }
558  operator Z3_ast() const { return m_ast; }
559  operator bool() const { return m_ast != 0; }
560  ast & operator=(ast const & s) {
561  Z3_inc_ref(s.ctx(), s.m_ast);
562  if (m_ast)
563  Z3_dec_ref(ctx(), m_ast);
564  object::operator=(s);
565  m_ast = s.m_ast;
566  return *this;
567  }
568  Z3_ast_kind kind() const { Z3_ast_kind r = Z3_get_ast_kind(ctx(), m_ast); check_error(); return r; }
569  unsigned hash() const { unsigned r = Z3_get_ast_hash(ctx(), m_ast); check_error(); return r; }
570  friend std::ostream & operator<<(std::ostream & out, ast const & n);
571  std::string to_string() const { return std::string(Z3_ast_to_string(ctx(), m_ast)); }
572 
573 
577  friend bool eq(ast const & a, ast const & b);
578  };
579  inline std::ostream & operator<<(std::ostream & out, ast const & n) {
580  out << Z3_ast_to_string(n.ctx(), n.m_ast); return out;
581  }
582 
583  inline bool eq(ast const & a, ast const & b) { return Z3_is_eq_ast(a.ctx(), a, b); }
584 
585  template<typename T>
586  class ast_vector_tpl : public object {
587  Z3_ast_vector m_vector;
588  void init(Z3_ast_vector v) { Z3_ast_vector_inc_ref(ctx(), v); m_vector = v; }
589  public:
591  ast_vector_tpl(context & c, Z3_ast_vector v):object(c) { init(v); }
592  ast_vector_tpl(ast_vector_tpl const & s):object(s), m_vector(s.m_vector) { Z3_ast_vector_inc_ref(ctx(), m_vector); }
593  ast_vector_tpl(context& c, ast_vector_tpl const& src): object(c) { init(Z3_ast_vector_translate(src.ctx(), src, c)); }
594 
596  operator Z3_ast_vector() const { return m_vector; }
597  unsigned size() const { return Z3_ast_vector_size(ctx(), m_vector); }
598  T operator[](unsigned i) const { Z3_ast r = Z3_ast_vector_get(ctx(), m_vector, i); check_error(); return cast_ast<T>()(ctx(), r); }
599  void push_back(T const & e) { Z3_ast_vector_push(ctx(), m_vector, e); check_error(); }
600  void resize(unsigned sz) { Z3_ast_vector_resize(ctx(), m_vector, sz); check_error(); }
601  T back() const { return operator[](size() - 1); }
602  void pop_back() { assert(size() > 0); resize(size() - 1); }
603  bool empty() const { return size() == 0; }
605  Z3_ast_vector_inc_ref(s.ctx(), s.m_vector);
606  Z3_ast_vector_dec_ref(ctx(), m_vector);
607  object::operator=(s);
608  m_vector = s.m_vector;
609  return *this;
610  }
611  ast_vector_tpl& set(unsigned idx, ast& a) {
612  Z3_ast_vector_set(ctx(), m_vector, idx, a);
613  return *this;
614  }
615  /*
616  Disabled pending C++98 build upgrade
617  bool contains(T const& x) const {
618  for (T y : *this) if (eq(x, y)) return true;
619  return false;
620  }
621  */
622 
623  class iterator final {
624  ast_vector_tpl const* m_vector;
625  unsigned m_index;
626  public:
627  iterator(ast_vector_tpl const* v, unsigned i): m_vector(v), m_index(i) {}
628 
629  bool operator==(iterator const& other) const noexcept {
630  return other.m_index == m_index;
631  };
632  bool operator!=(iterator const& other) const noexcept {
633  return other.m_index != m_index;
634  };
635  iterator& operator++() noexcept {
636  ++m_index;
637  return *this;
638  }
639  void set(T& arg) {
640  Z3_ast_vector_set(m_vector->ctx(), *m_vector, m_index, arg);
641  }
642  iterator operator++(int) noexcept { iterator tmp = *this; ++m_index; return tmp; }
643  T * operator->() const { return &(operator*()); }
644  T operator*() const { return (*m_vector)[m_index]; }
645  };
646  iterator begin() const noexcept { return iterator(this, 0); }
647  iterator end() const { return iterator(this, size()); }
648  friend std::ostream & operator<<(std::ostream & out, ast_vector_tpl const & v) { out << Z3_ast_vector_to_string(v.ctx(), v); return out; }
649  std::string to_string() const { return std::string(Z3_ast_vector_to_string(ctx(), m_vector)); }
650  };
651 
652 
656  class sort : public ast {
657  public:
658  sort(context & c):ast(c) {}
659  sort(context & c, Z3_sort s):ast(c, reinterpret_cast<Z3_ast>(s)) {}
660  sort(context & c, Z3_ast a):ast(c, a) {}
661  operator Z3_sort() const { return reinterpret_cast<Z3_sort>(m_ast); }
662 
666  unsigned id() const { unsigned r = Z3_get_sort_id(ctx(), *this); check_error(); return r; }
667 
671  Z3_sort_kind sort_kind() const { return Z3_get_sort_kind(*m_ctx, *this); }
675  symbol name() const { Z3_symbol s = Z3_get_sort_name(ctx(), *this); check_error(); return symbol(ctx(), s); }
679  bool is_bool() const { return sort_kind() == Z3_BOOL_SORT; }
683  bool is_int() const { return sort_kind() == Z3_INT_SORT; }
687  bool is_real() const { return sort_kind() == Z3_REAL_SORT; }
691  bool is_arith() const { return is_int() || is_real(); }
695  bool is_bv() const { return sort_kind() == Z3_BV_SORT; }
699  bool is_array() const { return sort_kind() == Z3_ARRAY_SORT; }
703  bool is_datatype() const { return sort_kind() == Z3_DATATYPE_SORT; }
707  bool is_relation() const { return sort_kind() == Z3_RELATION_SORT; }
711  bool is_seq() const { return sort_kind() == Z3_SEQ_SORT; }
715  bool is_re() const { return sort_kind() == Z3_RE_SORT; }
719  bool is_finite_domain() const { return sort_kind() == Z3_FINITE_DOMAIN_SORT; }
723  bool is_fpa() const { return sort_kind() == Z3_FLOATING_POINT_SORT; }
724 
730  unsigned bv_size() const { assert(is_bv()); unsigned r = Z3_get_bv_sort_size(ctx(), *this); check_error(); return r; }
731 
732  unsigned fpa_ebits() const { assert(is_fpa()); unsigned r = Z3_fpa_get_ebits(ctx(), *this); check_error(); return r; }
733 
734  unsigned fpa_sbits() const { assert(is_fpa()); unsigned r = Z3_fpa_get_sbits(ctx(), *this); check_error(); return r; }
740  sort array_domain() const { assert(is_array()); Z3_sort s = Z3_get_array_sort_domain(ctx(), *this); check_error(); return sort(ctx(), s); }
746  sort array_range() const { assert(is_array()); Z3_sort s = Z3_get_array_sort_range(ctx(), *this); check_error(); return sort(ctx(), s); }
747 
748  friend std::ostream & operator<<(std::ostream & out, sort const & s) { return out << Z3_sort_to_string(s.ctx(), Z3_sort(s.m_ast)); }
749 
750  func_decl_vector constructors();
751  func_decl_vector recognizers();
752  };
753 
754 
759  class func_decl : public ast {
760  public:
761  func_decl(context & c):ast(c) {}
762  func_decl(context & c, Z3_func_decl n):ast(c, reinterpret_cast<Z3_ast>(n)) {}
763  operator Z3_func_decl() const { return reinterpret_cast<Z3_func_decl>(m_ast); }
764 
768  unsigned id() const { unsigned r = Z3_get_func_decl_id(ctx(), *this); check_error(); return r; }
769 
770  unsigned arity() const { return Z3_get_arity(ctx(), *this); }
771  sort domain(unsigned i) const { assert(i < arity()); Z3_sort r = Z3_get_domain(ctx(), *this, i); check_error(); return sort(ctx(), r); }
772  sort range() const { Z3_sort r = Z3_get_range(ctx(), *this); check_error(); return sort(ctx(), r); }
773  symbol name() const { Z3_symbol s = Z3_get_decl_name(ctx(), *this); check_error(); return symbol(ctx(), s); }
774  Z3_decl_kind decl_kind() const { return Z3_get_decl_kind(ctx(), *this); }
775  unsigned num_parameters() const { return Z3_get_decl_num_parameters(ctx(), *this); }
776 
777 
779  Z3_func_decl tc = Z3_mk_transitive_closure(ctx(), *this); check_error(); return func_decl(ctx(), tc);
780  }
781 
782  bool is_const() const { return arity() == 0; }
783 
784  expr operator()() const;
785  expr operator()(unsigned n, expr const * args) const;
786  expr operator()(expr_vector const& v) const;
787  expr operator()(expr const & a) const;
788  expr operator()(int a) const;
789  expr operator()(expr const & a1, expr const & a2) const;
790  expr operator()(expr const & a1, int a2) const;
791  expr operator()(int a1, expr const & a2) const;
792  expr operator()(expr const & a1, expr const & a2, expr const & a3) const;
793  expr operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4) const;
794  expr operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4, expr const & a5) const;
795 
796  func_decl_vector accessors();
797 
798  };
799 
803  expr select(expr const & a, expr const& i);
804  expr select(expr const & a, expr_vector const & i);
805 
810  class expr : public ast {
811  public:
812  expr(context & c):ast(c) {}
813  expr(context & c, Z3_ast n):ast(c, reinterpret_cast<Z3_ast>(n)) {}
814 
818  sort get_sort() const { Z3_sort s = Z3_get_sort(*m_ctx, m_ast); check_error(); return sort(*m_ctx, s); }
819 
823  bool is_bool() const { return get_sort().is_bool(); }
827  bool is_int() const { return get_sort().is_int(); }
831  bool is_real() const { return get_sort().is_real(); }
835  bool is_arith() const { return get_sort().is_arith(); }
839  bool is_bv() const { return get_sort().is_bv(); }
843  bool is_array() const { return get_sort().is_array(); }
847  bool is_datatype() const { return get_sort().is_datatype(); }
851  bool is_relation() const { return get_sort().is_relation(); }
855  bool is_seq() const { return get_sort().is_seq(); }
859  bool is_re() const { return get_sort().is_re(); }
860 
869  bool is_finite_domain() const { return get_sort().is_finite_domain(); }
873  bool is_fpa() const { return get_sort().is_fpa(); }
874 
880  bool is_numeral() const { return kind() == Z3_NUMERAL_AST; }
881  bool is_numeral_i64(int64_t& i) const { bool r = Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;}
882  bool is_numeral_u64(uint64_t& i) const { bool r = Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;}
883  bool is_numeral_i(int& i) const { bool r = Z3_get_numeral_int(ctx(), m_ast, &i); check_error(); return r;}
884  bool is_numeral_u(unsigned& i) const { bool r = Z3_get_numeral_uint(ctx(), m_ast, &i); check_error(); return r;}
885  bool is_numeral(std::string& s) const { if (!is_numeral()) return false; s = Z3_get_numeral_string(ctx(), m_ast); check_error(); return true; }
886  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; }
887  bool is_numeral(double& d) const { if (!is_numeral()) return false; d = Z3_get_numeral_double(ctx(), m_ast); check_error(); return true; }
888  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; }
889 
890  double as_double() const { double d = 0; is_numeral(d); return d; }
891  uint64_t as_uint64() const { uint64_t r = 0; is_numeral_u64(r); return r; }
892  int64_t as_int64() const { int64_t r = 0; is_numeral_i64(r); return r; }
893 
894 
898  bool is_app() const { return kind() == Z3_APP_AST || kind() == Z3_NUMERAL_AST; }
902  bool is_const() const { return is_app() && num_args() == 0; }
906  bool is_quantifier() const { return kind() == Z3_QUANTIFIER_AST; }
907 
911  bool is_forall() const { return Z3_is_quantifier_forall(ctx(), m_ast); }
915  bool is_exists() const { return Z3_is_quantifier_exists(ctx(), m_ast); }
919  bool is_lambda() const { return Z3_is_lambda(ctx(), m_ast); }
924  bool is_var() const { return kind() == Z3_VAR_AST; }
928  bool is_algebraic() const { return Z3_is_algebraic_number(ctx(), m_ast); }
929 
933  bool is_well_sorted() const { bool r = Z3_is_well_sorted(ctx(), m_ast); check_error(); return r; }
934 
938  expr mk_is_inf() const {
939  assert(is_fpa());
940  Z3_ast r = Z3_mk_fpa_is_infinite(ctx(), m_ast);
941  check_error();
942  return expr(ctx(), r);
943  }
944 
948  expr mk_is_nan() const {
949  assert(is_fpa());
950  Z3_ast r = Z3_mk_fpa_is_nan(ctx(), m_ast);
951  check_error();
952  return expr(ctx(), r);
953  }
954 
958  expr mk_is_normal() const {
959  assert(is_fpa());
960  Z3_ast r = Z3_mk_fpa_is_normal(ctx(), m_ast);
961  check_error();
962  return expr(ctx(), r);
963  }
964 
969  assert(is_fpa());
970  Z3_ast r = Z3_mk_fpa_is_subnormal(ctx(), m_ast);
971  check_error();
972  return expr(ctx(), r);
973  }
974 
978  expr mk_is_zero() const {
979  assert(is_fpa());
980  Z3_ast r = Z3_mk_fpa_is_zero(ctx(), m_ast);
981  check_error();
982  return expr(ctx(), r);
983  }
984 
988  expr mk_to_ieee_bv() const {
989  assert(is_fpa());
990  Z3_ast r = Z3_mk_fpa_to_ieee_bv(ctx(), m_ast);
991  check_error();
992  return expr(ctx(), r);
993  }
994 
998  expr mk_from_ieee_bv(sort const &s) const {
999  assert(is_bv());
1000  Z3_ast r = Z3_mk_fpa_to_fp_bv(ctx(), m_ast, s);
1001  check_error();
1002  return expr(ctx(), r);
1003  }
1004 
1011  std::string get_decimal_string(int precision) const {
1012  assert(is_numeral() || is_algebraic());
1013  return std::string(Z3_get_numeral_decimal_string(ctx(), m_ast, precision));
1014  }
1015 
1019  expr algebraic_lower(unsigned precision) const {
1020  assert(is_algebraic());
1021  Z3_ast r = Z3_get_algebraic_number_lower(ctx(), m_ast, precision);
1022  check_error();
1023  return expr(ctx(), r);
1024  }
1025 
1026  expr algebraic_upper(unsigned precision) const {
1027  assert(is_algebraic());
1028  Z3_ast r = Z3_get_algebraic_number_upper(ctx(), m_ast, precision);
1029  check_error();
1030  return expr(ctx(), r);
1031  }
1032 
1036  expr_vector algebraic_poly() const {
1037  assert(is_algebraic());
1038  Z3_ast_vector r = Z3_algebraic_get_poly(ctx(), m_ast);
1039  check_error();
1040  return expr_vector(ctx(), r);
1041  }
1042 
1046  unsigned algebraic_i() const {
1047  assert(is_algebraic());
1048  unsigned i = Z3_algebraic_get_i(ctx(), m_ast);
1049  check_error();
1050  return i;
1051  }
1052 
1056  unsigned id() const { unsigned r = Z3_get_ast_id(ctx(), m_ast); check_error(); return r; }
1057 
1068  int get_numeral_int() const {
1069  int result = 0;
1070  if (!is_numeral_i(result)) {
1071  assert(ctx().enable_exceptions());
1072  if (!ctx().enable_exceptions()) return 0;
1073  Z3_THROW(exception("numeral does not fit in machine int"));
1074  }
1075  return result;
1076  }
1077 
1087  unsigned get_numeral_uint() const {
1088  assert(is_numeral());
1089  unsigned result = 0;
1090  if (!is_numeral_u(result)) {
1091  assert(ctx().enable_exceptions());
1092  if (!ctx().enable_exceptions()) return 0;
1093  Z3_THROW(exception("numeral does not fit in machine uint"));
1094  }
1095  return result;
1096  }
1097 
1104  int64_t get_numeral_int64() const {
1105  assert(is_numeral());
1106  int64_t result = 0;
1107  if (!is_numeral_i64(result)) {
1108  assert(ctx().enable_exceptions());
1109  if (!ctx().enable_exceptions()) return 0;
1110  Z3_THROW(exception("numeral does not fit in machine int64_t"));
1111  }
1112  return result;
1113  }
1114 
1121  uint64_t get_numeral_uint64() const {
1122  assert(is_numeral());
1123  uint64_t result = 0;
1124  if (!is_numeral_u64(result)) {
1125  assert(ctx().enable_exceptions());
1126  if (!ctx().enable_exceptions()) return 0;
1127  Z3_THROW(exception("numeral does not fit in machine uint64_t"));
1128  }
1129  return result;
1130  }
1131 
1133  return Z3_get_bool_value(ctx(), m_ast);
1134  }
1135 
1136  expr numerator() const {
1137  assert(is_numeral());
1138  Z3_ast r = Z3_get_numerator(ctx(), m_ast);
1139  check_error();
1140  return expr(ctx(),r);
1141  }
1142 
1143 
1144  expr denominator() const {
1145  assert(is_numeral());
1146  Z3_ast r = Z3_get_denominator(ctx(), m_ast);
1147  check_error();
1148  return expr(ctx(),r);
1149  }
1150 
1151 
1156  bool is_string_value() const { return Z3_is_string(ctx(), m_ast); }
1157 
1163  std::string get_string() const {
1164  assert(is_string_value());
1165  char const* s = Z3_get_string(ctx(), m_ast);
1166  check_error();
1167  return std::string(s);
1168  }
1169 
1175  std::u32string get_u32string() const {
1176  assert(is_string_value());
1177  unsigned n = Z3_get_string_length(ctx(), m_ast);
1178  std::u32string s;
1179  s.resize(n);
1180  Z3_get_string_contents(ctx(), m_ast, n, (unsigned*)s.data());
1181  return s;
1182  }
1183 
1184  operator Z3_app() const { assert(is_app()); return reinterpret_cast<Z3_app>(m_ast); }
1185 
1192  func_decl decl() const { Z3_func_decl f = Z3_get_app_decl(ctx(), *this); check_error(); return func_decl(ctx(), f); }
1199  unsigned num_args() const { unsigned r = Z3_get_app_num_args(ctx(), *this); check_error(); return r; }
1207  expr arg(unsigned i) const { Z3_ast r = Z3_get_app_arg(ctx(), *this, i); check_error(); return expr(ctx(), r); }
1214  expr_vector args() const {
1215  expr_vector vec(ctx());
1216  unsigned argCnt = num_args();
1217  for (unsigned i = 0; i < argCnt; i++)
1218  vec.push_back(arg(i));
1219  return vec;
1220  }
1221 
1227  expr body() const { assert(is_quantifier()); Z3_ast r = Z3_get_quantifier_body(ctx(), *this); check_error(); return expr(ctx(), r); }
1228 
1234  friend expr operator!(expr const & a);
1235 
1242  friend expr operator&&(expr const & a, expr const & b);
1243 
1244 
1251  friend expr operator&&(expr const & a, bool b);
1258  friend expr operator&&(bool a, expr const & b);
1259 
1266  friend expr operator||(expr const & a, expr const & b);
1273  friend expr operator||(expr const & a, bool b);
1274 
1281  friend expr operator||(bool a, expr const & b);
1282 
1283  friend expr implies(expr const & a, expr const & b);
1284  friend expr implies(expr const & a, bool b);
1285  friend expr implies(bool a, expr const & b);
1286 
1287  friend expr mk_or(expr_vector const& args);
1288  friend expr mk_xor(expr_vector const& args);
1289  friend expr mk_and(expr_vector const& args);
1290 
1291  friend expr ite(expr const & c, expr const & t, expr const & e);
1292 
1293  bool is_true() const { return is_app() && Z3_OP_TRUE == decl().decl_kind(); }
1294  bool is_false() const { return is_app() && Z3_OP_FALSE == decl().decl_kind(); }
1295  bool is_not() const { return is_app() && Z3_OP_NOT == decl().decl_kind(); }
1296  bool is_and() const { return is_app() && Z3_OP_AND == decl().decl_kind(); }
1297  bool is_or() const { return is_app() && Z3_OP_OR == decl().decl_kind(); }
1298  bool is_xor() const { return is_app() && Z3_OP_XOR == decl().decl_kind(); }
1299  bool is_implies() const { return is_app() && Z3_OP_IMPLIES == decl().decl_kind(); }
1300  bool is_eq() const { return is_app() && Z3_OP_EQ == decl().decl_kind(); }
1301  bool is_ite() const { return is_app() && Z3_OP_ITE == decl().decl_kind(); }
1302  bool is_distinct() const { return is_app() && Z3_OP_DISTINCT == decl().decl_kind(); }
1303 
1304  friend expr distinct(expr_vector const& args);
1305  friend expr concat(expr const& a, expr const& b);
1306  friend expr concat(expr_vector const& args);
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 sum(expr_vector const& args);
1320 
1321  friend expr operator*(expr const & a, expr const & b);
1322  friend expr operator*(expr const & a, int b);
1323  friend expr operator*(int a, expr const & b);
1324 
1325  /* \brief Power operator */
1326  friend expr pw(expr const & a, expr const & b);
1327  friend expr pw(expr const & a, int b);
1328  friend expr pw(int a, expr const & b);
1329 
1330  /* \brief mod operator */
1331  friend expr mod(expr const& a, expr const& b);
1332  friend expr mod(expr const& a, int b);
1333  friend expr mod(int a, expr const& b);
1334 
1335  /* \brief rem operator */
1336  friend expr rem(expr const& a, expr const& b);
1337  friend expr rem(expr const& a, int b);
1338  friend expr rem(int a, expr const& b);
1339 
1340  friend expr is_int(expr const& e);
1341 
1342  friend expr operator/(expr const & a, expr const & b);
1343  friend expr operator/(expr const & a, int b);
1344  friend expr operator/(int a, expr const & b);
1345 
1346  friend expr operator-(expr const & a);
1347 
1348  friend expr operator-(expr const & a, expr const & b);
1349  friend expr operator-(expr const & a, int b);
1350  friend expr operator-(int a, expr const & b);
1351 
1352  friend expr operator<=(expr const & a, expr const & b);
1353  friend expr operator<=(expr const & a, int b);
1354  friend expr operator<=(int a, expr const & b);
1355 
1356 
1357  friend expr operator>=(expr const & a, expr const & b);
1358  friend expr operator>=(expr const & a, int b);
1359  friend expr operator>=(int a, expr const & b);
1360 
1361  friend expr operator<(expr const & a, expr const & b);
1362  friend expr operator<(expr const & a, int b);
1363  friend expr operator<(int a, expr const & b);
1364 
1365  friend expr operator>(expr const & a, expr const & b);
1366  friend expr operator>(expr const & a, int b);
1367  friend expr operator>(int a, expr const & b);
1368 
1369  friend expr pble(expr_vector const& es, int const * coeffs, int bound);
1370  friend expr pbge(expr_vector const& es, int const * coeffs, int bound);
1371  friend expr pbeq(expr_vector const& es, int const * coeffs, int bound);
1372  friend expr atmost(expr_vector const& es, unsigned bound);
1373  friend expr atleast(expr_vector const& es, unsigned bound);
1374 
1375  friend expr operator&(expr const & a, expr const & b);
1376  friend expr operator&(expr const & a, int b);
1377  friend expr operator&(int a, expr const & b);
1378 
1379  friend expr operator^(expr const & a, expr const & b);
1380  friend expr operator^(expr const & a, int b);
1381  friend expr operator^(int a, expr const & b);
1382 
1383  friend expr operator|(expr const & a, expr const & b);
1384  friend expr operator|(expr const & a, int b);
1385  friend expr operator|(int a, expr const & b);
1386  friend expr nand(expr const& a, expr const& b);
1387  friend expr nor(expr const& a, expr const& b);
1388  friend expr xnor(expr const& a, expr const& b);
1389 
1390  friend expr min(expr const& a, expr const& b);
1391  friend expr max(expr const& a, expr const& b);
1392 
1393  friend expr bv2int(expr const& a, bool is_signed);
1394  friend expr int2bv(unsigned n, expr const& a);
1395  friend expr bvadd_no_overflow(expr const& a, expr const& b, bool is_signed);
1396  friend expr bvadd_no_underflow(expr const& a, expr const& b);
1397  friend expr bvsub_no_overflow(expr const& a, expr const& b);
1398  friend expr bvsub_no_underflow(expr const& a, expr const& b, bool is_signed);
1399  friend expr bvsdiv_no_overflow(expr const& a, expr const& b);
1400  friend expr bvneg_no_overflow(expr const& a);
1401  friend expr bvmul_no_overflow(expr const& a, expr const& b, bool is_signed);
1402  friend expr bvmul_no_underflow(expr const& a, expr const& b);
1403 
1404  expr rotate_left(unsigned i) const { Z3_ast r = Z3_mk_rotate_left(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1405  expr rotate_right(unsigned i) const { Z3_ast r = Z3_mk_rotate_right(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1406  expr repeat(unsigned i) const { Z3_ast r = Z3_mk_repeat(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1407 
1408  friend expr bvredor(expr const & a);
1409  friend expr bvredand(expr const & a);
1410 
1411  friend expr abs(expr const & a);
1412  friend expr sqrt(expr const & a, expr const & rm);
1413  friend expr fp_eq(expr const & a, expr const & b);
1414 
1415  friend expr operator~(expr const & a);
1416  expr extract(unsigned hi, unsigned lo) const { Z3_ast r = Z3_mk_extract(ctx(), hi, lo, *this); ctx().check_error(); return expr(ctx(), r); }
1417  expr bit2bool(unsigned i) const { Z3_ast r = Z3_mk_bit2bool(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); }
1418  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)); }
1419  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)); }
1420 
1424  friend expr fma(expr const& a, expr const& b, expr const& c, expr const& rm);
1425 
1429  friend expr fpa_fp(expr const& sgn, expr const& exp, expr const& sig);
1430 
1434  friend expr fpa_to_sbv(expr const& t, unsigned sz);
1435 
1439  friend expr fpa_to_ubv(expr const& t, unsigned sz);
1440 
1444  friend expr sbv_to_fpa(expr const& t, sort s);
1445 
1449  friend expr ubv_to_fpa(expr const& t, sort s);
1450 
1454  friend expr fpa_to_fpa(expr const& t, sort s);
1455 
1459  friend expr round_fpa_to_closest_integer(expr const& t);
1460 
1466  expr extract(expr const& offset, expr const& length) const {
1467  check_context(*this, offset); check_context(offset, length);
1468  Z3_ast r = Z3_mk_seq_extract(ctx(), *this, offset, length); check_error(); return expr(ctx(), r);
1469  }
1470  expr replace(expr const& src, expr const& dst) const {
1471  check_context(*this, src); check_context(src, dst);
1472  Z3_ast r = Z3_mk_seq_replace(ctx(), *this, src, dst);
1473  check_error();
1474  return expr(ctx(), r);
1475  }
1476  expr unit() const {
1477  Z3_ast r = Z3_mk_seq_unit(ctx(), *this);
1478  check_error();
1479  return expr(ctx(), r);
1480  }
1481  expr contains(expr const& s) const {
1482  check_context(*this, s);
1483  Z3_ast r = Z3_mk_seq_contains(ctx(), *this, s);
1484  check_error();
1485  return expr(ctx(), r);
1486  }
1487  expr at(expr const& index) const {
1488  check_context(*this, index);
1489  Z3_ast r = Z3_mk_seq_at(ctx(), *this, index);
1490  check_error();
1491  return expr(ctx(), r);
1492  }
1493  expr nth(expr const& index) const {
1494  check_context(*this, index);
1495  Z3_ast r = Z3_mk_seq_nth(ctx(), *this, index);
1496  check_error();
1497  return expr(ctx(), r);
1498  }
1499  expr length() const {
1500  Z3_ast r = Z3_mk_seq_length(ctx(), *this);
1501  check_error();
1502  return expr(ctx(), r);
1503  }
1504  expr stoi() const {
1505  Z3_ast r = Z3_mk_str_to_int(ctx(), *this);
1506  check_error();
1507  return expr(ctx(), r);
1508  }
1509  expr itos() const {
1510  Z3_ast r = Z3_mk_int_to_str(ctx(), *this);
1511  check_error();
1512  return expr(ctx(), r);
1513  }
1514  expr ubvtos() const {
1515  Z3_ast r = Z3_mk_ubv_to_str(ctx(), *this);
1516  check_error();
1517  return expr(ctx(), r);
1518  }
1519  expr sbvtos() const {
1520  Z3_ast r = Z3_mk_sbv_to_str(ctx(), *this);
1521  check_error();
1522  return expr(ctx(), r);
1523  }
1524  expr char_to_int() const {
1525  Z3_ast r = Z3_mk_char_to_int(ctx(), *this);
1526  check_error();
1527  return expr(ctx(), r);
1528  }
1529  expr char_to_bv() const {
1530  Z3_ast r = Z3_mk_char_to_bv(ctx(), *this);
1531  check_error();
1532  return expr(ctx(), r);
1533  }
1534  expr char_from_bv() const {
1535  Z3_ast r = Z3_mk_char_from_bv(ctx(), *this);
1536  check_error();
1537  return expr(ctx(), r);
1538  }
1539  expr is_digit() const {
1540  Z3_ast r = Z3_mk_char_is_digit(ctx(), *this);
1541  check_error();
1542  return expr(ctx(), r);
1543  }
1544 
1545  friend expr range(expr const& lo, expr const& hi);
1549  expr loop(unsigned lo) {
1550  Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, 0);
1551  check_error();
1552  return expr(ctx(), r);
1553  }
1554  expr loop(unsigned lo, unsigned hi) {
1555  Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, hi);
1556  check_error();
1557  return expr(ctx(), r);
1558  }
1559 
1563  expr operator[](expr const& index) const {
1564  assert(is_array() || is_seq());
1565  if (is_array()) {
1566  return select(*this, index);
1567  }
1568  return nth(index);
1569  }
1570 
1571  expr operator[](expr_vector const& index) const {
1572  return select(*this, index);
1573  }
1574 
1578  expr simplify() const { Z3_ast r = Z3_simplify(ctx(), m_ast); check_error(); return expr(ctx(), r); }
1582  expr simplify(params const & p) const { Z3_ast r = Z3_simplify_ex(ctx(), m_ast, p); check_error(); return expr(ctx(), r); }
1583 
1587  expr substitute(expr_vector const& src, expr_vector const& dst);
1588 
1592  expr substitute(expr_vector const& dst);
1593 
1597  expr substitute(func_decl_vector const& funs, expr_vector const& bodies);
1598 
1599 
1600  class iterator {
1601  expr& e;
1602  unsigned i;
1603  public:
1604  iterator(expr& e, unsigned i): e(e), i(i) {}
1605  bool operator==(iterator const& other) noexcept {
1606  return i == other.i;
1607  }
1608  bool operator!=(iterator const& other) noexcept {
1609  return i != other.i;
1610  }
1611  expr operator*() const { return e.arg(i); }
1612  iterator& operator++() { ++i; return *this; }
1613  iterator operator++(int) { assert(false); return *this; }
1614  };
1615 
1616  iterator begin() { return iterator(*this, 0); }
1617  iterator end() { return iterator(*this, is_app() ? num_args() : 0); }
1618 
1619  };
1620 
1621 #define _Z3_MK_BIN_(a, b, binop) \
1622  check_context(a, b); \
1623  Z3_ast r = binop(a.ctx(), a, b); \
1624  a.check_error(); \
1625  return expr(a.ctx(), r); \
1626 
1627 
1628  inline expr implies(expr const & a, expr const & b) {
1629  assert(a.is_bool() && b.is_bool());
1630  _Z3_MK_BIN_(a, b, Z3_mk_implies);
1631  }
1632  inline expr implies(expr const & a, bool b) { return implies(a, a.ctx().bool_val(b)); }
1633  inline expr implies(bool a, expr const & b) { return implies(b.ctx().bool_val(a), b); }
1634 
1635 
1636  inline expr pw(expr const & a, expr const & b) { _Z3_MK_BIN_(a, b, Z3_mk_power); }
1637  inline expr pw(expr const & a, int b) { return pw(a, a.ctx().num_val(b, a.get_sort())); }
1638  inline expr pw(int a, expr const & b) { return pw(b.ctx().num_val(a, b.get_sort()), b); }
1639 
1640  inline expr mod(expr const& a, expr const& b) {
1641  if (a.is_bv()) {
1642  _Z3_MK_BIN_(a, b, Z3_mk_bvsmod);
1643  }
1644  else {
1645  _Z3_MK_BIN_(a, b, Z3_mk_mod);
1646  }
1647  }
1648  inline expr mod(expr const & a, int b) { return mod(a, a.ctx().num_val(b, a.get_sort())); }
1649  inline expr mod(int a, expr const & b) { return mod(b.ctx().num_val(a, b.get_sort()), b); }
1650 
1651  inline expr operator%(expr const& a, expr const& b) { return mod(a, b); }
1652  inline expr operator%(expr const& a, int b) { return mod(a, b); }
1653  inline expr operator%(int a, expr const& b) { return mod(a, b); }
1654 
1655 
1656  inline expr rem(expr const& a, expr const& b) {
1657  if (a.is_fpa() && b.is_fpa()) {
1658  _Z3_MK_BIN_(a, b, Z3_mk_fpa_rem);
1659  } else {
1660  _Z3_MK_BIN_(a, b, Z3_mk_rem);
1661  }
1662  }
1663  inline expr rem(expr const & a, int b) { return rem(a, a.ctx().num_val(b, a.get_sort())); }
1664  inline expr rem(int a, expr const & b) { return rem(b.ctx().num_val(a, b.get_sort()), b); }
1665 
1666 #undef _Z3_MK_BIN_
1667 
1668 #define _Z3_MK_UN_(a, mkun) \
1669  Z3_ast r = mkun(a.ctx(), a); \
1670  a.check_error(); \
1671  return expr(a.ctx(), r); \
1672 
1673 
1674  inline expr operator!(expr const & a) { assert(a.is_bool()); _Z3_MK_UN_(a, Z3_mk_not); }
1675 
1676  inline expr is_int(expr const& e) { _Z3_MK_UN_(e, Z3_mk_is_int); }
1677 
1678 #undef _Z3_MK_UN_
1679 
1680  inline expr operator&&(expr const & a, expr const & b) {
1681  check_context(a, b);
1682  assert(a.is_bool() && b.is_bool());
1683  Z3_ast args[2] = { a, b };
1684  Z3_ast r = Z3_mk_and(a.ctx(), 2, args);
1685  a.check_error();
1686  return expr(a.ctx(), r);
1687  }
1688 
1689  inline expr operator&&(expr const & a, bool b) { return a && a.ctx().bool_val(b); }
1690  inline expr operator&&(bool a, expr const & b) { return b.ctx().bool_val(a) && b; }
1691 
1692  inline expr operator||(expr const & a, expr const & b) {
1693  check_context(a, b);
1694  assert(a.is_bool() && b.is_bool());
1695  Z3_ast args[2] = { a, b };
1696  Z3_ast r = Z3_mk_or(a.ctx(), 2, args);
1697  a.check_error();
1698  return expr(a.ctx(), r);
1699  }
1700 
1701  inline expr operator||(expr const & a, bool b) { return a || a.ctx().bool_val(b); }
1702 
1703  inline expr operator||(bool a, expr const & b) { return b.ctx().bool_val(a) || b; }
1704 
1705  inline expr operator==(expr const & a, expr const & b) {
1706  check_context(a, b);
1707  Z3_ast r = Z3_mk_eq(a.ctx(), a, b);
1708  a.check_error();
1709  return expr(a.ctx(), r);
1710  }
1711  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()); }
1712  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; }
1713  inline expr operator==(expr const & a, double b) { assert(a.is_fpa()); return a == a.ctx().fpa_val(b); }
1714  inline expr operator==(double a, expr const & b) { assert(b.is_fpa()); return b.ctx().fpa_val(a) == b; }
1715 
1716  inline expr operator!=(expr const & a, expr const & b) {
1717  check_context(a, b);
1718  Z3_ast args[2] = { a, b };
1719  Z3_ast r = Z3_mk_distinct(a.ctx(), 2, args);
1720  a.check_error();
1721  return expr(a.ctx(), r);
1722  }
1723  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()); }
1724  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; }
1725  inline expr operator!=(expr const & a, double b) { assert(a.is_fpa()); return a != a.ctx().fpa_val(b); }
1726  inline expr operator!=(double a, expr const & b) { assert(b.is_fpa()); return b.ctx().fpa_val(a) != b; }
1727 
1728  inline expr operator+(expr const & a, expr const & b) {
1729  check_context(a, b);
1730  Z3_ast r = 0;
1731  if (a.is_arith() && b.is_arith()) {
1732  Z3_ast args[2] = { a, b };
1733  r = Z3_mk_add(a.ctx(), 2, args);
1734  }
1735  else if (a.is_bv() && b.is_bv()) {
1736  r = Z3_mk_bvadd(a.ctx(), a, b);
1737  }
1738  else if (a.is_seq() && b.is_seq()) {
1739  return concat(a, b);
1740  }
1741  else if (a.is_re() && b.is_re()) {
1742  Z3_ast _args[2] = { a, b };
1743  r = Z3_mk_re_union(a.ctx(), 2, _args);
1744  }
1745  else if (a.is_fpa() && b.is_fpa()) {
1746  r = Z3_mk_fpa_add(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1747  }
1748  else {
1749  // operator is not supported by given arguments.
1750  assert(false);
1751  }
1752  a.check_error();
1753  return expr(a.ctx(), r);
1754  }
1755  inline expr operator+(expr const & a, int b) { return a + a.ctx().num_val(b, a.get_sort()); }
1756  inline expr operator+(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) + b; }
1757 
1758  inline expr operator*(expr const & a, expr const & b) {
1759  check_context(a, b);
1760  Z3_ast r = 0;
1761  if (a.is_arith() && b.is_arith()) {
1762  Z3_ast args[2] = { a, b };
1763  r = Z3_mk_mul(a.ctx(), 2, args);
1764  }
1765  else if (a.is_bv() && b.is_bv()) {
1766  r = Z3_mk_bvmul(a.ctx(), a, b);
1767  }
1768  else if (a.is_fpa() && b.is_fpa()) {
1769  r = Z3_mk_fpa_mul(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1770  }
1771  else {
1772  // operator is not supported by given arguments.
1773  assert(false);
1774  }
1775  a.check_error();
1776  return expr(a.ctx(), r);
1777  }
1778  inline expr operator*(expr const & a, int b) { return a * a.ctx().num_val(b, a.get_sort()); }
1779  inline expr operator*(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) * b; }
1780 
1781 
1782  inline expr operator>=(expr const & a, expr const & b) {
1783  check_context(a, b);
1784  Z3_ast r = 0;
1785  if (a.is_arith() && b.is_arith()) {
1786  r = Z3_mk_ge(a.ctx(), a, b);
1787  }
1788  else if (a.is_bv() && b.is_bv()) {
1789  r = Z3_mk_bvsge(a.ctx(), a, b);
1790  }
1791  else if (a.is_fpa() && b.is_fpa()) {
1792  r = Z3_mk_fpa_geq(a.ctx(), a, b);
1793  }
1794  else {
1795  // operator is not supported by given arguments.
1796  assert(false);
1797  }
1798  a.check_error();
1799  return expr(a.ctx(), r);
1800  }
1801 
1802  inline expr operator/(expr const & a, expr const & b) {
1803  check_context(a, b);
1804  Z3_ast r = 0;
1805  if (a.is_arith() && b.is_arith()) {
1806  r = Z3_mk_div(a.ctx(), a, b);
1807  }
1808  else if (a.is_bv() && b.is_bv()) {
1809  r = Z3_mk_bvsdiv(a.ctx(), a, b);
1810  }
1811  else if (a.is_fpa() && b.is_fpa()) {
1812  r = Z3_mk_fpa_div(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1813  }
1814  else {
1815  // operator is not supported by given arguments.
1816  assert(false);
1817  }
1818  a.check_error();
1819  return expr(a.ctx(), r);
1820  }
1821  inline expr operator/(expr const & a, int b) { return a / a.ctx().num_val(b, a.get_sort()); }
1822  inline expr operator/(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) / b; }
1823 
1824  inline expr operator-(expr const & a) {
1825  Z3_ast r = 0;
1826  if (a.is_arith()) {
1827  r = Z3_mk_unary_minus(a.ctx(), a);
1828  }
1829  else if (a.is_bv()) {
1830  r = Z3_mk_bvneg(a.ctx(), a);
1831  }
1832  else if (a.is_fpa()) {
1833  r = Z3_mk_fpa_neg(a.ctx(), a);
1834  }
1835  else {
1836  // operator is not supported by given arguments.
1837  assert(false);
1838  }
1839  a.check_error();
1840  return expr(a.ctx(), r);
1841  }
1842 
1843  inline expr operator-(expr const & a, expr const & b) {
1844  check_context(a, b);
1845  Z3_ast r = 0;
1846  if (a.is_arith() && b.is_arith()) {
1847  Z3_ast args[2] = { a, b };
1848  r = Z3_mk_sub(a.ctx(), 2, args);
1849  }
1850  else if (a.is_bv() && b.is_bv()) {
1851  r = Z3_mk_bvsub(a.ctx(), a, b);
1852  }
1853  else if (a.is_fpa() && b.is_fpa()) {
1854  r = Z3_mk_fpa_sub(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1855  }
1856  else {
1857  // operator is not supported by given arguments.
1858  assert(false);
1859  }
1860  a.check_error();
1861  return expr(a.ctx(), r);
1862  }
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) {
1867  check_context(a, b);
1868  Z3_ast r = 0;
1869  if (a.is_arith() && b.is_arith()) {
1870  r = Z3_mk_le(a.ctx(), a, b);
1871  }
1872  else if (a.is_bv() && b.is_bv()) {
1873  r = Z3_mk_bvsle(a.ctx(), a, b);
1874  }
1875  else if (a.is_fpa() && b.is_fpa()) {
1876  r = Z3_mk_fpa_leq(a.ctx(), a, b);
1877  }
1878  else {
1879  // operator is not supported by given arguments.
1880  assert(false);
1881  }
1882  a.check_error();
1883  return expr(a.ctx(), r);
1884  }
1885  inline expr operator<=(expr const & a, int b) { return a <= a.ctx().num_val(b, a.get_sort()); }
1886  inline expr operator<=(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) <= b; }
1887 
1888  inline expr operator>=(expr const & a, int b) { return a >= a.ctx().num_val(b, a.get_sort()); }
1889  inline expr operator>=(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) >= b; }
1890 
1891  inline expr operator<(expr const & a, expr const & b) {
1892  check_context(a, b);
1893  Z3_ast r = 0;
1894  if (a.is_arith() && b.is_arith()) {
1895  r = Z3_mk_lt(a.ctx(), a, b);
1896  }
1897  else if (a.is_bv() && b.is_bv()) {
1898  r = Z3_mk_bvslt(a.ctx(), a, b);
1899  }
1900  else if (a.is_fpa() && b.is_fpa()) {
1901  r = Z3_mk_fpa_lt(a.ctx(), a, b);
1902  }
1903  else {
1904  // operator is not supported by given arguments.
1905  assert(false);
1906  }
1907  a.check_error();
1908  return expr(a.ctx(), r);
1909  }
1910  inline expr operator<(expr const & a, int b) { return a < a.ctx().num_val(b, a.get_sort()); }
1911  inline expr operator<(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) < b; }
1912 
1913  inline expr operator>(expr const & a, expr const & b) {
1914  check_context(a, b);
1915  Z3_ast r = 0;
1916  if (a.is_arith() && b.is_arith()) {
1917  r = Z3_mk_gt(a.ctx(), a, b);
1918  }
1919  else if (a.is_bv() && b.is_bv()) {
1920  r = Z3_mk_bvsgt(a.ctx(), a, b);
1921  }
1922  else if (a.is_fpa() && b.is_fpa()) {
1923  r = Z3_mk_fpa_gt(a.ctx(), a, b);
1924  }
1925  else {
1926  // operator is not supported by given arguments.
1927  assert(false);
1928  }
1929  a.check_error();
1930  return expr(a.ctx(), r);
1931  }
1932  inline expr operator>(expr const & a, int b) { return a > a.ctx().num_val(b, a.get_sort()); }
1933  inline expr operator>(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) > b; }
1934 
1935  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); a.check_error(); return expr(a.ctx(), r); }
1936  inline expr operator&(expr const & a, int b) { return a & a.ctx().num_val(b, a.get_sort()); }
1937  inline expr operator&(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) & b; }
1938 
1939  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); a.check_error(); return expr(a.ctx(), r); }
1940  inline expr operator^(expr const & a, int b) { return a ^ a.ctx().num_val(b, a.get_sort()); }
1941  inline expr operator^(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) ^ b; }
1942 
1943  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); a.check_error(); return expr(a.ctx(), r); }
1944  inline expr operator|(expr const & a, int b) { return a | a.ctx().num_val(b, a.get_sort()); }
1945  inline expr operator|(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) | b; }
1946 
1947  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); a.check_error(); return expr(a.ctx(), r); }
1948  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); a.check_error(); return expr(a.ctx(), r); }
1949  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); a.check_error(); return expr(a.ctx(), r); }
1950  inline expr min(expr const& a, expr const& b) {
1951  check_context(a, b);
1952  Z3_ast r;
1953  if (a.is_arith()) {
1954  r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), b, a);
1955  }
1956  else if (a.is_bv()) {
1957  r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), b, a);
1958  }
1959  else {
1960  assert(a.is_fpa());
1961  r = Z3_mk_fpa_min(a.ctx(), a, b);
1962  }
1963  a.check_error();
1964  return expr(a.ctx(), r);
1965  }
1966  inline expr max(expr const& a, expr const& b) {
1967  check_context(a, b);
1968  Z3_ast r;
1969  if (a.is_arith()) {
1970  r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), a, b);
1971  }
1972  else if (a.is_bv()) {
1973  r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), a, b);
1974  }
1975  else {
1976  assert(a.is_fpa());
1977  r = Z3_mk_fpa_max(a.ctx(), a, b);
1978  }
1979  a.check_error();
1980  return expr(a.ctx(), r);
1981  }
1982  inline expr bvredor(expr const & a) {
1983  assert(a.is_bv());
1984  Z3_ast r = Z3_mk_bvredor(a.ctx(), a);
1985  a.check_error();
1986  return expr(a.ctx(), r);
1987  }
1988  inline expr bvredand(expr const & a) {
1989  assert(a.is_bv());
1990  Z3_ast r = Z3_mk_bvredand(a.ctx(), a);
1991  a.check_error();
1992  return expr(a.ctx(), r);
1993  }
1994  inline expr abs(expr const & a) {
1995  Z3_ast r;
1996  if (a.is_int()) {
1997  expr zero = a.ctx().int_val(0);
1998  expr ge = a >= zero;
1999  expr na = -a;
2000  r = Z3_mk_ite(a.ctx(), ge, a, na);
2001  }
2002  else if (a.is_real()) {
2003  expr zero = a.ctx().real_val(0);
2004  expr ge = a >= zero;
2005  expr na = -a;
2006  r = Z3_mk_ite(a.ctx(), ge, a, na);
2007  }
2008  else {
2009  r = Z3_mk_fpa_abs(a.ctx(), a);
2010  }
2011  a.check_error();
2012  return expr(a.ctx(), r);
2013  }
2014  inline expr sqrt(expr const & a, expr const& rm) {
2015  check_context(a, rm);
2016  assert(a.is_fpa());
2017  Z3_ast r = Z3_mk_fpa_sqrt(a.ctx(), rm, a);
2018  a.check_error();
2019  return expr(a.ctx(), r);
2020  }
2021  inline expr fp_eq(expr const & a, expr const & b) {
2022  check_context(a, b);
2023  assert(a.is_fpa());
2024  Z3_ast r = Z3_mk_fpa_eq(a.ctx(), a, b);
2025  a.check_error();
2026  return expr(a.ctx(), r);
2027  }
2028  inline expr operator~(expr const & a) { Z3_ast r = Z3_mk_bvnot(a.ctx(), a); return expr(a.ctx(), r); }
2029 
2030  inline expr fma(expr const& a, expr const& b, expr const& c, expr const& rm) {
2031  check_context(a, b); check_context(a, c); check_context(a, rm);
2032  assert(a.is_fpa() && b.is_fpa() && c.is_fpa());
2033  Z3_ast r = Z3_mk_fpa_fma(a.ctx(), rm, a, b, c);
2034  a.check_error();
2035  return expr(a.ctx(), r);
2036  }
2037 
2038  inline expr fpa_fp(expr const& sgn, expr const& exp, expr const& sig) {
2039  check_context(sgn, exp); check_context(exp, sig);
2040  assert(sgn.is_bv() && exp.is_bv() && sig.is_bv());
2041  Z3_ast r = Z3_mk_fpa_fp(sgn.ctx(), sgn, exp, sig);
2042  sgn.check_error();
2043  return expr(sgn.ctx(), r);
2044  }
2045 
2046  inline expr fpa_to_sbv(expr const& t, unsigned sz) {
2047  assert(t.is_fpa());
2048  Z3_ast r = Z3_mk_fpa_to_sbv(t.ctx(), t.ctx().fpa_rounding_mode(), t, sz);
2049  t.check_error();
2050  return expr(t.ctx(), r);
2051  }
2052 
2053  inline expr fpa_to_ubv(expr const& t, unsigned sz) {
2054  assert(t.is_fpa());
2055  Z3_ast r = Z3_mk_fpa_to_ubv(t.ctx(), t.ctx().fpa_rounding_mode(), t, sz);
2056  t.check_error();
2057  return expr(t.ctx(), r);
2058  }
2059 
2060  inline expr sbv_to_fpa(expr const& t, sort s) {
2061  assert(t.is_bv());
2062  Z3_ast r = Z3_mk_fpa_to_fp_signed(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2063  t.check_error();
2064  return expr(t.ctx(), r);
2065  }
2066 
2067  inline expr ubv_to_fpa(expr const& t, sort s) {
2068  assert(t.is_bv());
2069  Z3_ast r = Z3_mk_fpa_to_fp_unsigned(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2070  t.check_error();
2071  return expr(t.ctx(), r);
2072  }
2073 
2074  inline expr fpa_to_fpa(expr const& t, sort s) {
2075  assert(t.is_fpa());
2076  Z3_ast r = Z3_mk_fpa_to_fp_float(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2077  t.check_error();
2078  return expr(t.ctx(), r);
2079  }
2080 
2082  assert(t.is_fpa());
2083  Z3_ast r = Z3_mk_fpa_round_to_integral(t.ctx(), t.ctx().fpa_rounding_mode(), t);
2084  t.check_error();
2085  return expr(t.ctx(), r);
2086  }
2087 
2093  inline expr ite(expr const & c, expr const & t, expr const & e) {
2094  check_context(c, t); check_context(c, e);
2095  assert(c.is_bool());
2096  Z3_ast r = Z3_mk_ite(c.ctx(), c, t, e);
2097  c.check_error();
2098  return expr(c.ctx(), r);
2099  }
2100 
2101 
2106  inline expr to_expr(context & c, Z3_ast a) {
2107  c.check_error();
2108  assert(Z3_get_ast_kind(c, a) == Z3_APP_AST ||
2109  Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST ||
2110  Z3_get_ast_kind(c, a) == Z3_VAR_AST ||
2112  return expr(c, a);
2113  }
2114 
2115  inline sort to_sort(context & c, Z3_sort s) {
2116  c.check_error();
2117  return sort(c, s);
2118  }
2119 
2120  inline func_decl to_func_decl(context & c, Z3_func_decl f) {
2121  c.check_error();
2122  return func_decl(c, f);
2123  }
2124 
2128  inline expr sle(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsle(a.ctx(), a, b)); }
2129  inline expr sle(expr const & a, int b) { return sle(a, a.ctx().num_val(b, a.get_sort())); }
2130  inline expr sle(int a, expr const & b) { return sle(b.ctx().num_val(a, b.get_sort()), b); }
2134  inline expr slt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvslt(a.ctx(), a, b)); }
2135  inline expr slt(expr const & a, int b) { return slt(a, a.ctx().num_val(b, a.get_sort())); }
2136  inline expr slt(int a, expr const & b) { return slt(b.ctx().num_val(a, b.get_sort()), b); }
2140  inline expr sge(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsge(a.ctx(), a, b)); }
2141  inline expr sge(expr const & a, int b) { return sge(a, a.ctx().num_val(b, a.get_sort())); }
2142  inline expr sge(int a, expr const & b) { return sge(b.ctx().num_val(a, b.get_sort()), b); }
2146  inline expr sgt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsgt(a.ctx(), a, b)); }
2147  inline expr sgt(expr const & a, int b) { return sgt(a, a.ctx().num_val(b, a.get_sort())); }
2148  inline expr sgt(int a, expr const & b) { return sgt(b.ctx().num_val(a, b.get_sort()), b); }
2149 
2150 
2154  inline expr ule(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvule(a.ctx(), a, b)); }
2155  inline expr ule(expr const & a, int b) { return ule(a, a.ctx().num_val(b, a.get_sort())); }
2156  inline expr ule(int a, expr const & b) { return ule(b.ctx().num_val(a, b.get_sort()), b); }
2160  inline expr ult(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvult(a.ctx(), a, b)); }
2161  inline expr ult(expr const & a, int b) { return ult(a, a.ctx().num_val(b, a.get_sort())); }
2162  inline expr ult(int a, expr const & b) { return ult(b.ctx().num_val(a, b.get_sort()), b); }
2166  inline expr uge(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b)); }
2167  inline expr uge(expr const & a, int b) { return uge(a, a.ctx().num_val(b, a.get_sort())); }
2168  inline expr uge(int a, expr const & b) { return uge(b.ctx().num_val(a, b.get_sort()), b); }
2172  inline expr ugt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvugt(a.ctx(), a, b)); }
2173  inline expr ugt(expr const & a, int b) { return ugt(a, a.ctx().num_val(b, a.get_sort())); }
2174  inline expr ugt(int a, expr const & b) { return ugt(b.ctx().num_val(a, b.get_sort()), b); }
2178  inline expr udiv(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvudiv(a.ctx(), a, b)); }
2179  inline expr udiv(expr const & a, int b) { return udiv(a, a.ctx().num_val(b, a.get_sort())); }
2180  inline expr udiv(int a, expr const & b) { return udiv(b.ctx().num_val(a, b.get_sort()), b); }
2181 
2185  inline expr srem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsrem(a.ctx(), a, b)); }
2186  inline expr srem(expr const & a, int b) { return srem(a, a.ctx().num_val(b, a.get_sort())); }
2187  inline expr srem(int a, expr const & b) { return srem(b.ctx().num_val(a, b.get_sort()), b); }
2188 
2192  inline expr smod(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsmod(a.ctx(), a, b)); }
2193  inline expr smod(expr const & a, int b) { return smod(a, a.ctx().num_val(b, a.get_sort())); }
2194  inline expr smod(int a, expr const & b) { return smod(b.ctx().num_val(a, b.get_sort()), b); }
2195 
2199  inline expr urem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvurem(a.ctx(), a, b)); }
2200  inline expr urem(expr const & a, int b) { return urem(a, a.ctx().num_val(b, a.get_sort())); }
2201  inline expr urem(int a, expr const & b) { return urem(b.ctx().num_val(a, b.get_sort()), b); }
2202 
2206  inline expr shl(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvshl(a.ctx(), a, b)); }
2207  inline expr shl(expr const & a, int b) { return shl(a, a.ctx().num_val(b, a.get_sort())); }
2208  inline expr shl(int a, expr const & b) { return shl(b.ctx().num_val(a, b.get_sort()), b); }
2209 
2213  inline expr lshr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvlshr(a.ctx(), a, b)); }
2214  inline expr lshr(expr const & a, int b) { return lshr(a, a.ctx().num_val(b, a.get_sort())); }
2215  inline expr lshr(int a, expr const & b) { return lshr(b.ctx().num_val(a, b.get_sort()), b); }
2216 
2220  inline expr ashr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvashr(a.ctx(), a, b)); }
2221  inline expr ashr(expr const & a, int b) { return ashr(a, a.ctx().num_val(b, a.get_sort())); }
2222  inline expr ashr(int a, expr const & b) { return ashr(b.ctx().num_val(a, b.get_sort()), b); }
2223 
2227  inline expr zext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_zero_ext(a.ctx(), i, a)); }
2228 
2232  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); }
2233  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); }
2234 
2238  inline expr bvadd_no_overflow(expr const& a, expr const& b, bool is_signed) {
2239  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);
2240  }
2241  inline expr bvadd_no_underflow(expr const& a, expr const& b) {
2242  check_context(a, b); Z3_ast r = Z3_mk_bvadd_no_underflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2243  }
2244  inline expr bvsub_no_overflow(expr const& a, expr const& b) {
2245  check_context(a, b); Z3_ast r = Z3_mk_bvsub_no_overflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2246  }
2247  inline expr bvsub_no_underflow(expr const& a, expr const& b, bool is_signed) {
2248  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);
2249  }
2250  inline expr bvsdiv_no_overflow(expr const& a, expr const& b) {
2251  check_context(a, b); Z3_ast r = Z3_mk_bvsdiv_no_overflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2252  }
2253  inline expr bvneg_no_overflow(expr const& a) {
2254  Z3_ast r = Z3_mk_bvneg_no_overflow(a.ctx(), a); a.check_error(); return expr(a.ctx(), r);
2255  }
2256  inline expr bvmul_no_overflow(expr const& a, expr const& b, bool is_signed) {
2257  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);
2258  }
2259  inline expr bvmul_no_underflow(expr const& a, expr const& b) {
2260  check_context(a, b); Z3_ast r = Z3_mk_bvmul_no_underflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2261  }
2262 
2263 
2267  inline expr sext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_sign_ext(a.ctx(), i, a)); }
2268 
2269  inline func_decl linear_order(sort const& a, unsigned index) {
2270  return to_func_decl(a.ctx(), Z3_mk_linear_order(a.ctx(), a, index));
2271  }
2272  inline func_decl partial_order(sort const& a, unsigned index) {
2273  return to_func_decl(a.ctx(), Z3_mk_partial_order(a.ctx(), a, index));
2274  }
2275  inline func_decl piecewise_linear_order(sort const& a, unsigned index) {
2276  return to_func_decl(a.ctx(), Z3_mk_piecewise_linear_order(a.ctx(), a, index));
2277  }
2278  inline func_decl tree_order(sort const& a, unsigned index) {
2279  return to_func_decl(a.ctx(), Z3_mk_tree_order(a.ctx(), a, index));
2280  }
2281 
2282  template<> class cast_ast<ast> {
2283  public:
2284  ast operator()(context & c, Z3_ast a) { return ast(c, a); }
2285  };
2286 
2287  template<> class cast_ast<expr> {
2288  public:
2289  expr operator()(context & c, Z3_ast a) {
2290  assert(Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST ||
2291  Z3_get_ast_kind(c, a) == Z3_APP_AST ||
2293  Z3_get_ast_kind(c, a) == Z3_VAR_AST);
2294  return expr(c, a);
2295  }
2296  };
2297 
2298  template<> class cast_ast<sort> {
2299  public:
2300  sort operator()(context & c, Z3_ast a) {
2301  assert(Z3_get_ast_kind(c, a) == Z3_SORT_AST);
2302  return sort(c, reinterpret_cast<Z3_sort>(a));
2303  }
2304  };
2305 
2306  template<> class cast_ast<func_decl> {
2307  public:
2308  func_decl operator()(context & c, Z3_ast a) {
2309  assert(Z3_get_ast_kind(c, a) == Z3_FUNC_DECL_AST);
2310  return func_decl(c, reinterpret_cast<Z3_func_decl>(a));
2311  }
2312  };
2313 
2314  template<typename T>
2315  template<typename T2>
2316  array<T>::array(ast_vector_tpl<T2> const & v):m_array(new T[v.size()]), m_size(v.size()) {
2317  for (unsigned i = 0; i < m_size; i++) {
2318  m_array[i] = v[i];
2319  }
2320  }
2321 
2322  // Basic functions for creating quantified formulas.
2323  // The C API should be used for creating quantifiers with patterns, weights, many variables, etc.
2324  inline expr forall(expr const & x, expr const & b) {
2325  check_context(x, b);
2326  Z3_app vars[] = {(Z3_app) x};
2327  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 1, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2328  }
2329  inline expr forall(expr const & x1, expr const & x2, expr const & b) {
2330  check_context(x1, b); check_context(x2, b);
2331  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2332  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 2, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2333  }
2334  inline expr forall(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2335  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2336  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2337  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 3, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2338  }
2339  inline expr forall(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2340  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2341  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2342  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 4, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2343  }
2344  inline expr forall(expr_vector const & xs, expr const & b) {
2345  array<Z3_app> vars(xs);
2346  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);
2347  }
2348  inline expr exists(expr const & x, expr const & b) {
2349  check_context(x, b);
2350  Z3_app vars[] = {(Z3_app) x};
2351  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 1, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2352  }
2353  inline expr exists(expr const & x1, expr const & x2, expr const & b) {
2354  check_context(x1, b); check_context(x2, b);
2355  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2356  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 2, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2357  }
2358  inline expr exists(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2359  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2360  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2361  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 3, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2362  }
2363  inline expr exists(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2364  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2365  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2366  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 4, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2367  }
2368  inline expr exists(expr_vector const & xs, expr const & b) {
2369  array<Z3_app> vars(xs);
2370  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);
2371  }
2372  inline expr lambda(expr const & x, expr const & b) {
2373  check_context(x, b);
2374  Z3_app vars[] = {(Z3_app) x};
2375  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 1, vars, b); b.check_error(); return expr(b.ctx(), r);
2376  }
2377  inline expr lambda(expr const & x1, expr const & x2, expr const & b) {
2378  check_context(x1, b); check_context(x2, b);
2379  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2380  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 2, vars, b); b.check_error(); return expr(b.ctx(), r);
2381  }
2382  inline expr lambda(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2383  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2384  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2385  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 3, vars, b); b.check_error(); return expr(b.ctx(), r);
2386  }
2387  inline expr lambda(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2388  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2389  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2390  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 4, vars, b); b.check_error(); return expr(b.ctx(), r);
2391  }
2392  inline expr lambda(expr_vector const & xs, expr const & b) {
2393  array<Z3_app> vars(xs);
2394  Z3_ast r = Z3_mk_lambda_const(b.ctx(), vars.size(), vars.ptr(), b); b.check_error(); return expr(b.ctx(), r);
2395  }
2396 
2397  inline expr pble(expr_vector const& es, int const* coeffs, int bound) {
2398  assert(es.size() > 0);
2399  context& ctx = es[0u].ctx();
2400  array<Z3_ast> _es(es);
2401  Z3_ast r = Z3_mk_pble(ctx, _es.size(), _es.ptr(), coeffs, bound);
2402  ctx.check_error();
2403  return expr(ctx, r);
2404  }
2405  inline expr pbge(expr_vector const& es, int const* coeffs, int bound) {
2406  assert(es.size() > 0);
2407  context& ctx = es[0u].ctx();
2408  array<Z3_ast> _es(es);
2409  Z3_ast r = Z3_mk_pbge(ctx, _es.size(), _es.ptr(), coeffs, bound);
2410  ctx.check_error();
2411  return expr(ctx, r);
2412  }
2413  inline expr pbeq(expr_vector const& es, int const* coeffs, int bound) {
2414  assert(es.size() > 0);
2415  context& ctx = es[0u].ctx();
2416  array<Z3_ast> _es(es);
2417  Z3_ast r = Z3_mk_pbeq(ctx, _es.size(), _es.ptr(), coeffs, bound);
2418  ctx.check_error();
2419  return expr(ctx, r);
2420  }
2421  inline expr atmost(expr_vector const& es, unsigned bound) {
2422  assert(es.size() > 0);
2423  context& ctx = es[0u].ctx();
2424  array<Z3_ast> _es(es);
2425  Z3_ast r = Z3_mk_atmost(ctx, _es.size(), _es.ptr(), bound);
2426  ctx.check_error();
2427  return expr(ctx, r);
2428  }
2429  inline expr atleast(expr_vector const& es, unsigned bound) {
2430  assert(es.size() > 0);
2431  context& ctx = es[0u].ctx();
2432  array<Z3_ast> _es(es);
2433  Z3_ast r = Z3_mk_atleast(ctx, _es.size(), _es.ptr(), bound);
2434  ctx.check_error();
2435  return expr(ctx, r);
2436  }
2437  inline expr sum(expr_vector const& args) {
2438  assert(args.size() > 0);
2439  context& ctx = args[0u].ctx();
2440  array<Z3_ast> _args(args);
2441  Z3_ast r = Z3_mk_add(ctx, _args.size(), _args.ptr());
2442  ctx.check_error();
2443  return expr(ctx, r);
2444  }
2445 
2446  inline expr distinct(expr_vector const& args) {
2447  assert(args.size() > 0);
2448  context& ctx = args[0u].ctx();
2449  array<Z3_ast> _args(args);
2450  Z3_ast r = Z3_mk_distinct(ctx, _args.size(), _args.ptr());
2451  ctx.check_error();
2452  return expr(ctx, r);
2453  }
2454 
2455  inline expr concat(expr const& a, expr const& b) {
2456  check_context(a, b);
2457  Z3_ast r;
2458  if (Z3_is_seq_sort(a.ctx(), a.get_sort())) {
2459  Z3_ast _args[2] = { a, b };
2460  r = Z3_mk_seq_concat(a.ctx(), 2, _args);
2461  }
2462  else if (Z3_is_re_sort(a.ctx(), a.get_sort())) {
2463  Z3_ast _args[2] = { a, b };
2464  r = Z3_mk_re_concat(a.ctx(), 2, _args);
2465  }
2466  else {
2467  r = Z3_mk_concat(a.ctx(), a, b);
2468  }
2469  a.ctx().check_error();
2470  return expr(a.ctx(), r);
2471  }
2472 
2473  inline expr concat(expr_vector const& args) {
2474  Z3_ast r;
2475  assert(args.size() > 0);
2476  if (args.size() == 1) {
2477  return args[0u];
2478  }
2479  context& ctx = args[0u].ctx();
2480  array<Z3_ast> _args(args);
2481  if (Z3_is_seq_sort(ctx, args[0u].get_sort())) {
2482  r = Z3_mk_seq_concat(ctx, _args.size(), _args.ptr());
2483  }
2484  else if (Z3_is_re_sort(ctx, args[0u].get_sort())) {
2485  r = Z3_mk_re_concat(ctx, _args.size(), _args.ptr());
2486  }
2487  else {
2488  r = _args[args.size()-1];
2489  for (unsigned i = args.size()-1; i > 0; ) {
2490  --i;
2491  r = Z3_mk_concat(ctx, _args[i], r);
2492  ctx.check_error();
2493  }
2494  }
2495  ctx.check_error();
2496  return expr(ctx, r);
2497  }
2498 
2499  inline expr mk_or(expr_vector const& args) {
2500  array<Z3_ast> _args(args);
2501  Z3_ast r = Z3_mk_or(args.ctx(), _args.size(), _args.ptr());
2502  args.check_error();
2503  return expr(args.ctx(), r);
2504  }
2505  inline expr mk_and(expr_vector const& args) {
2506  array<Z3_ast> _args(args);
2507  Z3_ast r = Z3_mk_and(args.ctx(), _args.size(), _args.ptr());
2508  args.check_error();
2509  return expr(args.ctx(), r);
2510  }
2511  inline expr mk_xor(expr_vector const& args) {
2512  if (args.empty())
2513  return args.ctx().bool_val(false);
2514  expr r = args[0u];
2515  for (unsigned i = 1; i < args.size(); ++i)
2516  r = r ^ args[i];
2517  return r;
2518  }
2519 
2520 
2521  class func_entry : public object {
2522  Z3_func_entry m_entry;
2523  void init(Z3_func_entry e) {
2524  m_entry = e;
2525  Z3_func_entry_inc_ref(ctx(), m_entry);
2526  }
2527  public:
2528  func_entry(context & c, Z3_func_entry e):object(c) { init(e); }
2529  func_entry(func_entry const & s):object(s) { init(s.m_entry); }
2531  operator Z3_func_entry() const { return m_entry; }
2533  Z3_func_entry_inc_ref(s.ctx(), s.m_entry);
2534  Z3_func_entry_dec_ref(ctx(), m_entry);
2535  object::operator=(s);
2536  m_entry = s.m_entry;
2537  return *this;
2538  }
2539  expr value() const { Z3_ast r = Z3_func_entry_get_value(ctx(), m_entry); check_error(); return expr(ctx(), r); }
2540  unsigned num_args() const { unsigned r = Z3_func_entry_get_num_args(ctx(), m_entry); check_error(); return r; }
2541  expr arg(unsigned i) const { Z3_ast r = Z3_func_entry_get_arg(ctx(), m_entry, i); check_error(); return expr(ctx(), r); }
2542  };
2543 
2544  class func_interp : public object {
2545  Z3_func_interp m_interp;
2546  void init(Z3_func_interp e) {
2547  m_interp = e;
2548  Z3_func_interp_inc_ref(ctx(), m_interp);
2549  }
2550  public:
2551  func_interp(context & c, Z3_func_interp e):object(c) { init(e); }
2552  func_interp(func_interp const & s):object(s) { init(s.m_interp); }
2554  operator Z3_func_interp() const { return m_interp; }
2556  Z3_func_interp_inc_ref(s.ctx(), s.m_interp);
2557  Z3_func_interp_dec_ref(ctx(), m_interp);
2558  object::operator=(s);
2559  m_interp = s.m_interp;
2560  return *this;
2561  }
2562  expr else_value() const { Z3_ast r = Z3_func_interp_get_else(ctx(), m_interp); check_error(); return expr(ctx(), r); }
2563  unsigned num_entries() const { unsigned r = Z3_func_interp_get_num_entries(ctx(), m_interp); check_error(); return r; }
2564  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); }
2565  void add_entry(expr_vector const& args, expr& value) {
2566  Z3_func_interp_add_entry(ctx(), m_interp, args, value);
2567  check_error();
2568  }
2569  void set_else(expr& value) {
2570  Z3_func_interp_set_else(ctx(), m_interp, value);
2571  check_error();
2572  }
2573  };
2574 
2575  class model : public object {
2576  Z3_model m_model;
2577  void init(Z3_model m) {
2578  m_model = m;
2579  Z3_model_inc_ref(ctx(), m);
2580  }
2581  public:
2582  struct translate {};
2583  model(context & c):object(c) { init(Z3_mk_model(c)); }
2584  model(context & c, Z3_model m):object(c) { init(m); }
2585  model(model const & s):object(s) { init(s.m_model); }
2586  model(model& src, context& dst, translate) : object(dst) { init(Z3_model_translate(src.ctx(), src, dst)); }
2587  ~model() { Z3_model_dec_ref(ctx(), m_model); }
2588  operator Z3_model() const { return m_model; }
2589  model & operator=(model const & s) {
2590  Z3_model_inc_ref(s.ctx(), s.m_model);
2591  Z3_model_dec_ref(ctx(), m_model);
2592  object::operator=(s);
2593  m_model = s.m_model;
2594  return *this;
2595  }
2596 
2597  expr eval(expr const & n, bool model_completion=false) const {
2598  check_context(*this, n);
2599  Z3_ast r = 0;
2600  bool status = Z3_model_eval(ctx(), m_model, n, model_completion, &r);
2601  check_error();
2602  if (status == false && ctx().enable_exceptions())
2603  Z3_THROW(exception("failed to evaluate expression"));
2604  return expr(ctx(), r);
2605  }
2606 
2607  unsigned num_consts() const { return Z3_model_get_num_consts(ctx(), m_model); }
2608  unsigned num_funcs() const { return Z3_model_get_num_funcs(ctx(), m_model); }
2609  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); }
2610  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); }
2611  unsigned size() const { return num_consts() + num_funcs(); }
2612  func_decl operator[](int i) const {
2613  assert(0 <= i);
2614  return static_cast<unsigned>(i) < num_consts() ? get_const_decl(i) : get_func_decl(i - num_consts());
2615  }
2616 
2617  // returns interpretation of constant declaration c.
2618  // If c is not assigned any value in the model it returns
2619  // an expression with a null ast reference.
2621  check_context(*this, c);
2622  Z3_ast r = Z3_model_get_const_interp(ctx(), m_model, c);
2623  check_error();
2624  return expr(ctx(), r);
2625  }
2627  check_context(*this, f);
2628  Z3_func_interp r = Z3_model_get_func_interp(ctx(), m_model, f);
2629  check_error();
2630  return func_interp(ctx(), r);
2631  }
2632 
2633  // returns true iff the model contains an interpretation
2634  // for function f.
2635  bool has_interp(func_decl f) const {
2636  check_context(*this, f);
2637  return Z3_model_has_interp(ctx(), m_model, f);
2638  }
2639 
2641  Z3_func_interp r = Z3_add_func_interp(ctx(), m_model, f, else_val);
2642  check_error();
2643  return func_interp(ctx(), r);
2644  }
2645 
2646  void add_const_interp(func_decl& f, expr& value) {
2647  Z3_add_const_interp(ctx(), m_model, f, value);
2648  check_error();
2649  }
2650 
2651  friend std::ostream & operator<<(std::ostream & out, model const & m);
2652 
2653  std::string to_string() const { return m_model ? std::string(Z3_model_to_string(ctx(), m_model)) : "null"; }
2654  };
2655  inline std::ostream & operator<<(std::ostream & out, model const & m) { return out << m.to_string(); }
2656 
2657  class stats : public object {
2658  Z3_stats m_stats;
2659  void init(Z3_stats e) {
2660  m_stats = e;
2661  Z3_stats_inc_ref(ctx(), m_stats);
2662  }
2663  public:
2664  stats(context & c):object(c), m_stats(0) {}
2665  stats(context & c, Z3_stats e):object(c) { init(e); }
2666  stats(stats const & s):object(s) { init(s.m_stats); }
2667  ~stats() { if (m_stats) Z3_stats_dec_ref(ctx(), m_stats); }
2668  operator Z3_stats() const { return m_stats; }
2669  stats & operator=(stats const & s) {
2670  Z3_stats_inc_ref(s.ctx(), s.m_stats);
2671  if (m_stats) Z3_stats_dec_ref(ctx(), m_stats);
2672  object::operator=(s);
2673  m_stats = s.m_stats;
2674  return *this;
2675  }
2676  unsigned size() const { return Z3_stats_size(ctx(), m_stats); }
2677  std::string key(unsigned i) const { Z3_string s = Z3_stats_get_key(ctx(), m_stats, i); check_error(); return s; }
2678  bool is_uint(unsigned i) const { bool r = Z3_stats_is_uint(ctx(), m_stats, i); check_error(); return r; }
2679  bool is_double(unsigned i) const { bool r = Z3_stats_is_double(ctx(), m_stats, i); check_error(); return r; }
2680  unsigned uint_value(unsigned i) const { unsigned r = Z3_stats_get_uint_value(ctx(), m_stats, i); check_error(); return r; }
2681  double double_value(unsigned i) const { double r = Z3_stats_get_double_value(ctx(), m_stats, i); check_error(); return r; }
2682  friend std::ostream & operator<<(std::ostream & out, stats const & s);
2683  };
2684  inline std::ostream & operator<<(std::ostream & out, stats const & s) { out << Z3_stats_to_string(s.ctx(), s); return out; }
2685 
2686 
2687  inline std::ostream & operator<<(std::ostream & out, check_result r) {
2688  if (r == unsat) out << "unsat";
2689  else if (r == sat) out << "sat";
2690  else out << "unknown";
2691  return out;
2692  }
2693 
2704  class parameter {
2705  Z3_parameter_kind m_kind;
2706  func_decl m_decl;
2707  unsigned m_index;
2708  context& ctx() const { return m_decl.ctx(); }
2709  void check_error() const { ctx().check_error(); }
2710  public:
2711  parameter(func_decl const& d, unsigned idx) : m_decl(d), m_index(idx) {
2712  if (ctx().enable_exceptions() && idx >= d.num_parameters())
2713  Z3_THROW(exception("parameter index is out of bounds"));
2714  m_kind = Z3_get_decl_parameter_kind(ctx(), d, idx);
2715  }
2716  parameter(expr const& e, unsigned idx) : m_decl(e.decl()), m_index(idx) {
2717  if (ctx().enable_exceptions() && idx >= m_decl.num_parameters())
2718  Z3_THROW(exception("parameter index is out of bounds"));
2719  m_kind = Z3_get_decl_parameter_kind(ctx(), m_decl, idx);
2720  }
2721  Z3_parameter_kind kind() const { return m_kind; }
2722  expr get_expr() const { Z3_ast a = Z3_get_decl_ast_parameter(ctx(), m_decl, m_index); check_error(); return expr(ctx(), a); }
2723  sort get_sort() const { Z3_sort s = Z3_get_decl_sort_parameter(ctx(), m_decl, m_index); check_error(); return sort(ctx(), s); }
2724  func_decl get_decl() const { Z3_func_decl f = Z3_get_decl_func_decl_parameter(ctx(), m_decl, m_index); check_error(); return func_decl(ctx(), f); }
2725  symbol get_symbol() const { Z3_symbol s = Z3_get_decl_symbol_parameter(ctx(), m_decl, m_index); check_error(); return symbol(ctx(), s); }
2726  std::string get_rational() const { Z3_string s = Z3_get_decl_rational_parameter(ctx(), m_decl, m_index); check_error(); return s; }
2727  double get_double() const { double d = Z3_get_decl_double_parameter(ctx(), m_decl, m_index); check_error(); return d; }
2728  int get_int() const { int i = Z3_get_decl_int_parameter(ctx(), m_decl, m_index); check_error(); return i; }
2729  };
2730 
2731 
2732  class solver : public object {
2733  Z3_solver m_solver;
2734  void init(Z3_solver s) {
2735  m_solver = s;
2736  if (s)
2737  Z3_solver_inc_ref(ctx(), s);
2738  }
2739  public:
2740  struct simple {};
2741  struct translate {};
2742  solver(context & c):object(c) { init(Z3_mk_solver(c)); check_error(); }
2744  solver(context & c, Z3_solver s):object(c) { init(s); }
2745  solver(context & c, char const * logic):object(c) { init(Z3_mk_solver_for_logic(c, c.str_symbol(logic))); check_error(); }
2746  solver(context & c, solver const& src, translate): object(c) { Z3_solver s = Z3_solver_translate(src.ctx(), src, c); check_error(); init(s); }
2747  solver(solver const & s):object(s) { init(s.m_solver); }
2748  solver(solver const& s, simplifier const& simp);
2749  ~solver() { Z3_solver_dec_ref(ctx(), m_solver); }
2750  operator Z3_solver() const { return m_solver; }
2751  solver & operator=(solver const & s) {
2752  Z3_solver_inc_ref(s.ctx(), s.m_solver);
2753  Z3_solver_dec_ref(ctx(), m_solver);
2754  object::operator=(s);
2755  m_solver = s.m_solver;
2756  return *this;
2757  }
2758  void set(params const & p) { Z3_solver_set_params(ctx(), m_solver, p); check_error(); }
2759  void set(char const * k, bool v) { params p(ctx()); p.set(k, v); set(p); }
2760  void set(char const * k, unsigned v) { params p(ctx()); p.set(k, v); set(p); }
2761  void set(char const * k, double v) { params p(ctx()); p.set(k, v); set(p); }
2762  void set(char const * k, symbol const & v) { params p(ctx()); p.set(k, v); set(p); }
2763  void set(char const * k, char const* v) { params p(ctx()); p.set(k, v); set(p); }
2774  void push() { Z3_solver_push(ctx(), m_solver); check_error(); }
2775  void pop(unsigned n = 1) { Z3_solver_pop(ctx(), m_solver, n); check_error(); }
2776  void reset() { Z3_solver_reset(ctx(), m_solver); check_error(); }
2777  void add(expr const & e) { assert(e.is_bool()); Z3_solver_assert(ctx(), m_solver, e); check_error(); }
2778  void add(expr const & e, expr const & p) {
2779  assert(e.is_bool()); assert(p.is_bool()); assert(p.is_const());
2780  Z3_solver_assert_and_track(ctx(), m_solver, e, p);
2781  check_error();
2782  }
2783  void add(expr const & e, char const * p) {
2784  add(e, ctx().bool_const(p));
2785  }
2786  void add(expr_vector const& v) {
2787  check_context(*this, v);
2788  for (unsigned i = 0; i < v.size(); ++i)
2789  add(v[i]);
2790  }
2791  void from_file(char const* file) { Z3_solver_from_file(ctx(), m_solver, file); ctx().check_parser_error(); }
2792  void from_string(char const* s) { Z3_solver_from_string(ctx(), m_solver, s); ctx().check_parser_error(); }
2793 
2795  check_result check(unsigned n, expr * const assumptions) {
2796  array<Z3_ast> _assumptions(n);
2797  for (unsigned i = 0; i < n; i++) {
2798  check_context(*this, assumptions[i]);
2799  _assumptions[i] = assumptions[i];
2800  }
2801  Z3_lbool r = Z3_solver_check_assumptions(ctx(), m_solver, n, _assumptions.ptr());
2802  check_error();
2803  return to_check_result(r);
2804  }
2805  check_result check(expr_vector const& assumptions) {
2806  unsigned n = assumptions.size();
2807  array<Z3_ast> _assumptions(n);
2808  for (unsigned i = 0; i < n; i++) {
2809  check_context(*this, assumptions[i]);
2810  _assumptions[i] = assumptions[i];
2811  }
2812  Z3_lbool r = Z3_solver_check_assumptions(ctx(), m_solver, n, _assumptions.ptr());
2813  check_error();
2814  return to_check_result(r);
2815  }
2816  model get_model() const { Z3_model m = Z3_solver_get_model(ctx(), m_solver); check_error(); return model(ctx(), m); }
2817  check_result consequences(expr_vector& assumptions, expr_vector& vars, expr_vector& conseq) {
2818  Z3_lbool r = Z3_solver_get_consequences(ctx(), m_solver, assumptions, vars, conseq);
2819  check_error();
2820  return to_check_result(r);
2821  }
2822  std::string reason_unknown() const { Z3_string r = Z3_solver_get_reason_unknown(ctx(), m_solver); check_error(); return r; }
2823  stats statistics() const { Z3_stats r = Z3_solver_get_statistics(ctx(), m_solver); check_error(); return stats(ctx(), r); }
2824  expr_vector unsat_core() const { Z3_ast_vector r = Z3_solver_get_unsat_core(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2825  expr_vector assertions() const { Z3_ast_vector r = Z3_solver_get_assertions(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2826  expr_vector non_units() const { Z3_ast_vector r = Z3_solver_get_non_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2827  expr_vector units() const { Z3_ast_vector r = Z3_solver_get_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2828  expr_vector trail() const { Z3_ast_vector r = Z3_solver_get_trail(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2829  expr_vector trail(array<unsigned>& levels) const {
2830  Z3_ast_vector r = Z3_solver_get_trail(ctx(), m_solver);
2831  check_error();
2832  expr_vector result(ctx(), r);
2833  unsigned sz = result.size();
2834  levels.resize(sz);
2835  Z3_solver_get_levels(ctx(), m_solver, r, sz, levels.ptr());
2836  check_error();
2837  return result;
2838  }
2839  expr proof() const { Z3_ast r = Z3_solver_get_proof(ctx(), m_solver); check_error(); return expr(ctx(), r); }
2840  friend std::ostream & operator<<(std::ostream & out, solver const & s);
2841 
2842  std::string to_smt2(char const* status = "unknown") {
2843  array<Z3_ast> es(assertions());
2844  Z3_ast const* fmls = es.ptr();
2845  Z3_ast fml = 0;
2846  unsigned sz = es.size();
2847  if (sz > 0) {
2848  --sz;
2849  fml = fmls[sz];
2850  }
2851  else {
2852  fml = ctx().bool_val(true);
2853  }
2854  return std::string(Z3_benchmark_to_smtlib_string(
2855  ctx(),
2856  "", "", status, "",
2857  sz,
2858  fmls,
2859  fml));
2860  }
2861 
2862  std::string dimacs(bool include_names = true) const { return std::string(Z3_solver_to_dimacs_string(ctx(), m_solver, include_names)); }
2863 
2865 
2866 
2867  expr_vector cube(expr_vector& vars, unsigned cutoff) {
2868  Z3_ast_vector r = Z3_solver_cube(ctx(), m_solver, vars, cutoff);
2869  check_error();
2870  return expr_vector(ctx(), r);
2871  }
2872 
2874  solver& m_solver;
2875  unsigned& m_cutoff;
2876  expr_vector& m_vars;
2877  expr_vector m_cube;
2878  bool m_end;
2879  bool m_empty;
2880 
2881  void inc() {
2882  assert(!m_end && !m_empty);
2883  m_cube = m_solver.cube(m_vars, m_cutoff);
2884  m_cutoff = 0xFFFFFFFF;
2885  if (m_cube.size() == 1 && m_cube[0u].is_false()) {
2886  m_cube = z3::expr_vector(m_solver.ctx());
2887  m_end = true;
2888  }
2889  else if (m_cube.empty()) {
2890  m_empty = true;
2891  }
2892  }
2893  public:
2894  cube_iterator(solver& s, expr_vector& vars, unsigned& cutoff, bool end):
2895  m_solver(s),
2896  m_cutoff(cutoff),
2897  m_vars(vars),
2898  m_cube(s.ctx()),
2899  m_end(end),
2900  m_empty(false) {
2901  if (!m_end) {
2902  inc();
2903  }
2904  }
2905 
2907  assert(!m_end);
2908  if (m_empty) {
2909  m_end = true;
2910  }
2911  else {
2912  inc();
2913  }
2914  return *this;
2915  }
2916  cube_iterator operator++(int) { assert(false); return *this; }
2917  expr_vector const * operator->() const { return &(operator*()); }
2918  expr_vector const& operator*() const noexcept { return m_cube; }
2919 
2920  bool operator==(cube_iterator const& other) noexcept {
2921  return other.m_end == m_end;
2922  };
2923  bool operator!=(cube_iterator const& other) noexcept {
2924  return other.m_end != m_end;
2925  };
2926 
2927  };
2928 
2930  solver& m_solver;
2931  unsigned m_cutoff;
2932  expr_vector m_default_vars;
2933  expr_vector& m_vars;
2934  public:
2936  m_solver(s),
2937  m_cutoff(0xFFFFFFFF),
2938  m_default_vars(s.ctx()),
2939  m_vars(m_default_vars)
2940  {}
2941 
2942  cube_generator(solver& s, expr_vector& vars):
2943  m_solver(s),
2944  m_cutoff(0xFFFFFFFF),
2945  m_default_vars(s.ctx()),
2946  m_vars(vars)
2947  {}
2948 
2949  cube_iterator begin() { return cube_iterator(m_solver, m_vars, m_cutoff, false); }
2950  cube_iterator end() { return cube_iterator(m_solver, m_vars, m_cutoff, true); }
2951  void set_cutoff(unsigned c) noexcept { m_cutoff = c; }
2952  };
2953 
2954  cube_generator cubes() { return cube_generator(*this); }
2955  cube_generator cubes(expr_vector& vars) { return cube_generator(*this, vars); }
2956 
2957  };
2958  inline std::ostream & operator<<(std::ostream & out, solver const & s) { out << Z3_solver_to_string(s.ctx(), s); return out; }
2959 
2960  class goal : public object {
2961  Z3_goal m_goal;
2962  void init(Z3_goal s) {
2963  m_goal = s;
2964  Z3_goal_inc_ref(ctx(), s);
2965  }
2966  public:
2967  goal(context & c, bool models=true, bool unsat_cores=false, bool proofs=false):object(c) { init(Z3_mk_goal(c, models, unsat_cores, proofs)); }
2968  goal(context & c, Z3_goal s):object(c) { init(s); }
2969  goal(goal const & s):object(s) { init(s.m_goal); }
2970  ~goal() { Z3_goal_dec_ref(ctx(), m_goal); }
2971  operator Z3_goal() const { return m_goal; }
2972  goal & operator=(goal const & s) {
2973  Z3_goal_inc_ref(s.ctx(), s.m_goal);
2974  Z3_goal_dec_ref(ctx(), m_goal);
2975  object::operator=(s);
2976  m_goal = s.m_goal;
2977  return *this;
2978  }
2979  void add(expr const & f) { check_context(*this, f); Z3_goal_assert(ctx(), m_goal, f); check_error(); }
2980  void add(expr_vector const& v) { check_context(*this, v); for (unsigned i = 0; i < v.size(); ++i) add(v[i]); }
2981  unsigned size() const { return Z3_goal_size(ctx(), m_goal); }
2982  expr operator[](int i) const { assert(0 <= i); Z3_ast r = Z3_goal_formula(ctx(), m_goal, i); check_error(); return expr(ctx(), r); }
2983  Z3_goal_prec precision() const { return Z3_goal_precision(ctx(), m_goal); }
2984  bool inconsistent() const { return Z3_goal_inconsistent(ctx(), m_goal); }
2985  unsigned depth() const { return Z3_goal_depth(ctx(), m_goal); }
2986  void reset() { Z3_goal_reset(ctx(), m_goal); }
2987  unsigned num_exprs() const { return Z3_goal_num_exprs(ctx(), m_goal); }
2988  bool is_decided_sat() const { return Z3_goal_is_decided_sat(ctx(), m_goal); }
2989  bool is_decided_unsat() const { return Z3_goal_is_decided_unsat(ctx(), m_goal); }
2990  model convert_model(model const & m) const {
2991  check_context(*this, m);
2992  Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, m);
2993  check_error();
2994  return model(ctx(), new_m);
2995  }
2996  model get_model() const {
2997  Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, 0);
2998  check_error();
2999  return model(ctx(), new_m);
3000  }
3001  expr as_expr() const {
3002  unsigned n = size();
3003  if (n == 0)
3004  return ctx().bool_val(true);
3005  else if (n == 1)
3006  return operator[](0u);
3007  else {
3008  array<Z3_ast> args(n);
3009  for (unsigned i = 0; i < n; i++)
3010  args[i] = operator[](i);
3011  return expr(ctx(), Z3_mk_and(ctx(), n, args.ptr()));
3012  }
3013  }
3014  std::string dimacs(bool include_names = true) const { return std::string(Z3_goal_to_dimacs_string(ctx(), m_goal, include_names)); }
3015  friend std::ostream & operator<<(std::ostream & out, goal const & g);
3016  };
3017  inline std::ostream & operator<<(std::ostream & out, goal const & g) { out << Z3_goal_to_string(g.ctx(), g); return out; }
3018 
3019  class apply_result : public object {
3020  Z3_apply_result m_apply_result;
3021  void init(Z3_apply_result s) {
3022  m_apply_result = s;
3024  }
3025  public:
3026  apply_result(context & c, Z3_apply_result s):object(c) { init(s); }
3027  apply_result(apply_result const & s):object(s) { init(s.m_apply_result); }
3028  ~apply_result() { Z3_apply_result_dec_ref(ctx(), m_apply_result); }
3029  operator Z3_apply_result() const { return m_apply_result; }
3031  Z3_apply_result_inc_ref(s.ctx(), s.m_apply_result);
3032  Z3_apply_result_dec_ref(ctx(), m_apply_result);
3033  object::operator=(s);
3034  m_apply_result = s.m_apply_result;
3035  return *this;
3036  }
3037  unsigned size() const { return Z3_apply_result_get_num_subgoals(ctx(), m_apply_result); }
3038  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); }
3039  friend std::ostream & operator<<(std::ostream & out, apply_result const & r);
3040  };
3041  inline std::ostream & operator<<(std::ostream & out, apply_result const & r) { out << Z3_apply_result_to_string(r.ctx(), r); return out; }
3042 
3043  class tactic : public object {
3044  Z3_tactic m_tactic;
3045  void init(Z3_tactic s) {
3046  m_tactic = s;
3047  Z3_tactic_inc_ref(ctx(), s);
3048  }
3049  public:
3050  tactic(context & c, char const * name):object(c) { Z3_tactic r = Z3_mk_tactic(c, name); check_error(); init(r); }
3051  tactic(context & c, Z3_tactic s):object(c) { init(s); }
3052  tactic(tactic const & s):object(s) { init(s.m_tactic); }
3053  ~tactic() { Z3_tactic_dec_ref(ctx(), m_tactic); }
3054  operator Z3_tactic() const { return m_tactic; }
3055  tactic & operator=(tactic const & s) {
3056  Z3_tactic_inc_ref(s.ctx(), s.m_tactic);
3057  Z3_tactic_dec_ref(ctx(), m_tactic);
3058  object::operator=(s);
3059  m_tactic = s.m_tactic;
3060  return *this;
3061  }
3062  solver mk_solver() const { Z3_solver r = Z3_mk_solver_from_tactic(ctx(), m_tactic); check_error(); return solver(ctx(), r); }
3063  apply_result apply(goal const & g) const {
3064  check_context(*this, g);
3065  Z3_apply_result r = Z3_tactic_apply(ctx(), m_tactic, g);
3066  check_error();
3067  return apply_result(ctx(), r);
3068  }
3069  apply_result operator()(goal const & g) const {
3070  return apply(g);
3071  }
3072  std::string help() const { char const * r = Z3_tactic_get_help(ctx(), m_tactic); check_error(); return r; }
3073  friend tactic operator&(tactic const & t1, tactic const & t2);
3074  friend tactic operator|(tactic const & t1, tactic const & t2);
3075  friend tactic repeat(tactic const & t, unsigned max);
3076  friend tactic with(tactic const & t, params const & p);
3077  friend tactic try_for(tactic const & t, unsigned ms);
3078  friend tactic par_or(unsigned n, tactic const* tactics);
3079  friend tactic par_and_then(tactic const& t1, tactic const& t2);
3081  };
3082 
3083  inline tactic operator&(tactic const & t1, tactic const & t2) {
3084  check_context(t1, t2);
3085  Z3_tactic r = Z3_tactic_and_then(t1.ctx(), t1, t2);
3086  t1.check_error();
3087  return tactic(t1.ctx(), r);
3088  }
3089 
3090  inline tactic operator|(tactic const & t1, tactic const & t2) {
3091  check_context(t1, t2);
3092  Z3_tactic r = Z3_tactic_or_else(t1.ctx(), t1, t2);
3093  t1.check_error();
3094  return tactic(t1.ctx(), r);
3095  }
3096 
3097  inline tactic repeat(tactic const & t, unsigned max=UINT_MAX) {
3098  Z3_tactic r = Z3_tactic_repeat(t.ctx(), t, max);
3099  t.check_error();
3100  return tactic(t.ctx(), r);
3101  }
3102 
3103  inline tactic with(tactic const & t, params const & p) {
3104  Z3_tactic r = Z3_tactic_using_params(t.ctx(), t, p);
3105  t.check_error();
3106  return tactic(t.ctx(), r);
3107  }
3108  inline tactic try_for(tactic const & t, unsigned ms) {
3109  Z3_tactic r = Z3_tactic_try_for(t.ctx(), t, ms);
3110  t.check_error();
3111  return tactic(t.ctx(), r);
3112  }
3113  inline tactic par_or(unsigned n, tactic const* tactics) {
3114  if (n == 0) {
3115  Z3_THROW(exception("a non-zero number of tactics need to be passed to par_or"));
3116  }
3117  array<Z3_tactic> buffer(n);
3118  for (unsigned i = 0; i < n; ++i) buffer[i] = tactics[i];
3119  return tactic(tactics[0u].ctx(), Z3_tactic_par_or(tactics[0u].ctx(), n, buffer.ptr()));
3120  }
3121 
3122  inline tactic par_and_then(tactic const & t1, tactic const & t2) {
3123  check_context(t1, t2);
3124  Z3_tactic r = Z3_tactic_par_and_then(t1.ctx(), t1, t2);
3125  t1.check_error();
3126  return tactic(t1.ctx(), r);
3127  }
3128 
3129  class simplifier : public object {
3130  Z3_simplifier m_simplifier;
3131  void init(Z3_simplifier s) {
3132  m_simplifier = s;
3133  Z3_simplifier_inc_ref(ctx(), s);
3134  }
3135  public:
3136  simplifier(context & c, char const * name):object(c) { Z3_simplifier r = Z3_mk_simplifier(c, name); check_error(); init(r); }
3137  simplifier(context & c, Z3_simplifier s):object(c) { init(s); }
3138  simplifier(simplifier const & s):object(s) { init(s.m_simplifier); }
3139  ~simplifier() { Z3_simplifier_dec_ref(ctx(), m_simplifier); }
3140  operator Z3_simplifier() const { return m_simplifier; }
3142  Z3_simplifier_inc_ref(s.ctx(), s.m_simplifier);
3143  Z3_simplifier_dec_ref(ctx(), m_simplifier);
3144  object::operator=(s);
3145  m_simplifier = s.m_simplifier;
3146  return *this;
3147  }
3148  std::string help() const { char const * r = Z3_simplifier_get_help(ctx(), m_simplifier); check_error(); return r; }
3149  friend simplifier operator&(simplifier const & t1, simplifier const & t2);
3150  friend simplifier with(simplifier const & t, params const & p);
3152  };
3153 
3154  inline solver::solver(solver const& s, simplifier const& simp):object(s) { init(Z3_solver_add_simplifier(s.ctx(), s, simp)); }
3155 
3156 
3157  inline simplifier operator&(simplifier const & t1, simplifier const & t2) {
3158  check_context(t1, t2);
3159  Z3_simplifier r = Z3_simplifier_and_then(t1.ctx(), t1, t2);
3160  t1.check_error();
3161  return simplifier(t1.ctx(), r);
3162  }
3163 
3164  inline simplifier with(simplifier const & t, params const & p) {
3165  Z3_simplifier r = Z3_simplifier_using_params(t.ctx(), t, p);
3166  t.check_error();
3167  return simplifier(t.ctx(), r);
3168  }
3169 
3170  class probe : public object {
3171  Z3_probe m_probe;
3172  void init(Z3_probe s) {
3173  m_probe = s;
3174  Z3_probe_inc_ref(ctx(), s);
3175  }
3176  public:
3177  probe(context & c, char const * name):object(c) { Z3_probe r = Z3_mk_probe(c, name); check_error(); init(r); }
3178  probe(context & c, double val):object(c) { Z3_probe r = Z3_probe_const(c, val); check_error(); init(r); }
3179  probe(context & c, Z3_probe s):object(c) { init(s); }
3180  probe(probe const & s):object(s) { init(s.m_probe); }
3181  ~probe() { Z3_probe_dec_ref(ctx(), m_probe); }
3182  operator Z3_probe() const { return m_probe; }
3183  probe & operator=(probe const & s) {
3184  Z3_probe_inc_ref(s.ctx(), s.m_probe);
3185  Z3_probe_dec_ref(ctx(), m_probe);
3186  object::operator=(s);
3187  m_probe = s.m_probe;
3188  return *this;
3189  }
3190  double apply(goal const & g) const { double r = Z3_probe_apply(ctx(), m_probe, g); check_error(); return r; }
3191  double operator()(goal const & g) const { return apply(g); }
3192  friend probe operator<=(probe const & p1, probe const & p2);
3193  friend probe operator<=(probe const & p1, double p2);
3194  friend probe operator<=(double p1, probe const & p2);
3195  friend probe operator>=(probe const & p1, probe const & p2);
3196  friend probe operator>=(probe const & p1, double p2);
3197  friend probe operator>=(double p1, probe const & p2);
3198  friend probe operator<(probe const & p1, probe const & p2);
3199  friend probe operator<(probe const & p1, double p2);
3200  friend probe operator<(double p1, probe const & p2);
3201  friend probe operator>(probe const & p1, probe const & p2);
3202  friend probe operator>(probe const & p1, double p2);
3203  friend probe operator>(double p1, probe const & p2);
3204  friend probe operator==(probe const & p1, probe const & p2);
3205  friend probe operator==(probe const & p1, double p2);
3206  friend probe operator==(double p1, probe const & p2);
3207  friend probe operator&&(probe const & p1, probe const & p2);
3208  friend probe operator||(probe const & p1, probe const & p2);
3209  friend probe operator!(probe const & p);
3210  };
3211 
3212  inline probe operator<=(probe const & p1, probe const & p2) {
3213  check_context(p1, p2); Z3_probe r = Z3_probe_le(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3214  }
3215  inline probe operator<=(probe const & p1, double p2) { return p1 <= probe(p1.ctx(), p2); }
3216  inline probe operator<=(double p1, probe const & p2) { return probe(p2.ctx(), p1) <= p2; }
3217  inline probe operator>=(probe const & p1, probe const & p2) {
3218  check_context(p1, p2); Z3_probe r = Z3_probe_ge(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3219  }
3220  inline probe operator>=(probe const & p1, double p2) { return p1 >= probe(p1.ctx(), p2); }
3221  inline probe operator>=(double p1, probe const & p2) { return probe(p2.ctx(), p1) >= p2; }
3222  inline probe operator<(probe const & p1, probe const & p2) {
3223  check_context(p1, p2); Z3_probe r = Z3_probe_lt(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3224  }
3225  inline probe operator<(probe const & p1, double p2) { return p1 < probe(p1.ctx(), p2); }
3226  inline probe operator<(double p1, probe const & p2) { return probe(p2.ctx(), p1) < p2; }
3227  inline probe operator>(probe const & p1, probe const & p2) {
3228  check_context(p1, p2); Z3_probe r = Z3_probe_gt(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3229  }
3230  inline probe operator>(probe const & p1, double p2) { return p1 > probe(p1.ctx(), p2); }
3231  inline probe operator>(double p1, probe const & p2) { return probe(p2.ctx(), p1) > p2; }
3232  inline probe operator==(probe const & p1, probe const & p2) {
3233  check_context(p1, p2); Z3_probe r = Z3_probe_eq(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3234  }
3235  inline probe operator==(probe const & p1, double p2) { return p1 == probe(p1.ctx(), p2); }
3236  inline probe operator==(double p1, probe const & p2) { return probe(p2.ctx(), p1) == p2; }
3237  inline probe operator&&(probe const & p1, probe const & p2) {
3238  check_context(p1, p2); Z3_probe r = Z3_probe_and(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3239  }
3240  inline probe operator||(probe const & p1, probe const & p2) {
3241  check_context(p1, p2); Z3_probe r = Z3_probe_or(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3242  }
3243  inline probe operator!(probe const & p) {
3244  Z3_probe r = Z3_probe_not(p.ctx(), p); p.check_error(); return probe(p.ctx(), r);
3245  }
3246 
3247  class optimize : public object {
3248  Z3_optimize m_opt;
3249 
3250  public:
3251  class handle final {
3252  unsigned m_h;
3253  public:
3254  handle(unsigned h): m_h(h) {}
3255  unsigned h() const { return m_h; }
3256  };
3257  optimize(context& c):object(c) { m_opt = Z3_mk_optimize(c); Z3_optimize_inc_ref(c, m_opt); }
3258  optimize(optimize const & o):object(o), m_opt(o.m_opt) {
3259  Z3_optimize_inc_ref(o.ctx(), o.m_opt);
3260  }
3262  m_opt = Z3_mk_optimize(c);
3263  Z3_optimize_inc_ref(c, m_opt);
3264  add(expr_vector(c, src.assertions()));
3265  expr_vector v(c, src.objectives());
3266  for (expr_vector::iterator it = v.begin(); it != v.end(); ++it) minimize(*it);
3267  }
3269  Z3_optimize_inc_ref(o.ctx(), o.m_opt);
3270  Z3_optimize_dec_ref(ctx(), m_opt);
3271  m_opt = o.m_opt;
3272  object::operator=(o);
3273  return *this;
3274  }
3276  operator Z3_optimize() const { return m_opt; }
3277  void add(expr const& e) {
3278  assert(e.is_bool());
3279  Z3_optimize_assert(ctx(), m_opt, e);
3280  }
3281  void add(expr_vector const& es) {
3282  for (expr_vector::iterator it = es.begin(); it != es.end(); ++it) add(*it);
3283  }
3284  void add(expr const& e, expr const& t) {
3285  assert(e.is_bool());
3286  Z3_optimize_assert_and_track(ctx(), m_opt, e, t);
3287  }
3288  void add(expr const& e, char const* p) {
3289  assert(e.is_bool());
3290  add(e, ctx().bool_const(p));
3291  }
3292  handle add_soft(expr const& e, unsigned weight) {
3293  assert(e.is_bool());
3294  auto str = std::to_string(weight);
3295  return handle(Z3_optimize_assert_soft(ctx(), m_opt, e, str.c_str(), 0));
3296  }
3297  handle add_soft(expr const& e, char const* weight) {
3298  assert(e.is_bool());
3299  return handle(Z3_optimize_assert_soft(ctx(), m_opt, e, weight, 0));
3300  }
3301  handle add(expr const& e, unsigned weight) {
3302  return add_soft(e, weight);
3303  }
3304  handle maximize(expr const& e) {
3305  return handle(Z3_optimize_maximize(ctx(), m_opt, e));
3306  }
3307  handle minimize(expr const& e) {
3308  return handle(Z3_optimize_minimize(ctx(), m_opt, e));
3309  }
3310  void push() {
3311  Z3_optimize_push(ctx(), m_opt);
3312  }
3313  void pop() {
3314  Z3_optimize_pop(ctx(), m_opt);
3315  }
3317  check_result check(expr_vector const& asms) {
3318  unsigned n = asms.size();
3319  array<Z3_ast> _asms(n);
3320  for (unsigned i = 0; i < n; i++) {
3321  check_context(*this, asms[i]);
3322  _asms[i] = asms[i];
3323  }
3324  Z3_lbool r = Z3_optimize_check(ctx(), m_opt, n, _asms.ptr());
3325  check_error();
3326  return to_check_result(r);
3327  }
3328  model get_model() const { Z3_model m = Z3_optimize_get_model(ctx(), m_opt); check_error(); return model(ctx(), m); }
3329  expr_vector unsat_core() const { Z3_ast_vector r = Z3_optimize_get_unsat_core(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3330  void set(params const & p) { Z3_optimize_set_params(ctx(), m_opt, p); check_error(); }
3331  expr lower(handle const& h) {
3332  Z3_ast r = Z3_optimize_get_lower(ctx(), m_opt, h.h());
3333  check_error();
3334  return expr(ctx(), r);
3335  }
3336  expr upper(handle const& h) {
3337  Z3_ast r = Z3_optimize_get_upper(ctx(), m_opt, h.h());
3338  check_error();
3339  return expr(ctx(), r);
3340  }
3341  expr_vector assertions() const { Z3_ast_vector r = Z3_optimize_get_assertions(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3342  expr_vector objectives() const { Z3_ast_vector r = Z3_optimize_get_objectives(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3343  stats statistics() const { Z3_stats r = Z3_optimize_get_statistics(ctx(), m_opt); check_error(); return stats(ctx(), r); }
3344  friend std::ostream & operator<<(std::ostream & out, optimize const & s);
3345  void from_file(char const* filename) { Z3_optimize_from_file(ctx(), m_opt, filename); check_error(); }
3346  void from_string(char const* constraints) { Z3_optimize_from_string(ctx(), m_opt, constraints); check_error(); }
3347  std::string help() const { char const * r = Z3_optimize_get_help(ctx(), m_opt); check_error(); return r; }
3348  };
3349  inline std::ostream & operator<<(std::ostream & out, optimize const & s) { out << Z3_optimize_to_string(s.ctx(), s.m_opt); return out; }
3350 
3351  class fixedpoint : public object {
3352  Z3_fixedpoint m_fp;
3353  public:
3355  fixedpoint(fixedpoint const & o):object(o), m_fp(o.m_fp) { Z3_fixedpoint_inc_ref(ctx(), m_fp); }
3358  Z3_fixedpoint_inc_ref(o.ctx(), o.m_fp);
3359  Z3_fixedpoint_dec_ref(ctx(), m_fp);
3360  m_fp = o.m_fp;
3361  object::operator=(o);
3362  return *this;
3363  }
3364  operator Z3_fixedpoint() const { return m_fp; }
3365  expr_vector from_string(char const* s) {
3366  Z3_ast_vector r = Z3_fixedpoint_from_string(ctx(), m_fp, s);
3367  check_error();
3368  return expr_vector(ctx(), r);
3369  }
3370  expr_vector from_file(char const* s) {
3371  Z3_ast_vector r = Z3_fixedpoint_from_file(ctx(), m_fp, s);
3372  check_error();
3373  return expr_vector(ctx(), r);
3374  }
3375  void add_rule(expr& rule, symbol const& name) { Z3_fixedpoint_add_rule(ctx(), m_fp, rule, name); check_error(); }
3376  void add_fact(func_decl& f, unsigned * args) { Z3_fixedpoint_add_fact(ctx(), m_fp, f, f.arity(), args); check_error(); }
3378  check_result query(func_decl_vector& relations) {
3379  array<Z3_func_decl> rs(relations);
3380  Z3_lbool r = Z3_fixedpoint_query_relations(ctx(), m_fp, rs.size(), rs.ptr());
3381  check_error();
3382  return to_check_result(r);
3383  }
3384  expr get_answer() { Z3_ast r = Z3_fixedpoint_get_answer(ctx(), m_fp); check_error(); return expr(ctx(), r); }
3385  std::string reason_unknown() { return Z3_fixedpoint_get_reason_unknown(ctx(), m_fp); }
3386  void update_rule(expr& rule, symbol const& name) { Z3_fixedpoint_update_rule(ctx(), m_fp, rule, name); check_error(); }
3387  unsigned get_num_levels(func_decl& p) { unsigned r = Z3_fixedpoint_get_num_levels(ctx(), m_fp, p); check_error(); return r; }
3388  expr get_cover_delta(int level, func_decl& p) {
3389  Z3_ast r = Z3_fixedpoint_get_cover_delta(ctx(), m_fp, level, p);
3390  check_error();
3391  return expr(ctx(), r);
3392  }
3393  void add_cover(int level, func_decl& p, expr& property) { Z3_fixedpoint_add_cover(ctx(), m_fp, level, p, property); check_error(); }
3394  stats statistics() const { Z3_stats r = Z3_fixedpoint_get_statistics(ctx(), m_fp); check_error(); return stats(ctx(), r); }
3396  expr_vector assertions() const { Z3_ast_vector r = Z3_fixedpoint_get_assertions(ctx(), m_fp); check_error(); return expr_vector(ctx(), r); }
3397  expr_vector rules() const { Z3_ast_vector r = Z3_fixedpoint_get_rules(ctx(), m_fp); check_error(); return expr_vector(ctx(), r); }
3398  void set(params const & p) { Z3_fixedpoint_set_params(ctx(), m_fp, p); check_error(); }
3399  std::string help() const { return Z3_fixedpoint_get_help(ctx(), m_fp); }
3401  std::string to_string() { return Z3_fixedpoint_to_string(ctx(), m_fp, 0, 0); }
3402  std::string to_string(expr_vector const& queries) {
3403  array<Z3_ast> qs(queries);
3404  return Z3_fixedpoint_to_string(ctx(), m_fp, qs.size(), qs.ptr());
3405  }
3406  };
3407  inline std::ostream & operator<<(std::ostream & out, fixedpoint const & f) { return out << Z3_fixedpoint_to_string(f.ctx(), f, 0, 0); }
3408 
3409  inline tactic fail_if(probe const & p) {
3410  Z3_tactic r = Z3_tactic_fail_if(p.ctx(), p);
3411  p.check_error();
3412  return tactic(p.ctx(), r);
3413  }
3414  inline tactic when(probe const & p, tactic const & t) {
3415  check_context(p, t);
3416  Z3_tactic r = Z3_tactic_when(t.ctx(), p, t);
3417  t.check_error();
3418  return tactic(t.ctx(), r);
3419  }
3420  inline tactic cond(probe const & p, tactic const & t1, tactic const & t2) {
3421  check_context(p, t1); check_context(p, t2);
3422  Z3_tactic r = Z3_tactic_cond(t1.ctx(), p, t1, t2);
3423  t1.check_error();
3424  return tactic(t1.ctx(), r);
3425  }
3426 
3427  inline symbol context::str_symbol(char const * s) { Z3_symbol r = Z3_mk_string_symbol(m_ctx, s); check_error(); return symbol(*this, r); }
3428  inline symbol context::int_symbol(int n) { Z3_symbol r = Z3_mk_int_symbol(m_ctx, n); check_error(); return symbol(*this, r); }
3429 
3430  inline sort context::bool_sort() { Z3_sort s = Z3_mk_bool_sort(m_ctx); check_error(); return sort(*this, s); }
3431  inline sort context::int_sort() { Z3_sort s = Z3_mk_int_sort(m_ctx); check_error(); return sort(*this, s); }
3432  inline sort context::real_sort() { Z3_sort s = Z3_mk_real_sort(m_ctx); check_error(); return sort(*this, s); }
3433  inline sort context::bv_sort(unsigned sz) { Z3_sort s = Z3_mk_bv_sort(m_ctx, sz); check_error(); return sort(*this, s); }
3434  inline sort context::string_sort() { Z3_sort s = Z3_mk_string_sort(m_ctx); check_error(); return sort(*this, s); }
3435  inline sort context::char_sort() { Z3_sort s = Z3_mk_char_sort(m_ctx); check_error(); return sort(*this, s); }
3436  inline sort context::seq_sort(sort& s) { Z3_sort r = Z3_mk_seq_sort(m_ctx, s); check_error(); return sort(*this, r); }
3437  inline sort context::re_sort(sort& s) { Z3_sort r = Z3_mk_re_sort(m_ctx, s); check_error(); return sort(*this, r); }
3438  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); }
3439 
3440  template<>
3441  inline sort context::fpa_sort<16>() { return fpa_sort(5, 11); }
3442 
3443  template<>
3444  inline sort context::fpa_sort<32>() { return fpa_sort(8, 24); }
3445 
3446  template<>
3447  inline sort context::fpa_sort<64>() { return fpa_sort(11, 53); }
3448 
3449  template<>
3450  inline sort context::fpa_sort<128>() { return fpa_sort(15, 113); }
3451 
3452  inline sort context::fpa_rounding_mode_sort() { Z3_sort r = Z3_mk_fpa_rounding_mode_sort(m_ctx); check_error(); return sort(*this, r); }
3453 
3454  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); }
3455  inline sort context::array_sort(sort_vector const& d, sort r) {
3456  array<Z3_sort> dom(d);
3457  Z3_sort s = Z3_mk_array_sort_n(m_ctx, dom.size(), dom.ptr(), r); check_error(); return sort(*this, s);
3458  }
3459  inline sort context::enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts) {
3460  array<Z3_symbol> _enum_names(n);
3461  for (unsigned i = 0; i < n; i++) { _enum_names[i] = Z3_mk_string_symbol(*this, enum_names[i]); }
3462  array<Z3_func_decl> _cs(n);
3463  array<Z3_func_decl> _ts(n);
3464  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3465  sort s = to_sort(*this, Z3_mk_enumeration_sort(*this, _name, n, _enum_names.ptr(), _cs.ptr(), _ts.ptr()));
3466  check_error();
3467  for (unsigned i = 0; i < n; i++) { cs.push_back(func_decl(*this, _cs[i])); ts.push_back(func_decl(*this, _ts[i])); }
3468  return s;
3469  }
3470  inline func_decl context::tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs) {
3471  array<Z3_symbol> _names(n);
3472  array<Z3_sort> _sorts(n);
3473  for (unsigned i = 0; i < n; i++) { _names[i] = Z3_mk_string_symbol(*this, names[i]); _sorts[i] = sorts[i]; }
3474  array<Z3_func_decl> _projs(n);
3475  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3476  Z3_func_decl tuple;
3477  sort _ignore_s = to_sort(*this, Z3_mk_tuple_sort(*this, _name, n, _names.ptr(), _sorts.ptr(), &tuple, _projs.ptr()));
3478  check_error();
3479  for (unsigned i = 0; i < n; i++) { projs.push_back(func_decl(*this, _projs[i])); }
3480  return func_decl(*this, tuple);
3481  }
3482 
3484  context& ctx;
3485  Z3_constructor_list clist;
3486  public:
3487  constructor_list(constructors const& cs);
3489  operator Z3_constructor_list() const { return clist; }
3490  };
3491 
3493  friend class constructor_list;
3494  context& ctx;
3495  std::vector<Z3_constructor> cons;
3496  std::vector<unsigned> num_fields;
3497  public:
3498  constructors(context& ctx): ctx(ctx) {}
3499 
3501  for (auto con : cons)
3502  Z3_del_constructor(ctx, con);
3503  }
3504 
3505  void add(symbol const& name, symbol const& rec, unsigned n, symbol const* names, sort const* fields) {
3506  array<unsigned> sort_refs(n);
3507  array<Z3_sort> sorts(n);
3508  array<Z3_symbol> _names(n);
3509  for (unsigned i = 0; i < n; ++i) sorts[i] = fields[i], _names[i] = names[i];
3510  cons.push_back(Z3_mk_constructor(ctx, name, rec, n, _names.ptr(), sorts.ptr(), sort_refs.ptr()));
3511  num_fields.push_back(n);
3512  }
3513 
3514  Z3_constructor operator[](unsigned i) const { return cons[i]; }
3515 
3516  unsigned size() const { return (unsigned)cons.size(); }
3517 
3518  void query(unsigned i, func_decl& constructor, func_decl& test, func_decl_vector& accs) {
3519  Z3_func_decl _constructor;
3520  Z3_func_decl _test;
3521  array<Z3_func_decl> accessors(num_fields[i]);
3522  accs.resize(0);
3524  cons[i],
3525  num_fields[i],
3526  &_constructor,
3527  &_test,
3528  accessors.ptr());
3529  constructor = func_decl(ctx, _constructor);
3530 
3531  test = func_decl(ctx, _test);
3532  for (unsigned j = 0; j < num_fields[i]; ++j)
3533  accs.push_back(func_decl(ctx, accessors[j]));
3534  }
3535  };
3536 
3537  inline constructor_list::constructor_list(constructors const& cs): ctx(cs.ctx) {
3538  array<Z3_constructor> cons(cs.size());
3539  for (unsigned i = 0; i < cs.size(); ++i)
3540  cons[i] = cs[i];
3541  clist = Z3_mk_constructor_list(ctx, cs.size(), cons.ptr());
3542  }
3543 
3544  inline sort context::datatype(symbol const& name, constructors const& cs) {
3545  array<Z3_constructor> _cs(cs.size());
3546  for (unsigned i = 0; i < cs.size(); ++i) _cs[i] = cs[i];
3547  Z3_sort s = Z3_mk_datatype(*this, name, cs.size(), _cs.ptr());
3548  check_error();
3549  return sort(*this, s);
3550  }
3551 
3552  inline sort_vector context::datatypes(
3553  unsigned n, symbol const* names,
3554  constructor_list *const* cons) {
3555  sort_vector result(*this);
3556  array<Z3_symbol> _names(n);
3557  array<Z3_sort> _sorts(n);
3558  array<Z3_constructor_list> _cons(n);
3559  for (unsigned i = 0; i < n; ++i)
3560  _names[i] = names[i], _cons[i] = *cons[i];
3561  Z3_mk_datatypes(*this, n, _names.ptr(), _sorts.ptr(), _cons.ptr());
3562  for (unsigned i = 0; i < n; ++i)
3563  result.push_back(sort(*this, _sorts[i]));
3564  return result;
3565  }
3566 
3567 
3568  inline sort context::datatype_sort(symbol const& name) {
3569  Z3_sort s = Z3_mk_datatype_sort(*this, name);
3570  check_error();
3571  return sort(*this, s);
3572  }
3573 
3574 
3575  inline sort context::uninterpreted_sort(char const* name) {
3576  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3577  return to_sort(*this, Z3_mk_uninterpreted_sort(*this, _name));
3578  }
3580  return to_sort(*this, Z3_mk_uninterpreted_sort(*this, name));
3581  }
3582 
3583  inline func_decl context::function(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3584  array<Z3_sort> args(arity);
3585  for (unsigned i = 0; i < arity; i++) {
3586  check_context(domain[i], range);
3587  args[i] = domain[i];
3588  }
3589  Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, arity, args.ptr(), range);
3590  check_error();
3591  return func_decl(*this, f);
3592  }
3593 
3594  inline func_decl context::function(char const * name, unsigned arity, sort const * domain, sort const & range) {
3595  return function(range.ctx().str_symbol(name), arity, domain, range);
3596  }
3597 
3598  inline func_decl context::function(symbol const& name, sort_vector const& domain, sort const& range) {
3599  array<Z3_sort> args(domain.size());
3600  for (unsigned i = 0; i < domain.size(); i++) {
3601  check_context(domain[i], range);
3602  args[i] = domain[i];
3603  }
3604  Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, domain.size(), args.ptr(), range);
3605  check_error();
3606  return func_decl(*this, f);
3607  }
3608 
3609  inline func_decl context::function(char const * name, sort_vector const& domain, sort const& range) {
3610  return function(range.ctx().str_symbol(name), domain, range);
3611  }
3612 
3613 
3614  inline func_decl context::function(char const * name, sort const & domain, sort const & range) {
3615  check_context(domain, range);
3616  Z3_sort args[1] = { domain };
3617  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 1, args, range);
3618  check_error();
3619  return func_decl(*this, f);
3620  }
3621 
3622  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & range) {
3623  check_context(d1, range); check_context(d2, range);
3624  Z3_sort args[2] = { d1, d2 };
3625  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 2, args, range);
3626  check_error();
3627  return func_decl(*this, f);
3628  }
3629 
3630  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range) {
3631  check_context(d1, range); check_context(d2, range); check_context(d3, range);
3632  Z3_sort args[3] = { d1, d2, d3 };
3633  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 3, args, range);
3634  check_error();
3635  return func_decl(*this, f);
3636  }
3637 
3638  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range) {
3639  check_context(d1, range); check_context(d2, range); check_context(d3, range); check_context(d4, range);
3640  Z3_sort args[4] = { d1, d2, d3, d4 };
3641  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 4, args, range);
3642  check_error();
3643  return func_decl(*this, f);
3644  }
3645 
3646  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) {
3647  check_context(d1, range); check_context(d2, range); check_context(d3, range); check_context(d4, range); check_context(d5, range);
3648  Z3_sort args[5] = { d1, d2, d3, d4, d5 };
3649  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 5, args, range);
3650  check_error();
3651  return func_decl(*this, f);
3652  }
3653 
3654  inline func_decl context::recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3655  array<Z3_sort> args(arity);
3656  for (unsigned i = 0; i < arity; i++) {
3657  check_context(domain[i], range);
3658  args[i] = domain[i];
3659  }
3660  Z3_func_decl f = Z3_mk_rec_func_decl(m_ctx, name, arity, args.ptr(), range);
3661  check_error();
3662  return func_decl(*this, f);
3663 
3664  }
3665 
3666  inline func_decl context::recfun(symbol const & name, sort_vector const& domain, sort const & range) {
3667  check_context(domain, range);
3668  array<Z3_sort> domain1(domain);
3669  Z3_func_decl f = Z3_mk_rec_func_decl(m_ctx, name, domain1.size(), domain1.ptr(), range);
3670  check_error();
3671  return func_decl(*this, f);
3672  }
3673 
3674  inline func_decl context::recfun(char const * name, sort_vector const& domain, sort const & range) {
3675  return recfun(str_symbol(name), domain, range);
3676 
3677  }
3678 
3679  inline func_decl context::recfun(char const * name, unsigned arity, sort const * domain, sort const & range) {
3680  return recfun(str_symbol(name), arity, domain, range);
3681  }
3682 
3683  inline func_decl context::recfun(char const * name, sort const& d1, sort const & range) {
3684  return recfun(str_symbol(name), 1, &d1, range);
3685  }
3686 
3687  inline func_decl context::recfun(char const * name, sort const& d1, sort const& d2, sort const & range) {
3688  sort dom[2] = { d1, d2 };
3689  return recfun(str_symbol(name), 2, dom, range);
3690  }
3691 
3692  inline void context::recdef(func_decl f, expr_vector const& args, expr const& body) {
3693  check_context(f, args); check_context(f, body);
3694  array<Z3_ast> vars(args);
3695  Z3_add_rec_def(f.ctx(), f, vars.size(), vars.ptr(), body);
3696  }
3697 
3698  inline func_decl context::user_propagate_function(symbol const& name, sort_vector const& domain, sort const& range) {
3699  check_context(domain, range);
3700  array<Z3_sort> domain1(domain);
3701  Z3_func_decl f = Z3_solver_propagate_declare(range.ctx(), name, domain1.size(), domain1.ptr(), range);
3702  check_error();
3703  return func_decl(*this, f);
3704  }
3705 
3706  inline expr context::constant(symbol const & name, sort const & s) {
3707  Z3_ast r = Z3_mk_const(m_ctx, name, s);
3708  check_error();
3709  return expr(*this, r);
3710  }
3711  inline expr context::constant(char const * name, sort const & s) { return constant(str_symbol(name), s); }
3712  inline expr context::variable(unsigned idx, sort const& s) {
3713  Z3_ast r = Z3_mk_bound(m_ctx, idx, s);
3714  check_error();
3715  return expr(*this, r);
3716  }
3717  inline expr context::bool_const(char const * name) { return constant(name, bool_sort()); }
3718  inline expr context::int_const(char const * name) { return constant(name, int_sort()); }
3719  inline expr context::real_const(char const * name) { return constant(name, real_sort()); }
3720  inline expr context::string_const(char const * name) { return constant(name, string_sort()); }
3721  inline expr context::bv_const(char const * name, unsigned sz) { return constant(name, bv_sort(sz)); }
3722  inline expr context::fpa_const(char const * name, unsigned ebits, unsigned sbits) { return constant(name, fpa_sort(ebits, sbits)); }
3723 
3724  template<size_t precision>
3725  inline expr context::fpa_const(char const * name) { return constant(name, fpa_sort<precision>()); }
3726 
3727  inline void context::set_rounding_mode(rounding_mode rm) { m_rounding_mode = rm; }
3728 
3730  switch (m_rounding_mode) {
3731  case RNA: return expr(*this, Z3_mk_fpa_rna(m_ctx));
3732  case RNE: return expr(*this, Z3_mk_fpa_rne(m_ctx));
3733  case RTP: return expr(*this, Z3_mk_fpa_rtp(m_ctx));
3734  case RTN: return expr(*this, Z3_mk_fpa_rtn(m_ctx));
3735  case RTZ: return expr(*this, Z3_mk_fpa_rtz(m_ctx));
3736  default: return expr(*this);
3737  }
3738  }
3739 
3740  inline expr context::bool_val(bool b) { return b ? expr(*this, Z3_mk_true(m_ctx)) : expr(*this, Z3_mk_false(m_ctx)); }
3741 
3742  inline expr context::int_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3743  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); }
3744  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); }
3745  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); }
3746  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); }
3747 
3748  inline expr context::real_val(int64_t n, int64_t d) { Z3_ast r = Z3_mk_real_int64(m_ctx, n, d); check_error(); return expr(*this, r); }
3749  inline expr context::real_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3750  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); }
3751  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); }
3752  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); }
3753  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); }
3754 
3755  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); }
3756  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); }
3757  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); }
3758  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); }
3759  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); }
3760  inline expr context::bv_val(unsigned n, bool const* bits) {
3761  array<bool> _bits(n);
3762  for (unsigned i = 0; i < n; ++i) _bits[i] = bits[i] ? 1 : 0;
3763  Z3_ast r = Z3_mk_bv_numeral(m_ctx, n, _bits.ptr()); check_error(); return expr(*this, r);
3764  }
3765 
3766  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); }
3767  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); }
3768  inline expr context::fpa_nan(sort const & s) { Z3_ast r = Z3_mk_fpa_nan(m_ctx, s); check_error(); return expr(*this, r); }
3769  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); }
3770 
3771  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); }
3772  inline expr context::string_val(char const* s) { Z3_ast r = Z3_mk_string(m_ctx, s); check_error(); return expr(*this, r); }
3773  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); }
3774  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); }
3775 
3776  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); }
3777 
3778  inline expr func_decl::operator()(unsigned n, expr const * args) const {
3779  array<Z3_ast> _args(n);
3780  for (unsigned i = 0; i < n; i++) {
3781  check_context(*this, args[i]);
3782  _args[i] = args[i];
3783  }
3784  Z3_ast r = Z3_mk_app(ctx(), *this, n, _args.ptr());
3785  check_error();
3786  return expr(ctx(), r);
3787 
3788  }
3789  inline expr func_decl::operator()(expr_vector const& args) const {
3790  array<Z3_ast> _args(args.size());
3791  for (unsigned i = 0; i < args.size(); i++) {
3792  check_context(*this, args[i]);
3793  _args[i] = args[i];
3794  }
3795  Z3_ast r = Z3_mk_app(ctx(), *this, args.size(), _args.ptr());
3796  check_error();
3797  return expr(ctx(), r);
3798  }
3799  inline expr func_decl::operator()() const {
3800  Z3_ast r = Z3_mk_app(ctx(), *this, 0, 0);
3801  ctx().check_error();
3802  return expr(ctx(), r);
3803  }
3804  inline expr func_decl::operator()(expr const & a) const {
3805  check_context(*this, a);
3806  Z3_ast args[1] = { a };
3807  Z3_ast r = Z3_mk_app(ctx(), *this, 1, args);
3808  ctx().check_error();
3809  return expr(ctx(), r);
3810  }
3811  inline expr func_decl::operator()(int a) const {
3812  Z3_ast args[1] = { ctx().num_val(a, domain(0)) };
3813  Z3_ast r = Z3_mk_app(ctx(), *this, 1, args);
3814  ctx().check_error();
3815  return expr(ctx(), r);
3816  }
3817  inline expr func_decl::operator()(expr const & a1, expr const & a2) const {
3818  check_context(*this, a1); check_context(*this, a2);
3819  Z3_ast args[2] = { a1, a2 };
3820  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3821  ctx().check_error();
3822  return expr(ctx(), r);
3823  }
3824  inline expr func_decl::operator()(expr const & a1, int a2) const {
3825  check_context(*this, a1);
3826  Z3_ast args[2] = { a1, ctx().num_val(a2, domain(1)) };
3827  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3828  ctx().check_error();
3829  return expr(ctx(), r);
3830  }
3831  inline expr func_decl::operator()(int a1, expr const & a2) const {
3832  check_context(*this, a2);
3833  Z3_ast args[2] = { ctx().num_val(a1, domain(0)), a2 };
3834  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3835  ctx().check_error();
3836  return expr(ctx(), r);
3837  }
3838  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3) const {
3839  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3);
3840  Z3_ast args[3] = { a1, a2, a3 };
3841  Z3_ast r = Z3_mk_app(ctx(), *this, 3, args);
3842  ctx().check_error();
3843  return expr(ctx(), r);
3844  }
3845  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4) const {
3846  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3); check_context(*this, a4);
3847  Z3_ast args[4] = { a1, a2, a3, a4 };
3848  Z3_ast r = Z3_mk_app(ctx(), *this, 4, args);
3849  ctx().check_error();
3850  return expr(ctx(), r);
3851  }
3852  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4, expr const & a5) const {
3853  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3); check_context(*this, a4); check_context(*this, a5);
3854  Z3_ast args[5] = { a1, a2, a3, a4, a5 };
3855  Z3_ast r = Z3_mk_app(ctx(), *this, 5, args);
3856  ctx().check_error();
3857  return expr(ctx(), r);
3858  }
3859 
3860  inline expr to_real(expr const & a) { Z3_ast r = Z3_mk_int2real(a.ctx(), a); a.check_error(); return expr(a.ctx(), r); }
3861 
3862  inline func_decl function(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3863  return range.ctx().function(name, arity, domain, range);
3864  }
3865  inline func_decl function(char const * name, unsigned arity, sort const * domain, sort const & range) {
3866  return range.ctx().function(name, arity, domain, range);
3867  }
3868  inline func_decl function(char const * name, sort const & domain, sort const & range) {
3869  return range.ctx().function(name, domain, range);
3870  }
3871  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & range) {
3872  return range.ctx().function(name, d1, d2, range);
3873  }
3874  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range) {
3875  return range.ctx().function(name, d1, d2, d3, range);
3876  }
3877  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range) {
3878  return range.ctx().function(name, d1, d2, d3, d4, range);
3879  }
3880  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) {
3881  return range.ctx().function(name, d1, d2, d3, d4, d5, range);
3882  }
3883  inline func_decl function(char const* name, sort_vector const& domain, sort const& range) {
3884  return range.ctx().function(name, domain, range);
3885  }
3886  inline func_decl function(std::string const& name, sort_vector const& domain, sort const& range) {
3887  return range.ctx().function(name.c_str(), domain, range);
3888  }
3889 
3890  inline func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3891  return range.ctx().recfun(name, arity, domain, range);
3892  }
3893  inline func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range) {
3894  return range.ctx().recfun(name, arity, domain, range);
3895  }
3896  inline func_decl recfun(char const * name, sort const& d1, sort const & range) {
3897  return range.ctx().recfun(name, d1, range);
3898  }
3899  inline func_decl recfun(char const * name, sort const& d1, sort const& d2, sort const & range) {
3900  return range.ctx().recfun(name, d1, d2, range);
3901  }
3902 
3903  inline expr select(expr const & a, expr const & i) {
3904  check_context(a, i);
3905  Z3_ast r = Z3_mk_select(a.ctx(), a, i);
3906  a.check_error();
3907  return expr(a.ctx(), r);
3908  }
3909  inline expr select(expr const & a, int i) {
3910  return select(a, a.ctx().num_val(i, a.get_sort().array_domain()));
3911  }
3912  inline expr select(expr const & a, expr_vector const & i) {
3913  check_context(a, i);
3914  array<Z3_ast> idxs(i);
3915  Z3_ast r = Z3_mk_select_n(a.ctx(), a, idxs.size(), idxs.ptr());
3916  a.check_error();
3917  return expr(a.ctx(), r);
3918  }
3919 
3920  inline expr store(expr const & a, expr const & i, expr const & v) {
3921  check_context(a, i); check_context(a, v);
3922  Z3_ast r = Z3_mk_store(a.ctx(), a, i, v);
3923  a.check_error();
3924  return expr(a.ctx(), r);
3925  }
3926 
3927  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); }
3928  inline expr store(expr const & a, expr i, int v) { return store(a, i, a.ctx().num_val(v, a.get_sort().array_range())); }
3929  inline expr store(expr const & a, int i, int v) {
3930  return store(a, a.ctx().num_val(i, a.get_sort().array_domain()), a.ctx().num_val(v, a.get_sort().array_range()));
3931  }
3932  inline expr store(expr const & a, expr_vector const & i, expr const & v) {
3933  check_context(a, i); check_context(a, v);
3934  array<Z3_ast> idxs(i);
3935  Z3_ast r = Z3_mk_store_n(a.ctx(), a, idxs.size(), idxs.ptr(), v);
3936  a.check_error();
3937  return expr(a.ctx(), r);
3938  }
3939 
3940  inline expr as_array(func_decl & f) {
3941  Z3_ast r = Z3_mk_as_array(f.ctx(), f);
3942  f.check_error();
3943  return expr(f.ctx(), r);
3944  }
3945 
3946 #define MK_EXPR1(_fn, _arg) \
3947  Z3_ast r = _fn(_arg.ctx(), _arg); \
3948  _arg.check_error(); \
3949  return expr(_arg.ctx(), r);
3950 
3951 #define MK_EXPR2(_fn, _arg1, _arg2) \
3952  check_context(_arg1, _arg2); \
3953  Z3_ast r = _fn(_arg1.ctx(), _arg1, _arg2); \
3954  _arg1.check_error(); \
3955  return expr(_arg1.ctx(), r);
3956 
3957  inline expr const_array(sort const & d, expr const & v) {
3958  MK_EXPR2(Z3_mk_const_array, d, v);
3959  }
3960 
3961  inline expr empty_set(sort const& s) {
3963  }
3964 
3965  inline expr full_set(sort const& s) {
3967  }
3968 
3969  inline expr set_add(expr const& s, expr const& e) {
3970  MK_EXPR2(Z3_mk_set_add, s, e);
3971  }
3972 
3973  inline expr set_del(expr const& s, expr const& e) {
3974  MK_EXPR2(Z3_mk_set_del, s, e);
3975  }
3976 
3977  inline expr set_union(expr const& a, expr const& b) {
3978  check_context(a, b);
3979  Z3_ast es[2] = { a, b };
3980  Z3_ast r = Z3_mk_set_union(a.ctx(), 2, es);
3981  a.check_error();
3982  return expr(a.ctx(), r);
3983  }
3984 
3985  inline expr set_intersect(expr const& a, expr const& b) {
3986  check_context(a, b);
3987  Z3_ast es[2] = { a, b };
3988  Z3_ast r = Z3_mk_set_intersect(a.ctx(), 2, es);
3989  a.check_error();
3990  return expr(a.ctx(), r);
3991  }
3992 
3993  inline expr set_difference(expr const& a, expr const& b) {
3995  }
3996 
3997  inline expr set_complement(expr const& a) {
3999  }
4000 
4001  inline expr set_member(expr const& s, expr const& e) {
4002  MK_EXPR2(Z3_mk_set_member, s, e);
4003  }
4004 
4005  inline expr set_subset(expr const& a, expr const& b) {
4006  MK_EXPR2(Z3_mk_set_subset, a, b);
4007  }
4008 
4009  // sequence and regular expression operations.
4010  // union is +
4011  // concat is overloaded to handle sequences and regular expressions
4012 
4013  inline expr empty(sort const& s) {
4014  Z3_ast r = Z3_mk_seq_empty(s.ctx(), s);
4015  s.check_error();
4016  return expr(s.ctx(), r);
4017  }
4018  inline expr suffixof(expr const& a, expr const& b) {
4019  check_context(a, b);
4020  Z3_ast r = Z3_mk_seq_suffix(a.ctx(), a, b);
4021  a.check_error();
4022  return expr(a.ctx(), r);
4023  }
4024  inline expr prefixof(expr const& a, expr const& b) {
4025  check_context(a, b);
4026  Z3_ast r = Z3_mk_seq_prefix(a.ctx(), a, b);
4027  a.check_error();
4028  return expr(a.ctx(), r);
4029  }
4030  inline expr indexof(expr const& s, expr const& substr, expr const& offset) {
4031  check_context(s, substr); check_context(s, offset);
4032  Z3_ast r = Z3_mk_seq_index(s.ctx(), s, substr, offset);
4033  s.check_error();
4034  return expr(s.ctx(), r);
4035  }
4036  inline expr last_indexof(expr const& s, expr const& substr) {
4037  check_context(s, substr);
4038  Z3_ast r = Z3_mk_seq_last_index(s.ctx(), s, substr);
4039  s.check_error();
4040  return expr(s.ctx(), r);
4041  }
4042  inline expr to_re(expr const& s) {
4044  }
4045  inline expr in_re(expr const& s, expr const& re) {
4046  MK_EXPR2(Z3_mk_seq_in_re, s, re);
4047  }
4048  inline expr plus(expr const& re) {
4049  MK_EXPR1(Z3_mk_re_plus, re);
4050  }
4051  inline expr option(expr const& re) {
4053  }
4054  inline expr star(expr const& re) {
4055  MK_EXPR1(Z3_mk_re_star, re);
4056  }
4057  inline expr re_empty(sort const& s) {
4058  Z3_ast r = Z3_mk_re_empty(s.ctx(), s);
4059  s.check_error();
4060  return expr(s.ctx(), r);
4061  }
4062  inline expr re_full(sort const& s) {
4063  Z3_ast r = Z3_mk_re_full(s.ctx(), s);
4064  s.check_error();
4065  return expr(s.ctx(), r);
4066  }
4067  inline expr re_intersect(expr_vector const& args) {
4068  assert(args.size() > 0);
4069  context& ctx = args[0u].ctx();
4070  array<Z3_ast> _args(args);
4071  Z3_ast r = Z3_mk_re_intersect(ctx, _args.size(), _args.ptr());
4072  ctx.check_error();
4073  return expr(ctx, r);
4074  }
4075  inline expr re_diff(expr const& a, expr const& b) {
4076  check_context(a, b);
4077  context& ctx = a.ctx();
4078  Z3_ast r = Z3_mk_re_diff(ctx, a, b);
4079  ctx.check_error();
4080  return expr(ctx, r);
4081  }
4082  inline expr re_complement(expr const& a) {
4084  }
4085  inline expr range(expr const& lo, expr const& hi) {
4086  check_context(lo, hi);
4087  Z3_ast r = Z3_mk_re_range(lo.ctx(), lo, hi);
4088  lo.check_error();
4089  return expr(lo.ctx(), r);
4090  }
4091 
4092 
4093 
4094 
4095 
4096  inline expr_vector context::parse_string(char const* s) {
4097  Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, 0, 0, 0, 0, 0, 0);
4098  check_error();
4099  return expr_vector(*this, r);
4100 
4101  }
4102  inline expr_vector context::parse_file(char const* s) {
4103  Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, 0, 0, 0, 0, 0, 0);
4104  check_error();
4105  return expr_vector(*this, r);
4106  }
4107 
4108  inline expr_vector context::parse_string(char const* s, sort_vector const& sorts, func_decl_vector const& decls) {
4109  array<Z3_symbol> sort_names(sorts.size());
4110  array<Z3_symbol> decl_names(decls.size());
4111  array<Z3_sort> sorts1(sorts);
4112  array<Z3_func_decl> decls1(decls);
4113  for (unsigned i = 0; i < sorts.size(); ++i) {
4114  sort_names[i] = sorts[i].name();
4115  }
4116  for (unsigned i = 0; i < decls.size(); ++i) {
4117  decl_names[i] = decls[i].name();
4118  }
4119 
4120  Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
4121  check_error();
4122  return expr_vector(*this, r);
4123  }
4124 
4125  inline expr_vector context::parse_file(char const* s, sort_vector const& sorts, func_decl_vector const& decls) {
4126  array<Z3_symbol> sort_names(sorts.size());
4127  array<Z3_symbol> decl_names(decls.size());
4128  array<Z3_sort> sorts1(sorts);
4129  array<Z3_func_decl> decls1(decls);
4130  for (unsigned i = 0; i < sorts.size(); ++i) {
4131  sort_names[i] = sorts[i].name();
4132  }
4133  for (unsigned i = 0; i < decls.size(); ++i) {
4134  decl_names[i] = decls[i].name();
4135  }
4136  Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
4137  check_error();
4138  return expr_vector(*this, r);
4139  }
4140 
4141  inline func_decl_vector sort::constructors() {
4142  assert(is_datatype());
4143  func_decl_vector cs(ctx());
4144  unsigned n = Z3_get_datatype_sort_num_constructors(ctx(), *this);
4145  for (unsigned i = 0; i < n; ++i)
4147  return cs;
4148  }
4149 
4150  inline func_decl_vector sort::recognizers() {
4151  assert(is_datatype());
4152  func_decl_vector rs(ctx());
4153  unsigned n = Z3_get_datatype_sort_num_constructors(ctx(), *this);
4154  for (unsigned i = 0; i < n; ++i)
4156  return rs;
4157  }
4158 
4159  inline func_decl_vector func_decl::accessors() {
4160  sort s = range();
4161  assert(s.is_datatype());
4162  unsigned n = Z3_get_datatype_sort_num_constructors(ctx(), s);
4163  unsigned idx = 0;
4164  for (; idx < n; ++idx) {
4166  if (id() == f.id())
4167  break;
4168  }
4169  assert(idx < n);
4170  n = arity();
4171  func_decl_vector as(ctx());
4172  for (unsigned i = 0; i < n; ++i)
4174  return as;
4175  }
4176 
4177 
4178  inline expr expr::substitute(expr_vector const& src, expr_vector const& dst) {
4179  assert(src.size() == dst.size());
4180  array<Z3_ast> _src(src.size());
4181  array<Z3_ast> _dst(dst.size());
4182  for (unsigned i = 0; i < src.size(); ++i) {
4183  _src[i] = src[i];
4184  _dst[i] = dst[i];
4185  }
4186  Z3_ast r = Z3_substitute(ctx(), m_ast, src.size(), _src.ptr(), _dst.ptr());
4187  check_error();
4188  return expr(ctx(), r);
4189  }
4190 
4191  inline expr expr::substitute(expr_vector const& dst) {
4192  array<Z3_ast> _dst(dst.size());
4193  for (unsigned i = 0; i < dst.size(); ++i) {
4194  _dst[i] = dst[i];
4195  }
4196  Z3_ast r = Z3_substitute_vars(ctx(), m_ast, dst.size(), _dst.ptr());
4197  check_error();
4198  return expr(ctx(), r);
4199  }
4200 
4201  inline expr expr::substitute(func_decl_vector const& funs, expr_vector const& dst) {
4202  array<Z3_ast> _dst(dst.size());
4203  array<Z3_func_decl> _funs(funs.size());
4204  if (dst.size() != funs.size()) {
4205  Z3_THROW(exception("length of argument lists don't align"));
4206  return expr(ctx(), nullptr);
4207  }
4208  for (unsigned i = 0; i < dst.size(); ++i) {
4209  _dst[i] = dst[i];
4210  _funs[i] = funs[i];
4211  }
4212  Z3_ast r = Z3_substitute_funs(ctx(), m_ast, dst.size(), _funs.ptr(), _dst.ptr());
4213  check_error();
4214  return expr(ctx(), r);
4215  }
4216 
4217  typedef std::function<void(expr const& proof, std::vector<unsigned> const& deps, expr_vector const& clause)> on_clause_eh_t;
4218 
4219  class on_clause {
4220  context& c;
4221  on_clause_eh_t m_on_clause;
4222 
4223  static void _on_clause_eh(void* _ctx, Z3_ast _proof, unsigned n, unsigned const* dep, Z3_ast_vector _literals) {
4224  on_clause* ctx = static_cast<on_clause*>(_ctx);
4225  expr_vector lits(ctx->c, _literals);
4226  expr proof(ctx->c, _proof);
4227  std::vector<unsigned> deps;
4228  for (unsigned i = 0; i < n; ++i)
4229  deps.push_back(dep[i]);
4230  ctx->m_on_clause(proof, deps, lits);
4231  }
4232  public:
4234  m_on_clause = on_clause_eh;
4235  Z3_solver_register_on_clause(c, s, this, _on_clause_eh);
4236  c.check_error();
4237  }
4238  };
4239 
4241 
4242  typedef std::function<void(expr const&, expr const&)> fixed_eh_t;
4243  typedef std::function<void(void)> final_eh_t;
4244  typedef std::function<void(expr const&, expr const&)> eq_eh_t;
4245  typedef std::function<void(expr const&)> created_eh_t;
4246  typedef std::function<void(expr, unsigned, bool)> decide_eh_t;
4247 
4248  final_eh_t m_final_eh;
4249  eq_eh_t m_eq_eh;
4250  fixed_eh_t m_fixed_eh;
4251  created_eh_t m_created_eh;
4252  decide_eh_t m_decide_eh;
4253  solver* s;
4254  context* c;
4255  std::vector<z3::context*> subcontexts;
4256 
4257  Z3_solver_callback cb { nullptr };
4258 
4259  struct scoped_cb {
4261  scoped_cb(void* _p, Z3_solver_callback cb):p(*static_cast<user_propagator_base*>(_p)) {
4262  p.cb = cb;
4263  }
4264  ~scoped_cb() {
4265  p.cb = nullptr;
4266  }
4267  };
4268 
4269  static void push_eh(void* _p, Z3_solver_callback cb) {
4270  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4271  scoped_cb _cb(p, cb);
4272  static_cast<user_propagator_base*>(p)->push();
4273  }
4274 
4275  static void pop_eh(void* _p, Z3_solver_callback cb, unsigned num_scopes) {
4276  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4277  scoped_cb _cb(p, cb);
4278  static_cast<user_propagator_base*>(_p)->pop(num_scopes);
4279  }
4280 
4281  static void* fresh_eh(void* _p, Z3_context ctx) {
4282  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4283  context* c = new context(ctx);
4284  p->subcontexts.push_back(c);
4285  return p->fresh(*c);
4286  }
4287 
4288  static void fixed_eh(void* _p, Z3_solver_callback cb, Z3_ast _var, Z3_ast _value) {
4289  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4290  scoped_cb _cb(p, cb);
4291  expr value(p->ctx(), _value);
4292  expr var(p->ctx(), _var);
4293  p->m_fixed_eh(var, value);
4294  }
4295 
4296  static void eq_eh(void* _p, Z3_solver_callback cb, Z3_ast _x, Z3_ast _y) {
4297  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4298  scoped_cb _cb(p, cb);
4299  expr x(p->ctx(), _x), y(p->ctx(), _y);
4300  p->m_eq_eh(x, y);
4301  }
4302 
4303  static void final_eh(void* p, Z3_solver_callback cb) {
4304  scoped_cb _cb(p, cb);
4305  static_cast<user_propagator_base*>(p)->m_final_eh();
4306  }
4307 
4308  static void created_eh(void* _p, Z3_solver_callback cb, Z3_ast _e) {
4309  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4310  scoped_cb _cb(p, cb);
4311  expr e(p->ctx(), _e);
4312  p->m_created_eh(e);
4313  }
4314 
4315  static void decide_eh(void* _p, Z3_solver_callback cb, Z3_ast _val, unsigned bit, bool is_pos) {
4316  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4317  scoped_cb _cb(p, cb);
4318  expr val(p->ctx(), _val);
4319  p->m_decide_eh(val, bit, is_pos);
4320  }
4321 
4322  public:
4323  user_propagator_base(context& c) : s(nullptr), c(&c) {}
4324 
4325  user_propagator_base(solver* s): s(s), c(nullptr) {
4326  Z3_solver_propagate_init(ctx(), *s, this, push_eh, pop_eh, fresh_eh);
4327  }
4328 
4329  virtual void push() = 0;
4330  virtual void pop(unsigned num_scopes) = 0;
4331 
4333  for (auto& subcontext : subcontexts) {
4334  subcontext->detach(); // detach first; the subcontexts will be freed internally!
4335  delete subcontext;
4336  }
4337  }
4338 
4340  return c ? *c : s->ctx();
4341  }
4342 
4351  virtual user_propagator_base* fresh(context& ctx) = 0;
4352 
4359  void register_fixed(fixed_eh_t& f) {
4360  m_fixed_eh = f;
4361  if (s) {
4362  Z3_solver_propagate_fixed(ctx(), *s, fixed_eh);
4363  }
4364  }
4365 
4367  m_fixed_eh = [this](expr const &id, expr const &e) {
4368  fixed(id, e);
4369  };
4370  if (s) {
4371  Z3_solver_propagate_fixed(ctx(), *s, fixed_eh);
4372  }
4373  }
4374 
4375  void register_eq(eq_eh_t& f) {
4376  m_eq_eh = f;
4377  if (s) {
4378  Z3_solver_propagate_eq(ctx(), *s, eq_eh);
4379  }
4380  }
4381 
4382  void register_eq() {
4383  m_eq_eh = [this](expr const& x, expr const& y) {
4384  eq(x, y);
4385  };
4386  if (s) {
4387  Z3_solver_propagate_eq(ctx(), *s, eq_eh);
4388  }
4389  }
4390 
4399  void register_final(final_eh_t& f) {
4400  m_final_eh = f;
4401  if (s) {
4402  Z3_solver_propagate_final(ctx(), *s, final_eh);
4403  }
4404  }
4405 
4407  m_final_eh = [this]() {
4408  final();
4409  };
4410  if (s) {
4411  Z3_solver_propagate_final(ctx(), *s, final_eh);
4412  }
4413  }
4414 
4415  void register_created(created_eh_t& c) {
4416  m_created_eh = c;
4417  if (s) {
4418  Z3_solver_propagate_created(ctx(), *s, created_eh);
4419  }
4420  }
4421 
4423  m_created_eh = [this](expr const& e) {
4424  created(e);
4425  };
4426  if (s) {
4427  Z3_solver_propagate_created(ctx(), *s, created_eh);
4428  }
4429  }
4430 
4431  void register_decide(decide_eh_t& c) {
4432  m_decide_eh = c;
4433  if (s) {
4434  Z3_solver_propagate_decide(ctx(), *s, decide_eh);
4435  }
4436  }
4437 
4439  m_decide_eh = [this](expr val, unsigned bit, bool is_pos) {
4440  decide(val, bit, is_pos);
4441  };
4442  if (s) {
4443  Z3_solver_propagate_decide(ctx(), *s, decide_eh);
4444  }
4445  }
4446 
4447  virtual void fixed(expr const& /*id*/, expr const& /*e*/) { }
4448 
4449  virtual void eq(expr const& /*x*/, expr const& /*y*/) { }
4450 
4451  virtual void final() { }
4452 
4453  virtual void created(expr const& /*e*/) {}
4454 
4455  virtual void decide(expr const& /*val*/, unsigned /*bit*/, bool /*is_pos*/) {}
4456 
4457  bool next_split(expr const& e, unsigned idx, Z3_lbool phase) {
4458  assert(cb);
4459  return Z3_solver_next_split(ctx(), cb, e, idx, phase);
4460  }
4461 
4476  void add(expr const& e) {
4477  if (cb)
4479  else if (s)
4481  else
4482  assert(false);
4483  }
4484 
4485  void conflict(expr_vector const& fixed) {
4486  assert(cb);
4487  expr conseq = ctx().bool_val(false);
4488  array<Z3_ast> _fixed(fixed);
4489  Z3_solver_propagate_consequence(ctx(), cb, fixed.size(), _fixed.ptr(), 0, nullptr, nullptr, conseq);
4490  }
4491 
4492  void conflict(expr_vector const& fixed, expr_vector const& lhs, expr_vector const& rhs) {
4493  assert(cb);
4494  assert(lhs.size() == rhs.size());
4495  expr conseq = ctx().bool_val(false);
4496  array<Z3_ast> _fixed(fixed);
4497  array<Z3_ast> _lhs(lhs);
4498  array<Z3_ast> _rhs(rhs);
4499  Z3_solver_propagate_consequence(ctx(), cb, fixed.size(), _fixed.ptr(), lhs.size(), _lhs.ptr(), _rhs.ptr(), conseq);
4500  }
4501 
4502  bool propagate(expr_vector const& fixed, expr const& conseq) {
4503  assert(cb);
4504  assert((Z3_context)conseq.ctx() == (Z3_context)ctx());
4505  array<Z3_ast> _fixed(fixed);
4506  return Z3_solver_propagate_consequence(ctx(), cb, _fixed.size(), _fixed.ptr(), 0, nullptr, nullptr, conseq);
4507  }
4508 
4509  bool propagate(expr_vector const& fixed,
4510  expr_vector const& lhs, expr_vector const& rhs,
4511  expr const& conseq) {
4512  assert(cb);
4513  assert((Z3_context)conseq.ctx() == (Z3_context)ctx());
4514  assert(lhs.size() == rhs.size());
4515  array<Z3_ast> _fixed(fixed);
4516  array<Z3_ast> _lhs(lhs);
4517  array<Z3_ast> _rhs(rhs);
4518 
4519  return Z3_solver_propagate_consequence(ctx(), cb, _fixed.size(), _fixed.ptr(), lhs.size(), _lhs.ptr(), _rhs.ptr(), conseq);
4520  }
4521  };
4522 
4523 }
4524 
4527 #undef Z3_THROW
4528 
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.
cube_generator cubes(expr_vector &vars)
Definition: z3++.h:2955
ast_vector_tpl(context &c)
Definition: z3++.h:590
void Z3_API Z3_solver_push(Z3_context c, Z3_solver s)
Create a backtracking point.
expr distinct(expr_vector const &args)
Definition: z3++.h:2446
expr mod(expr const &a, expr const &b)
Definition: z3++.h:1640
friend expr mk_or(expr_vector const &args)
Definition: z3++.h:2499
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.
expr bvadd_no_overflow(expr const &a, expr const &b, bool is_signed)
bit-vector overflow/underflow checks
Definition: z3++.h:2238
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_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...
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_fpa_fma(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2, Z3_ast t3)
Floating-point fused multiply-add.
void Z3_API Z3_stats_inc_ref(Z3_context c, Z3_stats s)
Increment the reference counter of the given statistics object.
void Z3_API Z3_solver_propagate_fixed(Z3_context c, Z3_solver s, Z3_fixed_eh fixed_eh)
register a callback for when an expression is bound to a fixed value. The supported expression types ...
Z3_ast Z3_API Z3_mk_true(Z3_context c)
Create an AST node representing true.
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_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c)
Create a new fixedpoint context.
user_propagator_base(solver *s)
Definition: z3++.h:4325
Z3_probe Z3_API Z3_probe_le(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is less than or equal to the va...
Z3_sort_kind
The different kinds of Z3 types (See Z3_get_sort_kind).
Definition: z3_api.h:108
bool is_numeral_u(unsigned &i) const
Definition: z3++.h:884
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
friend expr operator|(expr const &a, expr const &b)
Definition: z3++.h:1943
Z3_ast Z3_API Z3_mk_bvnor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nor.
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:4399
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.
std::string reason_unknown() const
Definition: z3++.h:2822
std::string help() const
Definition: z3++.h:3072
sort bool_sort()
Return the Boolean sort.
Definition: z3++.h:3430
void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p)
Set the given solver using the given parameters.
friend expr atmost(expr_vector const &es, unsigned bound)
Definition: z3++.h:2421
void check_parser_error() const
Definition: z3++.h:199
handle add_soft(expr const &e, char const *weight)
Definition: z3++.h:3297
friend expr operator+(expr const &a, expr const &b)
Definition: z3++.h:1728
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.
expr variable(unsigned index, sort const &s)
create a de-Bruijn variable.
Definition: z3++.h:3712
void add_const_interp(func_decl &f, expr &value)
Definition: z3++.h:2646
expr mk_and(expr_vector const &args)
Definition: z3++.h:2505
Z3_string Z3_API Z3_get_decl_rational_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the rational value, as a string, associated with a rational parameter.
friend expr pw(expr const &a, expr const &b)
Definition: z3++.h:1636
double as_double() const
Definition: z3++.h:890
bool is_numeral_i64(int64_t &i) const
Definition: z3++.h:881
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: ...
unsigned Z3_API Z3_get_string_length(Z3_context c, Z3_ast s)
Retrieve the length of the unescaped string constant stored in s.
bool as_binary(std::string &s) const
Definition: z3++.h:888
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_ast Z3_API Z3_mk_fpa_rtz(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardZero rounding mode.
void set(char const *k, bool v)
Definition: z3++.h:2759
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
model(context &c)
Definition: z3++.h:2583
friend expr bv2int(expr const &a, bool is_signed)
bit-vector and integer conversions.
Definition: z3++.h:2232
bool is_int() const
Return true if this sort is the Integer sort.
Definition: z3++.h:683
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
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_ast Z3_API Z3_mk_mod(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 mod arg2.
iterator & operator++()
Definition: z3++.h:1612
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...
tactic & operator=(tactic const &s)
Definition: z3++.h:3055
expr operator[](expr const &index) const
Definition: z3++.h:1563
sort re_sort(sort &seq_sort)
Return a regular expression sort over sequences seq_sort.
Definition: z3++.h:3437
void Z3_API Z3_del_constructor(Z3_context c, Z3_constructor constr)
Reclaim memory allocated to constructor.
expr sle(expr const &a, expr const &b)
signed less than or equal to operator for bitvectors.
Definition: z3++.h:2128
expr bvredand(expr const &a)
Definition: z3++.h:1988
void add_fact(func_decl &f, unsigned *args)
Definition: z3++.h:3376
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.
probe(context &c, Z3_probe s)
Definition: z3++.h:3179
void Z3_API Z3_goal_reset(Z3_context c, Z3_goal g)
Erase all formulas from the given goal.
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.
expr pbeq(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2413
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.
friend expr xnor(expr const &a, expr const &b)
Definition: z3++.h:1949
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.
Z3_func_decl Z3_API Z3_get_datatype_sort_constructor_accessor(Z3_context c, Z3_sort t, unsigned idx_c, unsigned idx_a)
Return idx_a'th accessor for the idx_c'th constructor.
probe & operator=(probe const &s)
Definition: z3++.h:3183
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...
func_decl get_const_decl(unsigned i) const
Definition: z3++.h:2609
Z3_ast Z3_API Z3_mk_bound(Z3_context c, unsigned index, Z3_sort ty)
Create a variable.
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:4359
Z3_string Z3_API Z3_get_error_msg(Z3_context c, Z3_error_code err)
Return a string describing the given error code.
unsigned get_num_levels(func_decl &p)
Definition: z3++.h:3387
std::string documentation(symbol const &s)
Definition: z3++.h:518
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_mul(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] * ... * args[num_args-1].
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_func_decl Z3_API Z3_mk_transitive_closure(Z3_context c, Z3_func_decl f)
create transitive closure of binary relation.
void Z3_API Z3_tactic_inc_ref(Z3_context c, Z3_tactic t)
Increment the reference counter of the given tactic.
virtual void eq(expr const &, expr const &)
Definition: z3++.h:4449
friend expr operator>=(expr const &a, expr const &b)
Definition: z3++.h:1782
#define Z3_THROW(x)
Definition: z3++.h:103
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...
iterator & operator++() noexcept
Definition: z3++.h:635
bool is_array() const
Return true if this is a Array expression.
Definition: z3++.h:843
unsigned id() const
retrieve unique identifier for expression.
Definition: z3++.h:1056
void Z3_API Z3_solver_pop(Z3_context c, Z3_solver s, unsigned n)
Backtrack n backtracking points.
Z3_symbol Z3_API Z3_get_decl_name(Z3_context c, Z3_func_decl d)
Return the constant declaration name as a symbol.
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_sort Z3_API Z3_mk_fpa_sort(Z3_context c, unsigned ebits, unsigned sbits)
Create a FloatingPoint sort.
symbol str_symbol(char const *s)
Create a Z3 symbol based on the given string.
Definition: z3++.h:3427
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.
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:2227
void Z3_API Z3_simplifier_dec_ref(Z3_context c, Z3_simplifier g)
Decrement the reference counter of the given simplifier.
Z3_ast Z3_API Z3_mk_full_set(Z3_context c, Z3_sort domain)
Create the full set.
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 set(char const *k, symbol const &s)
Definition: z3++.h:541
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...
friend std::ostream & operator<<(std::ostream &out, sort const &s)
Definition: z3++.h:748
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_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...
friend bool eq(ast const &a, ast const &b)
Return true if the ASTs are structurally identical.
Definition: z3++.h:583
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...
func_decl piecewise_linear_order(sort const &a, unsigned index)
Definition: z3++.h:2275
void Z3_API Z3_ast_vector_inc_ref(Z3_context c, Z3_ast_vector v)
Increment the reference counter of the given AST vector.
void push()
Create a backtracking point.
Definition: z3++.h:2774
friend expr bvmul_no_overflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2256
expr length() const
Definition: z3++.h:1499
expr bvsub_no_underflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2247
Z3_string Z3_API Z3_ast_to_string(Z3_context c, Z3_ast a)
Convert the given AST node into a string.
stats statistics() const
Definition: z3++.h:2823
Z3_symbol Z3_API Z3_mk_string_symbol(Z3_context c, Z3_string s)
Create a Z3 symbol using a C string.
tactic cond(probe const &p, tactic const &t1, tactic const &t2)
Definition: z3++.h:3420
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_unary_minus(Z3_context c, Z3_ast arg)
Create an AST node representing - arg.
friend expr bvadd_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2241
solver(context &c, simple)
Definition: z3++.h:2743
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.
expr(context &c)
Definition: z3++.h:812
friend expr fp_eq(expr const &a, expr const &b)
Definition: z3++.h:2021
char const * msg() const
Definition: z3++.h:93
void Z3_API Z3_add_const_interp(Z3_context c, Z3_model m, Z3_func_decl f, Z3_ast a)
Add a constant interpretation.
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
expr bv_val(int n, unsigned sz)
Definition: z3++.h:3755
Z3_ast Z3_API Z3_mk_bvsgt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than.
expr operator!=(expr const &a, expr const &b)
Definition: z3++.h:1716
expr value() const
Definition: z3++.h:2539
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
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_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_sort Z3_API Z3_mk_int_sort(Z3_context c)
Create the integer type.
friend expr bvsub_no_underflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2247
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, again represented as a floating-point number.
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...
bool is_real() const
Return true if this is a real expression.
Definition: z3++.h:831
Definition: z3_api.h:1345
func_interp & operator=(func_interp const &s)
Definition: z3++.h:2555
friend expr operator!=(expr const &a, expr const &b)
Definition: z3++.h:1716
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...
func_decl_vector recognizers()
Definition: z3++.h:4150
friend expr bvredor(expr const &a)
Definition: z3++.h:1982
expr fpa_rounding_mode()
Definition: z3++.h:3729
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_xor(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 xor t2.
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...
probe(context &c, double val)
Definition: z3++.h:3178
bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a)
Return true if the given AST is a real algebraic number.
uint64_t as_uint64() const
Definition: z3++.h:891
expr itos() const
Definition: z3++.h:1509
Definition: z3++.h:136
std::string help() const
Definition: z3++.h:3347
Z3_ast Z3_API Z3_mk_store(Z3_context c, Z3_ast a, Z3_ast i, Z3_ast v)
Array update.
func_entry & operator=(func_entry const &s)
Definition: z3++.h:2532
Z3_ast Z3_API Z3_mk_const(Z3_context c, Z3_symbol s, Z3_sort ty)
Declare and create a constant.
Z3_ast Z3_API Z3_ast_vector_get(Z3_context c, Z3_ast_vector v, unsigned i)
Return the AST at position i in the AST vector v.
void set(char const *param, char const *value)
Set global parameter param with string value.
Definition: z3++.h:121
expr_vector units() const
Definition: z3++.h:2827
Z3_simplifier Z3_API Z3_simplifier_and_then(Z3_context c, Z3_simplifier t1, Z3_simplifier t2)
Return a simplifier that applies t1 to a given goal and t2 to every subgoal produced by t1...
constructor_list(constructors const &cs)
Definition: z3++.h:3537
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...
void set(char const *k, char const *v)
Definition: z3++.h:2763
simplifier(simplifier const &s)
Definition: z3++.h:3138
expr is_digit() const
Definition: z3++.h:1539
Definition: z3++.h:143
expr fma(expr const &a, expr const &b, expr const &c, expr const &rm)
Definition: z3++.h:2030
tactic when(probe const &p, tactic const &t)
Definition: z3++.h:3414
Z3_probe Z3_API Z3_probe_const(Z3_context x, double val)
Return a probe that always evaluates to val.
void set_else(expr &value)
Definition: z3++.h:2569
friend expr round_fpa_to_closest_integer(expr const &t)
Round a floating-point term into its closest integer.
Definition: z3++.h:2081
config()
Definition: z3++.h:115
friend std::ostream & operator<<(std::ostream &out, params const &p)
Definition: z3++.h:546
void set(char const *k, double n)
Definition: z3++.h:540
void Z3_API Z3_stats_dec_ref(Z3_context c, Z3_stats s)
Decrement the reference counter of the given statistics object.
Z3_sort Z3_API Z3_get_array_sort_range(Z3_context c, Z3_sort t)
Return the range of the given array sort.
expr lower(handle const &h)
Definition: z3++.h:3331
cube_generator cubes()
Definition: z3++.h:2954
bool is_numeral_u64(uint64_t &i) const
Definition: z3++.h:882
friend expr operator/(expr const &a, expr const &b)
Definition: z3++.h:1802
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 ...
std::string help() const
Definition: z3++.h:3148
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
void set(char const *param, char const *value)
Update global parameter param with string value.
Definition: z3++.h:217
array(unsigned sz)
Definition: z3++.h:457
handle add_soft(expr const &e, unsigned weight)
Definition: z3++.h:3292
expr mk_is_inf() const
Return Boolean expression to test for whether an FP expression is inf.
Definition: z3++.h:938
std::ostream & operator<<(std::ostream &out, exception const &e)
Definition: z3++.h:97
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_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 ...
A Z3 sort (aka type). Every expression (i.e., formula or term) in Z3 has a sort.
Definition: z3++.h:656
optimize(context &c, optimize &src)
Definition: z3++.h:3261
~solver()
Definition: z3++.h:2749
Z3_param_descrs Z3_API Z3_simplifier_get_param_descrs(Z3_context c, Z3_simplifier t)
Return the parameter description set for the given simplifier object.
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. The result is the new AST. The arrays from and to must have size num_exprs. For every i smaller than num_exprs, we must have that sort of from[i] must be equal to sort of to[i].
expr simplify() const
Return a simplified version of this expression.
Definition: z3++.h:1578
unsigned bv_size() const
Return the size of this Bit-vector sort.
Definition: z3++.h:730
bool is_bv() const
Return true if this sort is a Bit-vector sort.
Definition: z3++.h:695
Z3_ast Z3_API Z3_mk_bvuge(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than or equal to.
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
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_optimize Z3_API Z3_mk_optimize(Z3_context c)
Create a new optimize context.
void Z3_API Z3_optimize_assert(Z3_context c, Z3_optimize o, Z3_ast a)
Assert hard constraint to the optimization context.
func_decl(context &c)
Definition: z3++.h:761
int to_int() const
Definition: z3++.h:486
friend expr operator^(expr const &a, expr const &b)
Definition: z3++.h:1939
void pop_back()
Definition: z3++.h:602
expr full_set(sort const &s)
Definition: z3++.h:3965
def on_clause_eh(ctx, p, n, dep, clause)
Definition: z3py.py:11480
model(model &src, context &dst, translate)
Definition: z3++.h:2586
void Z3_API Z3_del_context(Z3_context c)
Delete the given logical context.
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 Z3_API Z3_mk_datatype(Z3_context c, Z3_symbol name, unsigned num_constructors, Z3_constructor constructors[])
Create datatype, such as lists, trees, records, enumerations or unions of records. The datatype may be recursive. Return the datatype sort.
friend expr fpa_to_ubv(expr const &t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.
Definition: z3++.h:2053
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
friend std::ostream & operator<<(std::ostream &out, ast const &n)
Definition: z3++.h:579
Z3_ast Z3_API Z3_mk_set_del(Z3_context c, Z3_ast set, Z3_ast elem)
Remove an element to a set.
bool is_true() const
Definition: z3++.h:1293
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_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_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.
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:3433
void interrupt()
Interrupt the current procedure being executed by any object managed by this context. This is a soft interruption: there is no guarantee the object will actually stop.
Definition: z3++.h:234
bool is_double(unsigned i) const
Definition: z3++.h:2679
expr lshr(expr const &a, expr const &b)
logic shift right operator for bitvectors
Definition: z3++.h:2213
expr udiv(expr const &a, expr const &b)
unsigned division operator for bitvectors.
Definition: z3++.h:2178
void add(expr const &e)
tracks e by a unique identifier that is returned by the call.
Definition: z3++.h:4476
apply_result operator()(goal const &g) const
Definition: z3++.h:3069
Z3_ast Z3_API Z3_mk_le(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than or equal to.
bool empty() const
Definition: z3++.h:603
T back() const
Definition: z3++.h:601
solver mk_solver() const
Definition: z3++.h:3062
friend expr concat(expr const &a, expr const &b)
Definition: z3++.h:2455
friend expr mod(expr const &a, expr const &b)
Definition: z3++.h:1640
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_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...
expr upper(handle const &h)
Definition: z3++.h:3336
Z3_goal_prec
Z3 custom error handler (See Z3_set_error_handler).
Definition: z3_api.h:1384
Z3_error_code
Z3 error codes (See Z3_get_error_code).
Definition: z3_api.h:1343
goal(context &c, Z3_goal s)
Definition: z3++.h:2968
optimize(optimize const &o)
Definition: z3++.h:3258
optimize & operator=(optimize const &o)
Definition: z3++.h:3268
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].
std::string to_string() const
Definition: z3++.h:519
expr eval(expr const &n, bool model_completion=false) const
Definition: z3++.h:2597
model(context &c, Z3_model m)
Definition: z3++.h:2584
Z3_ast_kind kind() const
Definition: z3++.h:568
sort array_sort(sort d, sort r)
Return an array sort for arrays from d to r.
Definition: z3++.h:3454
expr constant(symbol const &name, sort const &s)
create an uninterpreted constant.
Definition: z3++.h:3706
void pop()
Definition: z3++.h:3313
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.
friend simplifier operator&(simplifier const &t1, simplifier const &t2)
Definition: z3++.h:3157
unsigned Z3_API Z3_get_decl_num_parameters(Z3_context c, Z3_func_decl d)
Return the number of parameters associated with a declaration.
func_decl operator[](int i) const
Definition: z3++.h:2612
bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast t1, Z3_ast t2)
Compare terms.
check_result query(expr &q)
Definition: z3++.h:3377
bool is_ite() const
Definition: z3++.h:1301
unsigned fpa_sbits() const
Definition: z3++.h:734
fixedpoint(context &c)
Definition: z3++.h:3354
Z3_ast Z3_API Z3_mk_bvule(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than or equal to.
sort char_sort()
Return the sort for Unicode characters.
Definition: z3++.h:3435
constructors(context &ctx)
Definition: z3++.h:3498
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_string Z3_API Z3_ast_vector_to_string(Z3_context c, Z3_ast_vector v)
Convert AST vector into a string.
tactic(tactic const &s)
Definition: z3++.h:3052
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...
double get_double() const
Definition: z3++.h:2727
friend expr operator||(expr const &a, expr const &b)
Return an expression representing a or b.
Definition: z3++.h:1692
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:210
~probe()
Definition: z3++.h:3181
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...
bool is_datatype() const
Return true if this is a Datatype expression.
Definition: z3++.h:847
void add(expr const &e, expr const &t)
Definition: z3++.h:3284
Z3_decl_kind Z3_API Z3_get_decl_kind(Z3_context c, Z3_func_decl d)
Return declaration kind corresponding to declaration.
~tactic()
Definition: z3++.h:3053
bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a)
Determine if ast is an existential quantifier.
sort operator()(context &c, Z3_ast a)
Definition: z3++.h:2300
check_result check()
Definition: z3++.h:3316
expr ubv_to_fpa(expr const &t, sort s)
Definition: z3++.h:2067
simplifier(context &c, Z3_simplifier s)
Definition: z3++.h:3137
Z3_ast Z3_API Z3_mk_re_intersect(Z3_context c, unsigned n, Z3_ast const args[])
Create the intersection of the regular languages.
expr rotate_left(unsigned i) const
Definition: z3++.h:1404
friend probe operator||(probe const &p1, probe const &p2)
Definition: z3++.h:3240
expr is_int(expr const &e)
Definition: z3++.h:1676
void Z3_API Z3_optimize_inc_ref(Z3_context c, Z3_optimize d)
Increment the reference counter of the given optimize context.
expr fpa_to_fpa(expr const &t, sort s)
Definition: z3++.h:2074
expr contains(expr const &s) const
Definition: z3++.h:1481
friend expr bvadd_no_overflow(expr const &a, expr const &b, bool is_signed)
bit-vector overflow/underflow checks
Definition: z3++.h:2238
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.
iterator operator++(int) noexcept
Definition: z3++.h:642
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...
expr operator^(expr const &a, expr const &b)
Definition: z3++.h:1939
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.
friend std::ostream & operator<<(std::ostream &out, optimize const &s)
Definition: z3++.h:3349
Z3_ast Z3_API Z3_mk_const_array(Z3_context c, Z3_sort domain, Z3_ast v)
Create the constant array.
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].
void from_string(char const *constraints)
Definition: z3++.h:3346
void add(expr const &e, char const *p)
Definition: z3++.h:3288
unsigned lo() const
Definition: z3++.h:1418
Exception used to sign API usage errors.
Definition: z3++.h:88
expr operator*(expr const &a, expr const &b)
Definition: z3++.h:1758
Z3_stats Z3_API Z3_fixedpoint_get_statistics(Z3_context c, Z3_fixedpoint d)
Retrieve statistics information from the last call to Z3_fixedpoint_query.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
unsigned uint_value(unsigned i) const
Definition: z3++.h:2680
unsigned Z3_API Z3_get_sort_id(Z3_context c, Z3_sort s)
Return a unique identifier for s.
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. However, in the context returned by this function, the user is responsible for managing Z3_ast reference counters. Managing reference counters is a burden and error-prone, but allows the user to use the memory more efficiently. The user must invoke Z3_inc_ref for any Z3_ast returned by Z3, and Z3_dec_ref whenever the Z3_ast is not needed anymore. This idiom is similar to the one used in BDD (binary decision diagrams) packages such as CUDD.
Z3_string Z3_API Z3_simplifier_get_help(Z3_context c, Z3_simplifier t)
Return a string containing a description of parameters accepted by the given simplifier.
Z3_apply_result Z3_API Z3_tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g)
Apply tactic t to the goal g.
expr nth(expr const &index) const
Definition: z3++.h:1493
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...
ast_vector_tpl(context &c, Z3_ast_vector v)
Definition: z3++.h:591
A Z3 expression is used to represent formulas and terms. For Z3, a formula is any expression of sort ...
Definition: z3++.h:810
void reset_params()
Definition: z3++.h:83
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_string Z3_API Z3_sort_to_string(Z3_context c, Z3_sort s)
expr operator!(expr const &a)
Definition: z3++.h:1674
ast_vector_tpl & set(unsigned idx, ast &a)
Definition: z3++.h:611
expr set_subset(expr const &a, expr const &b)
Definition: z3++.h:4005
Z3_ast Z3_API Z3_mk_empty_set(Z3_context c, Z3_sort domain)
Create the empty set.
void add(expr_vector const &es)
Definition: z3++.h:3281
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.
void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s)
Remove all assertions from the solver.
unsigned num_exprs() const
Definition: z3++.h:2987
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_fpa_is_subnormal(Z3_context c, Z3_ast t)
Predicate indicating whether t is a subnormal floating-point number.
bool is_uint(unsigned i) const
Definition: z3++.h:2678
expr ule(expr const &a, expr const &b)
unsigned less than or equal to operator for bitvectors.
Definition: z3++.h:2154
expr in_re(expr const &s, expr const &re)
Definition: z3++.h:4045
symbol name(unsigned i)
Definition: z3++.h:516
expr re_diff(expr const &a, expr const &b)
Definition: z3++.h:4075
void Z3_API Z3_ast_vector_resize(Z3_context c, Z3_ast_vector v, unsigned n)
Resize the AST vector v.
expr_vector unsat_core() const
Definition: z3++.h:2824
bool is_lambda() const
Return true if this expression is a lambda expression.
Definition: z3++.h:919
iterator end() const
Definition: z3++.h:647
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
bool is_fpa() const
Return true if this is a FloatingPoint expression. .
Definition: z3++.h:873
Z3_parameter_kind Z3_API Z3_get_decl_parameter_kind(Z3_context c, Z3_func_decl d, unsigned idx)
Return the parameter type associated with a declaration.
sort datatype_sort(symbol const &name)
a reference to a recursively defined datatype. Expect that it gets defined as a datatype.
Definition: z3++.h:3568
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_error_code check_error() const
Definition: z3++.h:474
Z3_ast_vector Z3_API Z3_solver_get_units(Z3_context c, Z3_solver s)
Return the set of units modulo model conversion.
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.
void set(char const *param, int value)
Update global parameter param with Integer value.
Definition: z3++.h:225
static param_descrs simplify_param_descrs(context &c)
Definition: z3++.h:512
friend expr mk_and(expr_vector const &args)
Definition: z3++.h:2505
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.
unsigned num_entries() const
Definition: z3++.h:2563
Z3_ast Z3_API Z3_mk_fpa_rne(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToEven rounding mode...
cube_iterator begin()
Definition: z3++.h:2949
unsigned arity() const
Definition: z3++.h:770
iterator begin()
Definition: z3++.h:1616
Z3_func_decl Z3_API Z3_get_datatype_sort_recognizer(Z3_context c, Z3_sort t, unsigned idx)
Return idx'th recognizer.
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
sort_vector datatypes(unsigned n, symbol const *names, constructor_list *const *cons)
Create a set of mutually recursive datatypes. n - number of recursive datatypes names - array of name...
Definition: z3++.h:3552
void update_rule(expr &rule, symbol const &name)
Definition: z3++.h:3386
bool enable_exceptions() const
Definition: z3++.h:212
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...
bool is_finite_domain() const
Return true if this sort is a Finite domain sort.
Definition: z3++.h:719
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...
func_decl operator()(context &c, Z3_ast a)
Definition: z3++.h:2308
std::string to_string(expr_vector const &queries)
Definition: z3++.h:3402
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.
ast_vector_tpl< func_decl > func_decl_vector
Definition: z3++.h:78
stats(context &c)
Definition: z3++.h:2664
expr algebraic_upper(unsigned precision) const
Definition: z3++.h:1026
Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s)
Return statistics for the given solver.
void Z3_API Z3_ast_vector_dec_ref(Z3_context c, Z3_ast_vector v)
Decrement the reference counter of the given AST vector.
expr operator>=(expr const &a, expr const &b)
Definition: z3++.h:1782
std::string reason_unknown()
Definition: z3++.h:3385
#define MK_EXPR2(_fn, _arg1, _arg2)
Definition: z3++.h:3951
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...
expr replace(expr const &src, expr const &dst) const
Definition: z3++.h:1470
void add_entry(expr_vector const &args, expr &value)
Definition: z3++.h:2565
Z3_symbol Z3_API Z3_get_decl_symbol_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the double value associated with an double parameter.
Z3_ast Z3_API Z3_mk_set_intersect(Z3_context c, unsigned num_args, Z3_ast const args[])
Take the intersection of a list of sets.
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
expr pw(expr const &a, expr const &b)
Definition: z3++.h:1636
Z3_func_decl Z3_API Z3_get_app_decl(Z3_context c, Z3_app a)
Return the declaration of a constant or function application.
friend std::ostream & operator<<(std::ostream &out, goal const &g)
Definition: z3++.h:3017
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:2038
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...
friend probe operator>=(probe const &p1, probe const &p2)
Definition: z3++.h:3217
expr(context &c, Z3_ast n)
Definition: z3++.h:813
~goal()
Definition: z3++.h:2970
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...
expr set_difference(expr const &a, expr const &b)
Definition: z3++.h:3993
symbol name() const
Return name of sort.
Definition: z3++.h:675
T * operator->() const
Definition: z3++.h:643
unsigned Z3_API Z3_ast_vector_size(Z3_context c, Z3_ast_vector v)
Return the size of the given AST vector.
Z3_ast Z3_API Z3_mk_real_int64(Z3_context c, int64_t num, int64_t den)
Create a real from a fraction of int64.
bool is_and() const
Definition: z3++.h:1296
unsigned id() const
retrieve unique identifier for func_decl.
Definition: z3++.h:768
expr operator~(expr const &a)
Definition: z3++.h:2028
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.
expr operator[](int i) const
Definition: z3++.h:2982
bool propagate(expr_vector const &fixed, expr const &conseq)
Definition: z3++.h:4502
Z3_ast Z3_API Z3_mk_fpa_rtn(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardNegative rounding mode...
expr_vector assertions() const
Definition: z3++.h:3396
friend expr int2bv(unsigned n, expr const &a)
Definition: z3++.h:2233
expr_vector assertions() const
Definition: z3++.h:3341
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
expr_vector unsat_core() const
Definition: z3++.h:3329
friend expr operator-(expr const &a)
Definition: z3++.h:1824
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a string.
Z3_error_code Z3_API Z3_get_error_code(Z3_context c)
Return the error code for the last API call.
friend expr distinct(expr_vector const &args)
Definition: z3++.h:2446
check_result check(unsigned n, expr *const assumptions)
Definition: z3++.h:2795
Z3_ast Z3_API Z3_mk_bvnand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nand.
expr bvredor(expr const &a)
Definition: z3++.h:1982
expr rem(expr const &a, expr const &b)
Definition: z3++.h:1656
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.
friend expr operator*(expr const &a, expr const &b)
Definition: z3++.h:1758
probe(context &c, char const *name)
Definition: z3++.h:3177
friend std::ostream & operator<<(std::ostream &out, solver const &s)
Definition: z3++.h:2958
iterator operator++(int)
Definition: z3++.h:1613
Z3_ast Z3_API Z3_mk_bvslt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than.
#define MK_EXPR1(_fn, _arg)
Definition: z3++.h:3946
expr get_answer()
Definition: z3++.h:3384
Z3_sort Z3_API Z3_mk_string_sort(Z3_context c)
Create a sort for unicode strings.
~stats()
Definition: z3++.h:2667
bool is_forall() const
Return true if this expression is a universal quantifier.
Definition: z3++.h:911
friend expr min(expr const &a, expr const &b)
Definition: z3++.h:1950
sort seq_sort(sort &s)
Return a sequence sort over base sort s.
Definition: z3++.h:3436
void Z3_API Z3_optimize_set_params(Z3_context c, Z3_optimize o, Z3_params p)
Set parameters on optimization context.
friend expr bvmul_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2259
bool next_split(expr const &e, unsigned idx, Z3_lbool phase)
Definition: z3++.h:4457
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_solver_assert(Z3_context c, Z3_solver s, Z3_ast a)
Assert a constraint into the solver.
friend expr operator<=(expr const &a, expr const &b)
Definition: z3++.h:1866
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...
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_bit2bool(Z3_context c, unsigned i, Z3_ast t1)
Extracts the bit at position i of a bit-vector and yields a boolean.
expr bvmul_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2259
friend expr bvredand(expr const &a)
Definition: z3++.h:1988
expr get_const_interp(func_decl c) const
Definition: z3++.h:2620
Z3_model Z3_API Z3_solver_get_model(Z3_context c, Z3_solver s)
Retrieve the model for the last Z3_solver_check or Z3_solver_check_assumptions.
Z3_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_del_constructor_list(Z3_context c, Z3_constructor_list clist)
Reclaim memory allocated for constructor list.
Z3_constructor Z3_API Z3_mk_constructor(Z3_context c, Z3_symbol name, Z3_symbol recognizer, unsigned num_fields, Z3_symbol const field_names[], Z3_sort_opt const sorts[], unsigned sort_refs[])
Create a constructor.
A Context manages all other Z3 objects, global configuration options, etc.
Definition: z3++.h:160
Definition: z3++.h:550
Z3 C++ namespace.
Definition: z3++.h:49
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_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.
expr set_add(expr const &s, expr const &e)
Definition: z3++.h:3969
expr ashr(expr const &a, expr const &b)
arithmetic shift right operator for bitvectors
Definition: z3++.h:2220
expr re_empty(sort const &s)
Definition: z3++.h:4057
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.
void Z3_API Z3_solver_inc_ref(Z3_context c, Z3_solver s)
Increment the reference counter of the given solver.
Z3_ast Z3_API Z3_mk_bvsrem(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows dividend).
sort fpa_sort()
Return a FloatingPoint sort with given precision bitwidth (16, 32, 64 or 128).
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.
friend tactic operator|(tactic const &t1, tactic const &t2)
Definition: z3++.h:3090
Z3_ast Z3_API Z3_mk_bvsdiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed division.
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:1582
expr nor(expr const &a, expr const &b)
Definition: z3++.h:1948
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_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_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
std::string get_rational() const
Definition: z3++.h:2726
fixedpoint(fixedpoint const &o)
Definition: z3++.h:3355
void 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...
unsigned size() const
Definition: z3++.h:3516
solver(context &c, Z3_solver s)
Definition: z3++.h:2744
func_decl_vector accessors()
Definition: z3++.h:4159
expr ubvtos() const
Definition: z3++.h:1514
Z3_func_decl Z3_API Z3_mk_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a constant or function.
Z3 global configuration object.
Definition: z3++.h:110
solver & operator=(solver const &s)
Definition: z3++.h:2751
Z3_ast Z3_API Z3_mk_char_from_bv(Z3_context c, Z3_ast bv)
Create a character from a bit-vector (code point).
Z3_ast Z3_API Z3_mk_fpa_rtp(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardPositive rounding mode...
void set(char const *param, int value)
Set global parameter param with integer value.
Definition: z3++.h:129
void add_cover(int level, func_decl &p, expr &property)
Definition: z3++.h:3393
expr substitute(expr_vector const &src, expr_vector const &dst)
Apply substitution. Replace src expressions by dst.
Definition: z3++.h:4178
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.
ast(context &c, Z3_ast n)
Definition: z3++.h:555
ast_vector_tpl & operator=(ast_vector_tpl const &s)
Definition: z3++.h:604
expr_vector cube(expr_vector &vars, unsigned cutoff)
Definition: z3++.h:2867
friend expr fpa_to_sbv(expr const &t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.
Definition: z3++.h:2046
expr operator<=(expr const &a, expr const &b)
Definition: z3++.h:1866
friend std::ostream & operator<<(std::ostream &out, apply_result const &r)
Definition: z3++.h:3041
bool is_finite_domain() const
Return true if this is a Finite-domain expression.
Definition: z3++.h:869
expr proof() const
Definition: z3++.h:2839
void set(char const *k, char const *s)
Definition: z3++.h:542
expr bv_const(char const *name, unsigned sz)
Definition: z3++.h:3721
sort fpa_sort()
Definition: z3++.h:3441
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_ast Z3_API Z3_func_interp_get_else(Z3_context c, Z3_func_interp f)
Return the 'else' value of the given function interpretation.
user_propagator_base(context &c)
Definition: z3++.h:4323
expr real_val(int n)
Definition: z3++.h:3749
expr string_val(char const *s)
Definition: z3++.h:3772
uint64_t get_numeral_uint64() const
Return uint64_t value of numeral, throw if result cannot fit in uint64_t.
Definition: z3++.h:1121
tactic(context &c, char const *name)
Definition: z3++.h:3050
Z3_ast Z3_API Z3_mk_div(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 div arg2.
void Z3_API Z3_fixedpoint_inc_ref(Z3_context c, Z3_fixedpoint d)
Increment the reference counter of the given fixedpoint context.
void Z3_API Z3_probe_inc_ref(Z3_context c, Z3_probe p)
Increment the reference counter of the given probe.
sort string_sort()
Return the sort for Unicode strings.
Definition: z3++.h:3434
std::string str() const
Definition: z3++.h:485
void conflict(expr_vector const &fixed, expr_vector const &lhs, expr_vector const &rhs)
Definition: z3++.h:4492
tactic with(tactic const &t, params const &p)
Definition: z3++.h:3103
expr empty_set(sort const &s)
Definition: z3++.h:3961
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_ast_vector Z3_API Z3_mk_ast_vector(Z3_context c)
Return an empty AST vector.
expr as_array(func_decl &f)
Definition: z3++.h:3940
expr plus(expr const &re)
Definition: z3++.h:4048
func_decl partial_order(sort const &a, unsigned index)
Definition: z3++.h:2272
expr xnor(expr const &a, expr const &b)
Definition: z3++.h:1949
expr char_to_bv() const
Definition: z3++.h:1529
void reset()
Definition: z3++.h:2776
Z3_func_decl Z3_API Z3_get_decl_func_decl_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.
Z3_ast Z3_API Z3_mk_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...
expr operator*() const
Definition: z3++.h:1611
Z3_ast Z3_API Z3_mk_int2real(Z3_context c, Z3_ast t1)
Coerce an integer to a real.
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_fpa_rem(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point remainder.
Z3_ast Z3_API Z3_mk_bvshl(Z3_context c, Z3_ast t1, Z3_ast t2)
Shift left.
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:1011
~config()
Definition: z3++.h:116
void from_string(char const *s)
Definition: z3++.h:2792
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
sort array_domain() const
Return the domain of this Array sort.
Definition: z3++.h:740
Z3_ast Z3_API Z3_mk_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than.
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_ast_kind
The different kinds of Z3 AST (abstract syntax trees). That is, terms, formulas and types...
Definition: z3_api.h:140
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...
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.
expr_vector args() const
Return a vector of all the arguments of this application. This method assumes the expression is an ap...
Definition: z3++.h:1214
friend expr atleast(expr_vector const &es, unsigned bound)
Definition: z3++.h:2429
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.
expr fpa_fp(expr const &sgn, expr const &exp, expr const &sig)
Definition: z3++.h:2038
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 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...
func_entry(context &c, Z3_func_entry e)
Definition: z3++.h:2528
void resize(unsigned sz)
Definition: z3++.h:600
void Z3_API Z3_del_config(Z3_config c)
Delete the given configuration object.
bool is_var() const
Return true if this expression is a variable.
Definition: z3++.h:924
Z3_simplifier Z3_API Z3_simplifier_using_params(Z3_context c, Z3_simplifier t, Z3_params p)
Return a simplifier that applies t using the given set of parameters.
expr extract(unsigned hi, unsigned lo) const
Definition: z3++.h:1416
model get_model() const
Definition: z3++.h:2996
Z3_ast_vector Z3_API Z3_algebraic_get_poly(Z3_context c, Z3_ast a)
Return the coefficients of the defining polynomial.
expr operator[](expr_vector const &index) const
Definition: z3++.h:1571
void add(expr const &e, char const *p)
Definition: z3++.h:2783
func_decl to_func_decl(context &c, Z3_func_decl f)
Definition: z3++.h:2120
friend simplifier with(simplifier const &t, params const &p)
Definition: z3++.h:3164
unsigned depth() const
Definition: z3++.h:2985
optimize(context &c)
Definition: z3++.h:3257
expr min(expr const &a, expr const &b)
Definition: z3++.h:1950
context & ctx() const
Definition: z3++.h:473
sort array_range() const
Return the range of this Array sort.
Definition: z3++.h:746
cube_iterator(solver &s, expr_vector &vars, unsigned &cutoff, bool end)
Definition: z3++.h:2894
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...
param_descrs(param_descrs const &o)
Definition: z3++.h:503
void Z3_API Z3_optimize_push(Z3_context c, Z3_optimize d)
Create a backtracking point.
void set_cutoff(unsigned c) noexcept
Definition: z3++.h:2951
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_mk_re_option(Z3_context c, Z3_ast re)
Create the regular language [re].
friend expr fpa_to_fpa(expr const &t, sort s)
Conversion of a floating-point term into another floating-point.
Definition: z3++.h:2074
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].
Z3_ast Z3_API Z3_substitute_vars(Z3_context c, Z3_ast a, unsigned num_exprs, Z3_ast const to[])
Substitute the variables in a with the expressions in to. For every i smaller than num_exprs...
Z3_ast Z3_API Z3_mk_ge(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than or equal to.
unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t)
Return the size of the given bit-vector sort.
Z3_ast Z3_API Z3_optimize_get_lower(Z3_context c, Z3_optimize o, unsigned idx)
Retrieve lower bound value or approximation for the i'th optimization objective.
Definition: z3++.h:2521
bool is_const() const
Definition: z3++.h:782
Z3_sort Z3_API Z3_mk_array_sort(Z3_context c, Z3_sort domain, Z3_sort range)
Create an array type.
sort fpa_rounding_mode_sort()
Return a RoundingMode sort.
Definition: z3++.h:3452
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:1156
check_result check()
Definition: z3++.h:2794
unsigned size() const
Definition: z3++.h:3037
unsigned Z3_API Z3_stats_size(Z3_context c, Z3_stats s)
Return the number of statistical data in s.
Z3_ast Z3_API Z3_mk_set_subset(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Check for subsetness of sets.
std::string to_smt2(char const *status="unknown")
Definition: z3++.h:2842
unsigned get_numeral_uint() const
Return uint value of numeral, throw if result cannot fit in machine uint.
Definition: z3++.h:1087
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...
func_decl get_func_decl(unsigned i) const
Definition: z3++.h:2610
expr operator+(expr const &a, expr const &b)
Definition: z3++.h:1728
func_decl function(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3583
expr operator()(context &c, Z3_ast a)
Definition: z3++.h:2289
Z3_ast Z3_API Z3_mk_bvsge(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than or equal to.
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
double Z3_API Z3_get_decl_double_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the double value associated with an double parameter.
friend probe operator!(probe const &p)
Definition: z3++.h:3243
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.
expr as_expr() const
Definition: z3++.h:3001
bool is_numeral() const
Return true if this expression is a numeral. Specialized functions also return representations for th...
Definition: z3++.h:880
func_decl recfun(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3654
expr bvadd_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2241
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
expr int2bv(unsigned n, expr const &a)
Definition: z3++.h:2233
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...
expr bvneg_no_overflow(expr const &a)
Definition: z3++.h:2253
func_decl tree_order(sort const &a, unsigned index)
Definition: z3++.h:2278
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...
expr re_complement(expr const &a)
Definition: z3++.h:4082
model convert_model(model const &m) const
Definition: z3++.h:2990
unsigned h() const
Definition: z3++.h:3255
expr srem(expr const &a, expr const &b)
signed remainder operator for bitvectors
Definition: z3++.h:2185
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_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o)
Print the current context as a string.
expr operator&(expr const &a, expr const &b)
Definition: z3++.h:1935
expr set_intersect(expr const &a, expr const &b)
Definition: z3++.h:3985
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.
exception(char const *msg)
Definition: z3++.h:92
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...
solver(solver const &s)
Definition: z3++.h:2747
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_lbool
Lifted Boolean type: false, undefined, true.
Definition: z3_api.h:60
Z3_ast_vector Z3_API Z3_fixedpoint_from_file(Z3_context c, Z3_fixedpoint f, Z3_string s)
Parse an SMT-LIB2 file with fixedpoint rules. Add the rules to the current fixedpoint context...
Z3_sort Z3_API Z3_mk_fpa_rounding_mode_sort(Z3_context c)
Create the RoundingMode sort.
~optimize()
Definition: z3++.h:3275
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...
friend expr max(expr const &a, expr const &b)
Definition: z3++.h:1966
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...
bool operator!=(iterator const &other) noexcept
Definition: z3++.h:1608
expr fpa_const(char const *name, unsigned ebits, unsigned sbits)
Definition: z3++.h:3722
virtual void pop(unsigned num_scopes)=0
void Z3_API Z3_goal_dec_ref(Z3_context c, Z3_goal g)
Decrement the reference counter of the given goal.
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. ...
expr select(expr const &a, expr const &i)
forward declarations
Definition: z3++.h:3903
expr re_intersect(expr_vector const &args)
Definition: z3++.h:4067
friend expr ubv_to_fpa(expr const &t, sort s)
Conversion of an unsigned bit-vector term into a floating-point.
Definition: z3++.h:2067
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.
void Z3_API Z3_solver_propagate_decide(Z3_context c, Z3_solver s, Z3_decide_eh decide_eh)
register a callback when the solver decides to split on a registered expression. The callback may cha...
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...
ast_vector_tpl< sort > sort_vector
Definition: z3++.h:77
std::function< void(expr const &proof, std::vector< unsigned > const &deps, expr_vector const &clause)> on_clause_eh_t
Definition: z3++.h:4217
void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a file.
expr mk_xor(expr_vector const &args)
Definition: z3++.h:2511
void add(expr const &e)
Definition: z3++.h:3277
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.
expr prefixof(expr const &a, expr const &b)
Definition: z3++.h:4024
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_ubv_to_str(Z3_context c, Z3_ast s)
Unsigned bit-vector to string conversion.
Z3_parameter_kind kind() const
Definition: z3++.h:2721
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...
func_interp(func_interp const &s)
Definition: z3++.h:2552
Z3_decl_kind decl_kind() const
Definition: z3++.h:774
sort datatype(symbol const &name, constructors const &cs)
Create a recursive datatype over a single sort. name is the name of the recursive datatype n - the nu...
Definition: z3++.h:3544
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...
model & operator=(model const &s)
Definition: z3++.h:2589
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_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...
expr operator%(expr const &a, expr const &b)
Definition: z3++.h:1651
expr_vector parse_file(char const *file)
Definition: z3++.h:4102
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.
Z3_string Z3_API Z3_get_string(Z3_context c, Z3_ast s)
Retrieve the string constant stored in s. Characters outside the basic printable ASCII range are esca...
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.
tactic par_and_then(tactic const &t1, tactic const &t2)
Definition: z3++.h:3122
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.
friend expr operator==(expr const &a, expr const &b)
Definition: z3++.h:1705
void set(char const *param, bool value)
Set global parameter param with Boolean value.
Definition: z3++.h:125
unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m)
Return the number of constants assigned by the given model.
expr loop(unsigned lo)
create a looping regular expression.
Definition: z3++.h:1549
stats statistics() const
Definition: z3++.h:3343
func_entry entry(unsigned i) const
Definition: z3++.h:2564
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...
void add(expr const &e)
Definition: z3++.h:2777
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_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.
bool is_relation() const
Return true if this is a Relation expression.
Definition: z3++.h:851
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_mul(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point multiplication.
unsigned Z3_API Z3_goal_size(Z3_context c, Z3_goal g)
Return the number of formulas in the given goal.
bool is_bool() const
Return true if this sort is the Boolean sort.
Definition: z3++.h:679
void resize(unsigned sz)
Definition: z3++.h:460
expr ugt(expr const &a, expr const &b)
unsigned greater than operator for bitvectors.
Definition: z3++.h:2172
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_bvxnor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise xnor.
goal & operator=(goal const &s)
Definition: z3++.h:2972
expr option(expr const &re)
Definition: z3++.h:4051
~params()
Definition: z3++.h:529
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, this function returns the sort of the first dimension.
expr const_array(sort const &d, expr const &v)
Definition: z3++.h:3957
stats(stats const &s)
Definition: z3++.h:2666
T const * ptr() const
Definition: z3++.h:464
cube_iterator operator++(int)
Definition: z3++.h:2916
Z3_ast_vector Z3_API Z3_fixedpoint_get_rules(Z3_context c, Z3_fixedpoint f)
Retrieve set of rules from fixedpoint context.
void 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...
expr set_member(expr const &s, expr const &e)
Definition: z3++.h:4001
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
unsigned id() const
retrieve unique identifier for func_decl.
Definition: z3++.h:666
bool is_distinct() const
Definition: z3++.h:1302
Z3_sort Z3_API Z3_mk_datatype_sort(Z3_context c, Z3_symbol name)
create a forward reference to a recursive datatype being declared. The forward reference can be used ...
friend std::ostream & operator<<(std::ostream &out, model const &m)
Definition: z3++.h:2655
bool is_or() const
Definition: z3++.h:1297
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.
int Z3_API Z3_get_symbol_int(Z3_context c, Z3_symbol s)
Return the symbol int value.
bool is_not() const
Definition: z3++.h:1295
void Z3_API Z3_params_dec_ref(Z3_context c, Z3_params p)
Decrement the reference counter of the given parameter set.
~func_entry()
Definition: z3++.h:2530
void Z3_API Z3_optimize_dec_ref(Z3_context c, Z3_optimize d)
Decrement the reference counter of the given optimize context.
sort uninterpreted_sort(char const *name)
create an uninterpreted sort with the name given by the string or symbol.
Definition: z3++.h:3575
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...
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...
goal operator[](int i) const
Definition: z3++.h:3038
check_result check(expr_vector const &assumptions)
Definition: z3++.h:2805
unsigned fpa_ebits() const
Definition: z3++.h:732
expr_vector trail() const
Definition: z3++.h:2828
iterator end()
Definition: z3++.h:1617
void reset()
Definition: z3++.h:2986
Z3_ast Z3_API Z3_mk_bvsmod(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows divisor).
bool is_numeral(double &d) const
Definition: z3++.h:887
T * ptr()
Definition: z3++.h:465
bool is_implies() const
Definition: z3++.h:1299
params(params const &s)
Definition: z3++.h:528
Z3_ast Z3_API Z3_func_entry_get_value(Z3_context c, Z3_func_entry e)
Return the value of this point.
expr_vector algebraic_poly() const
Return coefficients for p of an algebraic number (root-obj p i)
Definition: z3++.h:1036
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 set_param(char const *param, char const *value)
Definition: z3++.h:80
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_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
expr bv2int(expr const &a, bool is_signed)
bit-vector and integer conversions.
Definition: z3++.h:2232
friend void check_context(object const &a, object const &b)
Definition: z3++.h:477
Z3_string Z3_API Z3_goal_to_string(Z3_context c, Z3_goal g)
Convert a goal into a string.
parameter(expr const &e, unsigned idx)
Definition: z3++.h:2716
handle maximize(expr const &e)
Definition: z3++.h:3304
unsigned Z3_API Z3_model_get_num_funcs(Z3_context c, Z3_model m)
Return the number of function interpretations in the given model.
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.
func_decl decl() const
Return the declaration associated with this application. This method assumes the expression is an app...
Definition: z3++.h:1192
unsigned size() const
Definition: z3++.h:597
bool is_seq() const
Return true if this is a sequence expression.
Definition: z3++.h:855
std::u32string get_u32string() const
for a string value expression return an unespaced string value.
Definition: z3++.h:1175
Z3_param_kind
The different kinds of parameters that can be associated with parameter sets. (see Z3_mk_params)...
Definition: z3_api.h:1302
friend expr bvsdiv_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2250
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...
friend probe operator<=(probe const &p1, probe const &p2)
Definition: z3++.h:3212
friend expr operator&&(expr const &a, expr const &b)
Return an expression representing a and b.
Definition: z3++.h:1680
expr get_cover_delta(int level, func_decl &p)
Definition: z3++.h:3388
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.
bool Z3_API Z3_is_string(Z3_context c, Z3_ast s)
Determine if s is a string constant.
expr int_const(char const *name)
Definition: z3++.h:3718
Z3_ast Z3_API Z3_mk_rem(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 rem arg2.
friend expr operator&(expr const &a, expr const &b)
Definition: z3++.h:1935
friend std::ostream & operator<<(std::ostream &out, exception const &e)
Definition: z3++.h:97
expr arg(unsigned i) const
Definition: z3++.h:2541
expr abs(expr const &a)
Definition: z3++.h:1994
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.
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.
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...
expr sbvtos() const
Definition: z3++.h:1519
unsigned num_args() const
Return the number of arguments in this application. This method assumes the expression is an applicat...
Definition: z3++.h:1199
virtual void decide(expr const &, unsigned, bool)
Definition: z3++.h:4455
void register_decide(decide_eh_t &c)
Definition: z3++.h:4431
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:74
expr sum(expr_vector const &args)
Definition: z3++.h:2437
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_ast Z3_API Z3_mk_re_plus(Z3_context c, Z3_ast re)
Create the regular language re+.
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_simplify(Z3_context c, Z3_ast a)
Interface to simplifier.
sort(context &c)
Definition: z3++.h:658
expr_vector from_string(char const *s)
Definition: z3++.h:3365
Z3_model Z3_API Z3_optimize_get_model(Z3_context c, Z3_optimize o)
Retrieve the model for the last Z3_optimize_check.
virtual void created(expr const &)
Definition: z3++.h:4453
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.
goal(context &c, bool models=true, bool unsat_cores=false, bool proofs=false)
Definition: z3++.h:2967
expr suffixof(expr const &a, expr const &b)
Definition: z3++.h:4018
void from_file(char const *filename)
Definition: z3++.h:3345
void Z3_API Z3_interrupt(Z3_context c)
Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers...
expr_vector const * operator->() const
Definition: z3++.h:2917
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.
check_result consequences(expr_vector &assumptions, expr_vector &vars, expr_vector &conseq)
Definition: z3++.h:2817
unsigned algebraic_i() const
Return i of an algebraic number (root-obj p i)
Definition: z3++.h:1046
bool is_app() const
Return true if this expression is an application.
Definition: z3++.h:898
std::string to_string() const
Definition: z3++.h:2653
friend tactic operator&(tactic const &t1, tactic const &t2)
Definition: z3++.h:3083
expr operator<(expr const &a, expr const &b)
Definition: z3++.h:1891
object(context &c)
Definition: z3++.h:472
friend expr operator>(expr const &a, expr const &b)
Definition: z3++.h:1913
unsigned size() const
Definition: z3++.h:2981
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.
handle add(expr const &e, unsigned weight)
Definition: z3++.h:3301
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.
fixedpoint & operator=(fixedpoint const &o)
Definition: z3++.h:3357
ast(context &c)
Definition: z3++.h:554
Z3_symbol_kind kind() const
Definition: z3++.h:484
param_descrs get_param_descrs()
Definition: z3++.h:3151
friend expr nand(expr const &a, expr const &b)
Definition: z3++.h:1947
void set(params const &p)
Definition: z3++.h:3398
expr fp_eq(expr const &a, expr const &b)
Definition: z3++.h:2021
expr atleast(expr_vector const &es, unsigned bound)
Definition: z3++.h:2429
friend tactic with(tactic const &t, params const &p)
Definition: z3++.h:3103
Z3_ast Z3_API Z3_mk_fpa_is_nan(Z3_context c, Z3_ast t)
Predicate indicating whether t is a NaN.
Z3_ast Z3_API Z3_mk_bvor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise or.
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...
bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s)
Check if s is a sequence sort.
expr real_const(char const *name)
Definition: z3++.h:3719
Z3_sort Z3_API Z3_mk_seq_sort(Z3_context c, Z3_sort s)
Create a sequence sort out of the sort for the elements.
Z3_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.
sort(context &c, Z3_ast a)
Definition: z3++.h:660
friend expr sbv_to_fpa(expr const &t, sort s)
Conversion of a signed bit-vector term into a floating-point.
Definition: z3++.h:2060
stats statistics() const
Definition: z3++.h:3394
model get_model() const
Definition: z3++.h:3328
context & ctx()
Definition: z3++.h:4339
func_interp get_func_interp(func_decl f) const
Definition: z3++.h:2626
friend probe operator==(probe const &p1, probe const &p2)
Definition: z3++.h:3232
bool operator!=(cube_iterator const &other) noexcept
Definition: z3++.h:2923
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...
bool is_numeral(std::string &s, unsigned precision) const
Definition: z3++.h:886
Z3_ast Z3_API Z3_mk_repeat(Z3_context c, unsigned i, Z3_ast t1)
Repeat the given bit-vector up length i.
void conflict(expr_vector const &fixed)
Definition: z3++.h:4485
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_get_decl_ast_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the expression value associated with an expression parameter.
bool operator!=(iterator const &other) const noexcept
Definition: z3++.h:632
expr algebraic_lower(unsigned precision) const
Definition: z3++.h:1019
bool is_eq() const
Definition: z3++.h:1300
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.
double Z3_API Z3_get_numeral_double(Z3_context c, Z3_ast a)
Return numeral as a double.
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector...
Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s)
Convert a solver into a string.
Z3_sort_kind sort_kind() const
Return the internal sort kind.
Definition: z3++.h:671
bool is_numeral(std::string &s) const
Definition: z3++.h:885
bool is_arith() const
Return true if this sort is the Integer or Real sort.
Definition: z3++.h:691
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
std::string dimacs(bool include_names=true) const
Definition: z3++.h:2862
expr sext(expr const &a, unsigned i)
Sign-extend of the given bit-vector to the (signed) equivalent bitvector of size m+i, where m is the size of the given bit-vector.
Definition: z3++.h:2267
friend expr fma(expr const &a, expr const &b, expr const &c, expr const &rm)
FloatingPoint fused multiply-add.
Definition: z3++.h:2030
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.
expr mk_is_zero() const
Return Boolean expression to test for whether an FP expression is a zero.
Definition: z3++.h:978
Z3_ast_vector Z3_API Z3_ast_vector_translate(Z3_context s, Z3_ast_vector v, Z3_context t)
Translate the AST vector v from context s into an AST vector in context t.
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context dst)
translate model from context c to context dst.
void from_file(char const *file)
Definition: z3++.h:2791
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_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.
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...
Definition: z3++.h:140
void Z3_API Z3_optimize_pop(Z3_context c, Z3_optimize d)
Backtrack one level.
Z3_ast Z3_API Z3_mk_fpa_neg(Z3_context c, Z3_ast t)
Floating-point negation.
Z3_ast Z3_API Z3_mk_is_int(Z3_context c, Z3_ast t1)
Check if a real number is an integer.
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
friend expr pbeq(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2413
expr at(expr const &index) const
Definition: z3++.h:1487
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. Thus, two ast nodes created by the same context and having the same children and same function symbols have the same identifiers. Ast nodes created in the same context, but having different children or different functions have different identifiers. Variables and quantifiers are also assigned different identifiers according to their structure.
bool operator==(iterator const &other) const noexcept
Definition: z3++.h:629
void add(expr_vector const &v)
Definition: z3++.h:2980
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_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
expr_vector trail(array< unsigned > &levels) const
Definition: z3++.h:2829
Z3_ast Z3_API Z3_mk_fpa_rna(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode...
expr empty(sort const &s)
Definition: z3++.h:4013
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.
bool is_well_sorted() const
Return true if this expression is well sorted (aka type correct).
Definition: z3++.h:933
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_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of the first occurrence of substr in s starting from offset offset. If s does not contai...
Z3_ast Z3_API Z3_mk_fpa_add(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point addition.
Z3_config Z3_API Z3_mk_config(void)
Create a configuration object for the Z3 context object.
~model()
Definition: z3++.h:2587
Z3_ast Z3_API Z3_mk_char_to_int(Z3_context c, Z3_ast ch)
Create an integer (code point) from character.
cube_generator(solver &s, expr_vector &vars)
Definition: z3++.h:2942
friend tactic par_and_then(tactic const &t1, tactic const &t2)
Definition: z3++.h:3122
char const * what() const
Definition: z3++.h:94
sort real_sort()
Return the Real sort.
Definition: z3++.h:3432
void set(char const *k, unsigned v)
Definition: z3++.h:2760
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_goal_num_exprs(Z3_context c, Z3_goal g)
Return the number of formulas, subformulas and terms in the given goal.
virtual ~user_propagator_base()
Definition: z3++.h:4332
friend std::ostream & operator<<(std::ostream &out, ast_vector_tpl const &v)
Definition: z3++.h:648
expr re_full(sort const &s)
Definition: z3++.h:4062
Z3_sort Z3_API Z3_get_range(Z3_context c, Z3_func_decl d)
Return the range of the given declaration.
bool inconsistent() const
Definition: z3++.h:2984
bool is_const() const
Return true if this expression is a constant (i.e., an application with 0 arguments).
Definition: z3++.h:902
expr arg(unsigned i) const
Return the i-th argument of this application. This method assumes the expression is an application...
Definition: z3++.h:1207
Z3_ast Z3_API Z3_mk_seq_last_index(Z3_context c, Z3_ast s, Z3_ast substr)
Return index of the last occurrence of substr in s. If s does not contain substr, then the value is -...
ast_vector_tpl(ast_vector_tpl const &s)
Definition: z3++.h:592
friend expr rem(expr const &a, expr const &b)
Definition: z3++.h:1656
expr num_val(int n, sort const &s)
Definition: z3++.h:3776
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. ...
bool eq(ast const &a, ast const &b)
Definition: z3++.h:583
Z3_string Z3_API Z3_stats_to_string(Z3_context c, Z3_stats s)
Convert a statistics into a string.
unsigned num_consts() const
Definition: z3++.h:2607
symbol int_symbol(int n)
Create a Z3 symbol based on the given integer.
Definition: z3++.h:3428
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...
expr loop(unsigned lo, unsigned hi)
Definition: z3++.h:1554
void add(expr_vector const &v)
Definition: z3++.h:2786
expr fpa_val(double n)
Definition: z3++.h:3766
func_decl transitive_closure(func_decl const &)
Definition: z3++.h:778
void Z3_API Z3_mk_datatypes(Z3_context c, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort sorts[], Z3_constructor_list constructor_lists[])
Create mutually recursive datatypes.
expr bvmul_no_overflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2256
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_gt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than.
friend probe operator>(probe const &p1, probe const &p2)
Definition: z3++.h:3227
expr indexof(expr const &s, expr const &substr, expr const &offset)
Definition: z3++.h:4030
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...
expr set_complement(expr const &a)
Definition: z3++.h:3997
unsigned num_funcs() const
Definition: z3++.h:2608
bool is_algebraic() const
Return true if expression is an algebraic number.
Definition: z3++.h:928
expr operator()() const
Definition: z3++.h:3799
Z3_constructor operator[](unsigned i) const
Definition: z3++.h:3514
expr_vector non_units() const
Definition: z3++.h:2826
Z3_parameter_kind
The different kinds of parameters that can be associated with function symbols.
Definition: z3_api.h:94
iterator(expr &e, unsigned i)
Definition: z3++.h:1604
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.
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...
param_descrs & operator=(param_descrs const &o)
Definition: z3++.h:504
expr operator>(expr const &a, expr const &b)
Definition: z3++.h:1913
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].
check_result to_check_result(Z3_lbool l)
Definition: z3++.h:147
expr star(expr const &re)
Definition: z3++.h:4054
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.
friend expr operator~(expr const &a)
Definition: z3++.h:2028
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.
expr operator==(expr const &a, expr const &b)
Definition: z3++.h:1705
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
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_implies(Z3_context c, Z3_ast t1, Z3_ast t2)
Create an AST node representing t1 implies t2.
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...
param_descrs(context &c, Z3_param_descrs d)
Definition: z3++.h:502
void Z3_API Z3_set_param_value(Z3_config c, Z3_string param_id, Z3_string param_value)
Set a configuration parameter.
friend tactic repeat(tactic const &t, unsigned max)
Definition: z3++.h:3097
expr operator|(expr const &a, expr const &b)
Definition: z3++.h:1943
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_bvnot(Z3_context c, Z3_ast t1)
Bitwise negation.
Z3_ast Z3_API Z3_mk_fpa_div(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point division.
friend tactic par_or(unsigned n, tactic const *tactics)
Definition: z3++.h:3113
expr pbge(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2405
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
friend expr abs(expr const &a)
Definition: z3++.h:1994
tactic(context &c, Z3_tactic s)
Definition: z3++.h:3051
void check_context(object const &a, object const &b)
Definition: z3++.h:477
expr char_to_int() const
Definition: z3++.h:1524
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 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.
expr mk_from_ieee_bv(sort const &s) const
Convert this IEEE BV into a fpa.
Definition: z3++.h:998
virtual user_propagator_base * fresh(context &ctx)=0
user_propagators created using fresh() are created during search and their lifetimes are restricted t...
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_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint f)
Return a string describing all fixedpoint available parameters.
expr bool_const(char const *name)
create uninterpreted constants of a given sort.
Definition: z3++.h:3717
expr urem(expr const &a, expr const &b)
unsigned reminder operator for bitvectors
Definition: z3++.h:2199
void Z3_API Z3_simplifier_inc_ref(Z3_context c, Z3_simplifier t)
Increment the reference counter of the given simplifier.
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.
expr sbv_to_fpa(expr const &t, sort s)
Definition: z3++.h:2060
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_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.
expr operator&&(expr const &a, expr const &b)
Definition: z3++.h:1680
double apply(goal const &g) const
Definition: z3++.h:3190
expr extract(expr const &offset, expr const &length) const
sequence and regular expression operations.
Definition: z3++.h:1466
rounding_mode
Definition: z3++.h:139
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_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.
unsigned Z3_API Z3_get_datatype_sort_num_constructors(Z3_context c, Z3_sort t)
Return number of constructors for datatype.
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...
symbol get_symbol() const
Definition: z3++.h:2725
#define _Z3_MK_BIN_(a, b, binop)
Definition: z3++.h:1621
void set_rounding_mode(rounding_mode rm)
Sets RoundingMode of FloatingPoints.
Definition: z3++.h:3727
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:2093
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_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.
std::string dimacs(bool include_names=true) const
Definition: z3++.h:3014
expr_vector rules() const
Definition: z3++.h:3397
friend expr nor(expr const &a, expr const &b)
Definition: z3++.h:1948
params & operator=(params const &s)
Definition: z3++.h:531
friend std::ostream & operator<<(std::ostream &out, symbol const &s)
Definition: z3++.h:490
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).
model(model const &s)
Definition: z3++.h:2585
Z3_param_descrs Z3_API Z3_get_global_param_descrs(Z3_context c)
Retrieve description of global parameters.
unsigned hi() const
Definition: z3++.h:1419
check_result query(func_decl_vector &relations)
Definition: z3++.h:3378
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.
probe(probe const &s)
Definition: z3++.h:3180
bool operator==(iterator const &other) noexcept
Definition: z3++.h:1605
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.
iterator(ast_vector_tpl const *v, unsigned i)
Definition: z3++.h:627
Definition: z3++.h:144
friend expr operator<(expr const &a, expr const &b)
Definition: z3++.h:1891
friend expr operator!(expr const &a)
Return an expression representing not(a).
Definition: z3++.h:1674
class for auxiliary parameters associated with func_decl The class is initialized with a func_decl or...
Definition: z3++.h:2704
Z3_ast Z3_API Z3_mk_bvredor(Z3_context c, Z3_ast t1)
Take disjunction of bits in vector, return vector of length 1.
virtual ~exception()=default
friend expr bvsub_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2244
solver(context &c, solver const &src, translate)
Definition: z3++.h:2746
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_goal_prec precision() const
Definition: z3++.h:2983
solver(context &c)
Definition: z3++.h:2742
expr get_expr() const
Definition: z3++.h:2722
unsigned Z3_API Z3_get_func_decl_id(Z3_context c, Z3_func_decl f)
Return a unique identifier for f.
void Z3_API Z3_apply_result_dec_ref(Z3_context c, Z3_apply_result r)
Decrement the reference counter of the given Z3_apply_result object.
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
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.
friend expr sum(expr_vector const &args)
Definition: z3++.h:2437
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...
expr lambda(expr const &x, expr const &b)
Definition: z3++.h:2372
parameter(func_decl const &d, unsigned idx)
Definition: z3++.h:2711
Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement subtraction.
bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a)
Determine if an ast is a universal quantifier.
func_decl get_decl() const
Definition: z3++.h:2724
func_decl(context &c, Z3_func_decl n)
Definition: z3++.h:762
Z3_ast Z3_API Z3_mk_bvand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise and.
Z3_ast_vector Z3_API Z3_fixedpoint_get_assertions(Z3_context c, Z3_fixedpoint f)
Retrieve set of background assertions from fixedpoint context.
ast_vector_tpl< ast > ast_vector
Definition: z3++.h:74
bool is_decided_unsat() const
Definition: z3++.h:2989
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.
handle minimize(expr const &e)
Definition: z3++.h:3307
expr mk_is_subnormal() const
Return Boolean expression to test for whether an FP expression is a subnormal.
Definition: z3++.h:968
friend probe operator<(probe const &p1, probe const &p2)
Definition: z3++.h:3222
Z3_ast Z3_API Z3_mk_atleast(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
expr_vector assertions() const
Definition: z3++.h:2825
cube_iterator & operator++()
Definition: z3++.h:2906
void Z3_API Z3_goal_inc_ref(Z3_context c, Z3_goal g)
Increment the reference counter of the given goal.
Z3_ast Z3_API Z3_fixedpoint_get_cover_delta(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred)
bool operator==(cube_iterator const &other) noexcept
Definition: z3++.h:2920
sort get_sort() const
Return the sort of this expression.
Definition: z3++.h:818
friend probe operator&&(probe const &p1, probe const &p2)
Definition: z3++.h:3237
void set(char const *k, double v)
Definition: z3++.h:2761
void add(expr const &e, expr const &p)
Definition: z3++.h:2778
Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a)
Return body of quantifier.
expr store(expr const &a, expr const &i, expr const &v)
Definition: z3++.h:3920
Z3_ast Z3_API Z3_mk_fpa_geq(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point greater than or equal.
bool is_exists() const
Return true if this expression is an existential quantifier.
Definition: z3++.h:915
Z3_lbool Z3_API Z3_fixedpoint_query(Z3_context c, Z3_fixedpoint d, Z3_ast query)
Pose a query against the asserted rules.
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
void set(char const *k, unsigned n)
Definition: z3++.h:539
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...
iterator begin() const noexcept
Definition: z3++.h:646
expr_vector const & operator*() const noexcept
Definition: z3++.h:2918
friend expr pble(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2397
Z3_ast Z3_API Z3_mk_fpa_sub(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point subtraction.
std::string key(unsigned i) const
Definition: z3++.h:2677
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.
bool is_relation() const
Return true if this sort is a Relation sort.
Definition: z3++.h:707
Z3_ast m_ast
Definition: z3++.h:552
Z3_ast Z3_API Z3_mk_bvudiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned division.
void set(char const *k, bool b)
Definition: z3++.h:538
tactic repeat(tactic const &t, unsigned max=UINT_MAX)
Definition: z3++.h:3097
expr bool_val(bool b)
Definition: z3++.h:3740
~context()
Definition: z3++.h:186
expr operator||(expr const &a, expr const &b)
Definition: z3++.h:1692
expr ult(expr const &a, expr const &b)
unsigned less than operator for bitvectors.
Definition: z3++.h:2160
void Z3_API Z3_params_inc_ref(Z3_context c, Z3_params p)
Increment the reference counter of the given parameter set.
Z3_solver Z3_API Z3_solver_add_simplifier(Z3_context c, Z3_solver solver, Z3_simplifier simplifier)
Attach simplifier to a solver. The solver will use the simplifier for incremental pre-processing...
unsigned num_parameters() const
Definition: z3++.h:775
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_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_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.
bool is_int() const
Return true if this is an integer expression.
Definition: z3++.h:827
friend expr pbge(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2405
apply_result apply(goal const &g) const
Definition: z3++.h:3063
expr int_val(int n)
Definition: z3++.h:3742
bool is_arith() const
Return true if this is an integer or real expression.
Definition: z3++.h:835
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...
void Z3_API Z3_model_inc_ref(Z3_context c, Z3_model m)
Increment the reference counter of the given model.
unsigned Z3_API Z3_optimize_minimize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a minimization constraint.
model get_model() const
Definition: z3++.h:2816
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_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.
expr else_value() const
Definition: z3++.h:2562
expr mk_or(expr_vector const &args)
Definition: z3++.h:2499
tactic fail_if(probe const &p)
Definition: z3++.h:3409
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_param_kind kind(symbol const &s)
Definition: z3++.h:517
stats(context &c, Z3_stats e)
Definition: z3++.h:2665
expr exists(expr const &x, expr const &b)
Definition: z3++.h:2348
expr round_fpa_to_closest_integer(expr const &t)
Definition: z3++.h:2081
std::string to_string()
Definition: z3++.h:3401
expr sge(expr const &a, expr const &b)
signed greater than or equal to operator for bitvectors.
Definition: z3++.h:2140
ast operator()(context &c, Z3_ast a)
Definition: z3++.h:2284
Z3_ast Z3_API Z3_mk_atmost(Z3_context c, unsigned num_args, Z3_ast const args[], unsigned k)
Pseudo-Boolean relations.
Definition: z3++.h:142
expr rotate_right(unsigned i) const
Definition: z3++.h:1405
Z3_symbol Z3_API Z3_mk_int_symbol(Z3_context c, int i)
Create a Z3 symbol using an integer.
expr_vector parse_string(char const *s)
parsing
Definition: z3++.h:4096
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.
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.
Z3_ast Z3_API Z3_mk_bvmul(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement multiplication.
context(config &c)
Definition: z3++.h:185
func_decl user_propagate_function(symbol const &name, sort_vector const &domain, sort const &range)
Definition: z3++.h:3698
void recdef(func_decl decl, expr_vector const &args, expr const &body)
add function definition body to declaration decl. decl needs to be declared using context::recfun...
Definition: z3++.h:3692
expr unit() const
Definition: z3++.h:1476
bool is_array() const
Return true if this sort is a Array sort.
Definition: z3++.h:699
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.
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.
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...
expr_vector from_file(char const *s)
Definition: z3++.h:3370
void set(char const *k, symbol const &v)
Definition: z3++.h:2762
expr ite(expr const &c, expr const &t, expr const &e)
Create the if-then-else expression ite(c, t, e)
Definition: z3++.h:2093
T const & operator[](int i) const
Definition: z3++.h:463
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.
func_entry(func_entry const &s)
Definition: z3++.h:2529
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...
double double_value(unsigned i) const
Definition: z3++.h:2681
expr bit2bool(unsigned i) const
Definition: z3++.h:1417
func_decl recfun(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3890
void register_eq(eq_eh_t &f)
Definition: z3++.h:4375
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_seq_empty(Z3_context c, Z3_sort seq)
Create an empty sequence of the sequence sort seq.
expr body() const
Return the 'body' of this quantifier.
Definition: z3++.h:1227
std::string get_string() const
for a string value expression return an escaped string value.
Definition: z3++.h:1163
~ast()
Definition: z3++.h:557
expr char_from_bv() const
Definition: z3++.h:1534
friend expr bvneg_no_overflow(expr const &a)
Definition: z3++.h:2253
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
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.
cube_generator(solver &s)
Definition: z3++.h:2935
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.
ast & operator=(ast const &s)
Definition: z3++.h:560
bool is_seq() const
Return true if this sort is a Sequence sort.
Definition: z3++.h:711
func_interp add_func_interp(func_decl &f, expr &else_val)
Definition: z3++.h:2640
expr repeat(unsigned i) const
Definition: z3++.h:1406
bool is_bv() const
Return true if this is a Bit-vector expression.
Definition: z3++.h:839
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
expr forall(expr const &x, expr const &b)
Definition: z3++.h:2324
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.
sort domain(unsigned i) const
Definition: z3++.h:771
bool is_bool() const
Return true if this is a Boolean expression.
Definition: z3++.h:823
int64_t get_numeral_int64() const
Return int64_t value of numeral, throw if result cannot fit in int64_t.
Definition: z3++.h:1104
sort(context &c, Z3_sort s)
Definition: z3++.h:659
unsigned hash() const
Definition: z3++.h:569
double operator()(goal const &g) const
Definition: z3++.h:3191
Z3_error_code check_error() const
Auxiliary method used to check for API usage errors.
Definition: z3++.h:192
Z3_ast Z3_API Z3_mk_fpa_sqrt(Z3_context c, Z3_ast rm, Z3_ast t)
Floating-point square root.
Z3_ast Z3_API Z3_mk_bvxor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise exclusive-or.
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_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).
bool is_datatype() const
Return true if this sort is a Datatype sort.
Definition: z3++.h:703
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.
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...
std::string to_string() const
Definition: z3++.h:571
expr implies(expr const &a, expr const &b)
Definition: z3++.h:1628
sort get_sort() const
Definition: z3++.h:2723
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-propagator with the solver.
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...
friend expr sqrt(expr const &a, expr const &rm)
Definition: z3++.h:2014
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.
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:2106
bool has_interp(func_decl f) const
Definition: z3++.h:2635
Z3_sort Z3_API Z3_mk_char_sort(Z3_context c)
Create a sort for unicode characters.
expr mk_is_normal() const
Return Boolean expression to test for whether an FP expression is a normal.
Definition: z3++.h:958
expr concat(expr const &a, expr const &b)
Definition: z3++.h:2455
symbol(context &c, Z3_symbol s)
Definition: z3++.h:482
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.
solver(context &c, char const *logic)
Definition: z3++.h:2745
bool is_false() const
Definition: z3++.h:1294
tactic try_for(tactic const &t, unsigned ms)
Definition: z3++.h:3108
func_interp(context &c, Z3_func_interp e)
Definition: z3++.h:2551
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 register_relation(func_decl &p)
Definition: z3++.h:3395
unsigned Z3_API Z3_get_arity(Z3_context c, Z3_func_decl d)
Alias for Z3_get_domain_size.
expr fpa_nan(sort const &s)
Definition: z3++.h:3768
Z3_sort Z3_API Z3_get_sort(Z3_context c, Z3_ast a)
Return the sort of an AST node.
void add_rule(expr &rule, symbol const &name)
Definition: z3++.h:3375
expr shl(expr const &a, expr const &b)
shift left operator for bitvectors
Definition: z3++.h:2206
expr bvsdiv_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2250
params(context &c)
Definition: z3++.h:527
Z3_string Z3_API Z3_solver_to_dimacs_string(Z3_context c, Z3_solver s, bool include_names)
Convert a solver into a DIMACS formatted string.
Z3_ast Z3_API Z3_mk_rotate_left(Z3_context c, unsigned i, Z3_ast t1)
Rotate bits of t1 to the left i times.
Z3_ast Z3_API Z3_mk_re_diff(Z3_context c, Z3_ast re1, Z3_ast re2)
Create the difference of regular expressions.
friend tactic try_for(tactic const &t, unsigned ms)
Definition: z3++.h:3108
void push_back(T const &e)
Definition: z3++.h:599
expr pble(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2397
expr max(expr const &a, expr const &b)
Definition: z3++.h:1966
sort range() const
Definition: z3++.h:772
expr sqrt(expr const &a, expr const &rm)
Definition: z3++.h:2014
expr mk_to_ieee_bv() const
Convert this fpa into an IEEE BV.
Definition: z3++.h:988
ast_vector_tpl< expr > expr_vector
Definition: z3++.h:76
bool is_re() const
Return true if this is a regular expression.
Definition: z3++.h:859
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_probe_dec_ref(Z3_context c, Z3_probe p)
Decrement the reference counter of the given probe.
int get_int() const
Definition: z3++.h:2728
expr mk_is_nan() const
Return Boolean expression to test for whether an FP expression is a NaN.
Definition: z3++.h:948
expr uge(expr const &a, expr const &b)
unsigned greater than or equal to operator for bitvectors.
Definition: z3++.h:2166
void push()
Definition: z3++.h:3310
expr last_indexof(expr const &s, expr const &substr)
Definition: z3++.h:4036
expr slt(expr const &a, expr const &b)
signed less than operator for bitvectors.
Definition: z3++.h:2134
void set(char const *param, bool value)
Update global parameter param with Boolean value.
Definition: z3++.h:221
Z3_constructor_list Z3_API Z3_mk_constructor_list(Z3_context c, unsigned num_constructors, Z3_constructor const constructors[])
Create list of constructors.
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. Add the parsed constraints and objectives to the optimization context.
void set(params const &p)
Definition: z3++.h:2758
bool is_re() const
Return true if this sort is a regular expression sort.
Definition: z3++.h:715
func_decl_vector constructors()
Definition: z3++.h:4141
Z3_ast Z3_API Z3_goal_formula(Z3_context c, Z3_goal g, unsigned idx)
Return a formula from the given goal.
Z3_symbol Z3_API Z3_get_sort_name(Z3_context c, Z3_sort d)
Return the sort name as a symbol.
bool is_quantifier() const
Return true if this expression is a quantifier.
Definition: z3++.h:906
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:3470
context * m_ctx
Definition: z3++.h:470
bool propagate(expr_vector const &fixed, expr_vector const &lhs, expr_vector const &rhs, expr const &conseq)
Definition: z3++.h:4509
unsigned size()
Definition: z3++.h:515
unsigned size() const
Definition: z3++.h:461
void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint f, Z3_params p)
Set parameters on fixedpoint context.
Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s)
Create a floating-point NaN of sort s.
void Z3_API Z3_query_constructor(Z3_context c, Z3_constructor constr, unsigned num_fields, Z3_func_decl *constructor, Z3_func_decl *tester, Z3_func_decl accessors[])
Query constructor for declared functions.
expr fpa_inf(sort const &s, bool sgn)
Definition: z3++.h:3769
symbol name() const
Definition: z3++.h:773
std::string help() const
Definition: z3++.h:3399
bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s)
Check if s is a regular expression sort.
expr operator-(expr const &a)
Definition: z3++.h:1824
void pop(unsigned n=1)
Definition: z3++.h:2775
friend std::ostream & operator<<(std::ostream &out, stats const &s)
Definition: z3++.h:2684
expr smod(expr const &a, expr const &b)
signed modulus operator for bitvectors
Definition: z3++.h:2192
bool Z3_API Z3_solver_propagate_consequence(Z3_context c, Z3_solver_callback cb, unsigned num_fixed, Z3_ast const *fixed, unsigned num_eqs, Z3_ast const *eq_lhs, Z3_ast const *eq_rhs, Z3_ast conseq)
propagate a consequence based on fixed values and equalities. A client may invoke it during the propa...
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.
expr to_real(expr const &a)
Definition: z3++.h:3860
cube_iterator end()
Definition: z3++.h:2950
handle(unsigned h)
Definition: z3++.h:3254
unsigned size() const
Definition: z3++.h:2676
void register_created(created_eh_t &c)
Definition: z3++.h:4415
Z3_ast Z3_API Z3_mk_bvadd(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement addition.
friend expr implies(expr const &a, expr const &b)
Definition: z3++.h:1628
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...
virtual void push()=0
param_descrs get_param_descrs()
Definition: z3++.h:2864
Definition: z3++.h:141
void add(symbol const &name, symbol const &rec, unsigned n, symbol const *names, sort const *fields)
Definition: z3++.h:3505
Z3_ast Z3_API Z3_mk_seq_unit(Z3_context c, Z3_ast a)
Create a unit sequence of a.
void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s)
Decrement the reference counter of the given solver.
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_...
ast(ast const &s)
Definition: z3++.h:556
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:3459
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
Z3_ast Z3_API Z3_mk_fpa_min(Z3_context c, Z3_ast t1, Z3_ast t2)
Minimum of floating-point numbers.
tactic par_or(unsigned n, tactic const *tactics)
Definition: z3++.h:3113
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.
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_decl_kind
The different kinds of interpreted function kinds.
Definition: z3_api.h:963
T operator[](unsigned i) const
Definition: z3++.h:598
unsigned Z3_API Z3_optimize_maximize(Z3_context c, Z3_optimize o, Z3_ast t)
Add a maximization constraint.
expr sgt(expr const &a, expr const &b)
signed greater than operator for bitvectors.
Definition: z3++.h:2146
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_fpa_leq(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point less than or equal.
apply_result(context &c, Z3_apply_result s)
Definition: z3++.h:3026
expr nand(expr const &a, expr const &b)
Definition: z3++.h:1947
def tactics
Definition: z3py.py:8565
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_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_fixedpoint_get_answer(Z3_context c, Z3_fixedpoint d)
Retrieve a formula that encodes satisfying answers to the query.
Z3_string Z3_API Z3_fixedpoint_to_string(Z3_context c, Z3_fixedpoint f, unsigned num_queries, Z3_ast queries[])
Print the current rules and background axioms as a string.
Z3_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.
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.
expr fpa_to_ubv(expr const &t, unsigned sz)
Definition: z3++.h:2053
expr stoi() const
Definition: z3++.h:1504
static param_descrs global_param_descrs(context &c)
Definition: z3++.h:513
expr operator/(expr const &a, expr const &b)
Definition: z3++.h:1802
void Z3_API Z3_solver_register_on_clause(Z3_context c, Z3_solver s, void *user_context, Z3_on_clause_eh on_clause_eh)
register a callback to that retrieves assumed, inferred and deleted clauses during search...
Z3_ast Z3_API Z3_mk_fpa_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point less than.
void query(unsigned i, func_decl &constructor, func_decl &test, func_decl_vector &accs)
Definition: z3++.h:3518
Function declaration (aka function definition). It is the signature of interpreted and uninterpreted ...
Definition: z3++.h:759
expr set_union(expr const &a, expr const &b)
Definition: z3++.h:3977
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.
T & operator[](int i)
Definition: z3++.h:462
expr_vector objectives() const
Definition: z3++.h:3342
bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t)
Return true if the given expression t is well sorted.
int get_numeral_int() const
Return int value of numeral, throw if result cannot fit in machine int.
Definition: z3++.h:1068
param_descrs get_param_descrs()
Definition: z3++.h:3080
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...
bool is_xor() const
Definition: z3++.h:1298
virtual void fixed(expr const &, expr const &)
Definition: z3++.h:4447
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.
goal(goal const &s)
Definition: z3++.h:2969
sort int_sort()
Return the integer sort.
Definition: z3++.h:3431
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_func_decl Z3_API Z3_get_datatype_sort_constructor(Z3_context c, Z3_sort t, unsigned idx)
Return idx'th constructor.
ast_vector_tpl(context &c, ast_vector_tpl const &src)
Definition: z3++.h:593
expr set_del(expr const &s, expr const &e)
Definition: z3++.h:3973
void set(params const &p)
Definition: z3++.h:3330
check_result check(expr_vector const &asms)
Definition: z3++.h:3317
#define _Z3_MK_UN_(a, mkun)
Definition: z3++.h:1668
void Z3_API Z3_tactic_dec_ref(Z3_context c, Z3_tactic g)
Decrement the reference counter of the given tactic.
simplifier & operator=(simplifier const &s)
Definition: z3++.h:3141
int64_t as_int64() const
Definition: z3++.h:892
stats & operator=(stats const &s)
Definition: z3++.h:2669
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.
simplifier(context &c, char const *name)
Definition: z3++.h:3136
unsigned num_args() const
Definition: z3++.h:2540
expr bvsub_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2244
Z3_ast Z3_API Z3_mk_sbv_to_str(Z3_context c, Z3_ast s)
Signed bit-vector to string conversion.
Z3_lbool bool_value() const
Definition: z3++.h:1132
expr fpa_to_sbv(expr const &t, unsigned sz)
Definition: z3++.h:2046
bool Z3_API Z3_solver_next_split(Z3_context c, Z3_solver_callback cb, Z3_ast t, unsigned idx, Z3_lbool phase)
apply_result & operator=(apply_result const &s)
Definition: z3++.h:3030
Z3_ast Z3_API Z3_mk_int_to_str(Z3_context c, Z3_ast s)
Integer to string conversion.
Z3_func_decl Z3_API Z3_solver_propagate_declare(Z3_context c, Z3_symbol name, unsigned n, Z3_sort *domain, Z3_sort range)
expr atmost(expr_vector const &es, unsigned bound)
Definition: z3++.h:2421
void Z3_API Z3_ast_vector_push(Z3_context c, Z3_ast_vector v, Z3_ast a)
Add the AST a in the end of the AST vector v. The size of v is increased by one.
Z3_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.
bool is_real() const
Return true if this sort is the Real sort.
Definition: z3++.h:687
Z3_ast Z3_API Z3_substitute_funs(Z3_context c, Z3_ast a, unsigned num_funs, Z3_func_decl const from[], Z3_ast const to[])
Substitute functions in from with new expressions in to.
bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a)
Determine if ast is a lambda expression.
sort to_sort(context &c, Z3_sort s)
Definition: z3++.h:2115
expr string_const(char const *name)
Definition: z3++.h:3720
context()
Definition: z3++.h:184
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_simplifier Z3_API Z3_mk_simplifier(Z3_context c, Z3_string name)
Return a simplifier associated with the given name. The complete list of simplifiers may be obtained ...
expr numerator() const
Definition: z3++.h:1136
Z3_sort Z3_API Z3_get_decl_sort_parameter(Z3_context c, Z3_func_decl d, unsigned idx)
Return the sort value associated with a sort parameter.
void Z3_API Z3_solver_propagate_eq(Z3_context c, Z3_solver s, Z3_eq_eh eq_eh)
register a callback on expression equalities.
bool is_decided_sat() const
Definition: z3++.h:2988
on_clause(solver &s, on_clause_eh_t &on_clause_eh)
Definition: z3++.h:4233
void add(expr const &f)
Definition: z3++.h:2979
friend expr mk_xor(expr_vector const &args)
Definition: z3++.h:2511
Z3_ast Z3_API Z3_mk_fpa_gt(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point greater than.
friend expr range(expr const &lo, expr const &hi)
Definition: z3++.h:4085
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...
expr to_re(expr const &s)
Definition: z3++.h:4042
func_decl linear_order(sort const &a, unsigned index)
Definition: z3++.h:2269
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. Add the parsed constraints and objectives to the optimization context.
Z3_ast Z3_API Z3_mk_seq_contains(Z3_context c, Z3_ast container, Z3_ast containee)
Check if container contains containee.
check_result
Definition: z3++.h:135
Z3_ast Z3_API Z3_mk_zero_ext(Z3_context c, unsigned i, Z3_ast t1)
Extend the given bit-vector with zeros to the (unsigned) equivalent bit-vector of size m+i...
Z3_string Z3_API Z3_model_to_string(Z3_context c, Z3_model m)
Convert the given model into a string.
expr denominator() const
Definition: z3++.h:1144
std::string to_string() const
Definition: z3++.h:649
bool is_numeral_i(int &i) const
Definition: z3++.h:883
param_descrs get_param_descrs()
Definition: z3++.h:3400
unsigned size() const
Definition: z3++.h:2611
const char * Z3_string
Z3 string type. It is just an alias for const char *.
Definition: z3_api.h:53
unsigned Z3_API Z3_algebraic_get_i(Z3_context c, Z3_ast a)
Return which root of the polynomial the algebraic number represents.
Z3_ast Z3_API Z3_mk_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...
apply_result(apply_result const &s)
Definition: z3++.h:3027
bool is_fpa() const
Return true if this sort is a Floating point sort.
Definition: z3++.h:723