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