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  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)); }
1363  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)); }
1364 
1368  friend expr fma(expr const& a, expr const& b, expr const& c, expr const& rm);
1369 
1373  friend expr fpa_fp(expr const& sgn, expr const& exp, expr const& sig);
1374 
1378  friend expr fpa_to_sbv(expr const& t, unsigned sz);
1379 
1383  friend expr fpa_to_ubv(expr const& t, unsigned sz);
1384 
1388  friend expr sbv_to_fpa(expr const& t, sort s);
1389 
1393  friend expr ubv_to_fpa(expr const& t, sort s);
1394 
1398  friend expr fpa_to_fpa(expr const& t, sort s);
1399 
1403  friend expr round_fpa_to_closest_integer(expr const& t);
1404 
1410  expr extract(expr const& offset, expr const& length) const {
1411  check_context(*this, offset); check_context(offset, length);
1412  Z3_ast r = Z3_mk_seq_extract(ctx(), *this, offset, length); check_error(); return expr(ctx(), r);
1413  }
1414  expr replace(expr const& src, expr const& dst) const {
1415  check_context(*this, src); check_context(src, dst);
1416  Z3_ast r = Z3_mk_seq_replace(ctx(), *this, src, dst);
1417  check_error();
1418  return expr(ctx(), r);
1419  }
1420  expr unit() const {
1421  Z3_ast r = Z3_mk_seq_unit(ctx(), *this);
1422  check_error();
1423  return expr(ctx(), r);
1424  }
1425  expr contains(expr const& s) const {
1426  check_context(*this, s);
1427  Z3_ast r = Z3_mk_seq_contains(ctx(), *this, s);
1428  check_error();
1429  return expr(ctx(), r);
1430  }
1431  expr at(expr const& index) const {
1432  check_context(*this, index);
1433  Z3_ast r = Z3_mk_seq_at(ctx(), *this, index);
1434  check_error();
1435  return expr(ctx(), r);
1436  }
1437  expr nth(expr const& index) const {
1438  check_context(*this, index);
1439  Z3_ast r = Z3_mk_seq_nth(ctx(), *this, index);
1440  check_error();
1441  return expr(ctx(), r);
1442  }
1443  expr length() const {
1444  Z3_ast r = Z3_mk_seq_length(ctx(), *this);
1445  check_error();
1446  return expr(ctx(), r);
1447  }
1448  expr stoi() const {
1449  Z3_ast r = Z3_mk_str_to_int(ctx(), *this);
1450  check_error();
1451  return expr(ctx(), r);
1452  }
1453  expr itos() const {
1454  Z3_ast r = Z3_mk_int_to_str(ctx(), *this);
1455  check_error();
1456  return expr(ctx(), r);
1457  }
1458  expr ubvtos() const {
1459  Z3_ast r = Z3_mk_ubv_to_str(ctx(), *this);
1460  check_error();
1461  return expr(ctx(), r);
1462  }
1463  expr sbvtos() const {
1464  Z3_ast r = Z3_mk_sbv_to_str(ctx(), *this);
1465  check_error();
1466  return expr(ctx(), r);
1467  }
1468  expr char_to_int() const {
1469  Z3_ast r = Z3_mk_char_to_int(ctx(), *this);
1470  check_error();
1471  return expr(ctx(), r);
1472  }
1473  expr char_to_bv() const {
1474  Z3_ast r = Z3_mk_char_to_bv(ctx(), *this);
1475  check_error();
1476  return expr(ctx(), r);
1477  }
1478  expr char_from_bv() const {
1479  Z3_ast r = Z3_mk_char_from_bv(ctx(), *this);
1480  check_error();
1481  return expr(ctx(), r);
1482  }
1483  expr is_digit() const {
1484  Z3_ast r = Z3_mk_char_is_digit(ctx(), *this);
1485  check_error();
1486  return expr(ctx(), r);
1487  }
1488 
1489  friend expr range(expr const& lo, expr const& hi);
1493  expr loop(unsigned lo) {
1494  Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, 0);
1495  check_error();
1496  return expr(ctx(), r);
1497  }
1498  expr loop(unsigned lo, unsigned hi) {
1499  Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, hi);
1500  check_error();
1501  return expr(ctx(), r);
1502  }
1503 
1507  expr operator[](expr const& index) const {
1508  assert(is_array() || is_seq());
1509  if (is_array()) {
1510  return select(*this, index);
1511  }
1512  return nth(index);
1513  }
1514 
1515  expr operator[](expr_vector const& index) const {
1516  return select(*this, index);
1517  }
1518 
1522  expr simplify() const { Z3_ast r = Z3_simplify(ctx(), m_ast); check_error(); return expr(ctx(), r); }
1526  expr simplify(params const & p) const { Z3_ast r = Z3_simplify_ex(ctx(), m_ast, p); check_error(); return expr(ctx(), r); }
1527 
1531  expr substitute(expr_vector const& src, expr_vector const& dst);
1532 
1536  expr substitute(expr_vector const& dst);
1537 
1538 
1539  class iterator {
1540  expr& e;
1541  unsigned i;
1542  public:
1543  iterator(expr& e, unsigned i): e(e), i(i) {}
1544  bool operator==(iterator const& other) noexcept {
1545  return i == other.i;
1546  }
1547  bool operator!=(iterator const& other) noexcept {
1548  return i != other.i;
1549  }
1550  expr operator*() const { return e.arg(i); }
1551  iterator& operator++() { ++i; return *this; }
1552  iterator operator++(int) { assert(false); return *this; }
1553  };
1554 
1555  iterator begin() { return iterator(*this, 0); }
1556  iterator end() { return iterator(*this, is_app() ? num_args() : 0); }
1557 
1558  };
1559 
1560 #define _Z3_MK_BIN_(a, b, binop) \
1561  check_context(a, b); \
1562  Z3_ast r = binop(a.ctx(), a, b); \
1563  a.check_error(); \
1564  return expr(a.ctx(), r); \
1565 
1566 
1567  inline expr implies(expr const & a, expr const & b) {
1568  assert(a.is_bool() && b.is_bool());
1569  _Z3_MK_BIN_(a, b, Z3_mk_implies);
1570  }
1571  inline expr implies(expr const & a, bool b) { return implies(a, a.ctx().bool_val(b)); }
1572  inline expr implies(bool a, expr const & b) { return implies(b.ctx().bool_val(a), b); }
1573 
1574 
1575  inline expr pw(expr const & a, expr const & b) { _Z3_MK_BIN_(a, b, Z3_mk_power); }
1576  inline expr pw(expr const & a, int b) { return pw(a, a.ctx().num_val(b, a.get_sort())); }
1577  inline expr pw(int a, expr const & b) { return pw(b.ctx().num_val(a, b.get_sort()), b); }
1578 
1579  inline expr mod(expr const& a, expr const& b) {
1580  if (a.is_bv()) {
1581  _Z3_MK_BIN_(a, b, Z3_mk_bvsmod);
1582  }
1583  else {
1584  _Z3_MK_BIN_(a, b, Z3_mk_mod);
1585  }
1586  }
1587  inline expr mod(expr const & a, int b) { return mod(a, a.ctx().num_val(b, a.get_sort())); }
1588  inline expr mod(int a, expr const & b) { return mod(b.ctx().num_val(a, b.get_sort()), b); }
1589 
1590  inline expr operator%(expr const& a, expr const& b) { return mod(a, b); }
1591  inline expr operator%(expr const& a, int b) { return mod(a, b); }
1592  inline expr operator%(int a, expr const& b) { return mod(a, b); }
1593 
1594 
1595  inline expr rem(expr const& a, expr const& b) {
1596  if (a.is_fpa() && b.is_fpa()) {
1597  _Z3_MK_BIN_(a, b, Z3_mk_fpa_rem);
1598  } else {
1599  _Z3_MK_BIN_(a, b, Z3_mk_rem);
1600  }
1601  }
1602  inline expr rem(expr const & a, int b) { return rem(a, a.ctx().num_val(b, a.get_sort())); }
1603  inline expr rem(int a, expr const & b) { return rem(b.ctx().num_val(a, b.get_sort()), b); }
1604 
1605 #undef _Z3_MK_BIN_
1606 
1607 #define _Z3_MK_UN_(a, mkun) \
1608  Z3_ast r = mkun(a.ctx(), a); \
1609  a.check_error(); \
1610  return expr(a.ctx(), r); \
1611 
1612 
1613  inline expr operator!(expr const & a) { assert(a.is_bool()); _Z3_MK_UN_(a, Z3_mk_not); }
1614 
1615  inline expr is_int(expr const& e) { _Z3_MK_UN_(e, Z3_mk_is_int); }
1616 
1617 #undef _Z3_MK_UN_
1618 
1619  inline expr operator&&(expr const & a, expr const & b) {
1620  check_context(a, b);
1621  assert(a.is_bool() && b.is_bool());
1622  Z3_ast args[2] = { a, b };
1623  Z3_ast r = Z3_mk_and(a.ctx(), 2, args);
1624  a.check_error();
1625  return expr(a.ctx(), r);
1626  }
1627 
1628  inline expr operator&&(expr const & a, bool b) { return a && a.ctx().bool_val(b); }
1629  inline expr operator&&(bool a, expr const & b) { return b.ctx().bool_val(a) && b; }
1630 
1631  inline expr operator||(expr const & a, expr const & b) {
1632  check_context(a, b);
1633  assert(a.is_bool() && b.is_bool());
1634  Z3_ast args[2] = { a, b };
1635  Z3_ast r = Z3_mk_or(a.ctx(), 2, args);
1636  a.check_error();
1637  return expr(a.ctx(), r);
1638  }
1639 
1640  inline expr operator||(expr const & a, bool b) { return a || a.ctx().bool_val(b); }
1641 
1642  inline expr operator||(bool a, expr const & b) { return b.ctx().bool_val(a) || b; }
1643 
1644  inline expr operator==(expr const & a, expr const & b) {
1645  check_context(a, b);
1646  Z3_ast r = Z3_mk_eq(a.ctx(), a, b);
1647  a.check_error();
1648  return expr(a.ctx(), r);
1649  }
1650  inline expr operator==(expr const & a, int b) { assert(a.is_arith() || a.is_bv() || a.is_fpa()); return a == a.ctx().num_val(b, a.get_sort()); }
1651  inline expr operator==(int a, expr const & b) { assert(b.is_arith() || b.is_bv() || b.is_fpa()); return b.ctx().num_val(a, b.get_sort()) == b; }
1652  inline expr operator==(expr const & a, double b) { assert(a.is_fpa()); return a == a.ctx().fpa_val(b); }
1653  inline expr operator==(double a, expr const & b) { assert(b.is_fpa()); return b.ctx().fpa_val(a) == b; }
1654 
1655  inline expr operator!=(expr const & a, expr const & b) {
1656  check_context(a, b);
1657  Z3_ast args[2] = { a, b };
1658  Z3_ast r = Z3_mk_distinct(a.ctx(), 2, args);
1659  a.check_error();
1660  return expr(a.ctx(), r);
1661  }
1662  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()); }
1663  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; }
1664  inline expr operator!=(expr const & a, double b) { assert(a.is_fpa()); return a != a.ctx().fpa_val(b); }
1665  inline expr operator!=(double a, expr const & b) { assert(b.is_fpa()); return b.ctx().fpa_val(a) != b; }
1666 
1667  inline expr operator+(expr const & a, expr const & b) {
1668  check_context(a, b);
1669  Z3_ast r = 0;
1670  if (a.is_arith() && b.is_arith()) {
1671  Z3_ast args[2] = { a, b };
1672  r = Z3_mk_add(a.ctx(), 2, args);
1673  }
1674  else if (a.is_bv() && b.is_bv()) {
1675  r = Z3_mk_bvadd(a.ctx(), a, b);
1676  }
1677  else if (a.is_seq() && b.is_seq()) {
1678  return concat(a, b);
1679  }
1680  else if (a.is_re() && b.is_re()) {
1681  Z3_ast _args[2] = { a, b };
1682  r = Z3_mk_re_union(a.ctx(), 2, _args);
1683  }
1684  else if (a.is_fpa() && b.is_fpa()) {
1685  r = Z3_mk_fpa_add(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1686  }
1687  else {
1688  // operator is not supported by given arguments.
1689  assert(false);
1690  }
1691  a.check_error();
1692  return expr(a.ctx(), r);
1693  }
1694  inline expr operator+(expr const & a, int b) { return a + a.ctx().num_val(b, a.get_sort()); }
1695  inline expr operator+(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) + b; }
1696 
1697  inline expr operator*(expr const & a, expr const & b) {
1698  check_context(a, b);
1699  Z3_ast r = 0;
1700  if (a.is_arith() && b.is_arith()) {
1701  Z3_ast args[2] = { a, b };
1702  r = Z3_mk_mul(a.ctx(), 2, args);
1703  }
1704  else if (a.is_bv() && b.is_bv()) {
1705  r = Z3_mk_bvmul(a.ctx(), a, b);
1706  }
1707  else if (a.is_fpa() && b.is_fpa()) {
1708  r = Z3_mk_fpa_mul(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1709  }
1710  else {
1711  // operator is not supported by given arguments.
1712  assert(false);
1713  }
1714  a.check_error();
1715  return expr(a.ctx(), r);
1716  }
1717  inline expr operator*(expr const & a, int b) { return a * a.ctx().num_val(b, a.get_sort()); }
1718  inline expr operator*(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) * b; }
1719 
1720 
1721  inline expr operator>=(expr const & a, expr const & b) {
1722  check_context(a, b);
1723  Z3_ast r = 0;
1724  if (a.is_arith() && b.is_arith()) {
1725  r = Z3_mk_ge(a.ctx(), a, b);
1726  }
1727  else if (a.is_bv() && b.is_bv()) {
1728  r = Z3_mk_bvsge(a.ctx(), a, b);
1729  }
1730  else if (a.is_fpa() && b.is_fpa()) {
1731  r = Z3_mk_fpa_geq(a.ctx(), a, b);
1732  }
1733  else {
1734  // operator is not supported by given arguments.
1735  assert(false);
1736  }
1737  a.check_error();
1738  return expr(a.ctx(), r);
1739  }
1740 
1741  inline expr operator/(expr const & a, expr const & b) {
1742  check_context(a, b);
1743  Z3_ast r = 0;
1744  if (a.is_arith() && b.is_arith()) {
1745  r = Z3_mk_div(a.ctx(), a, b);
1746  }
1747  else if (a.is_bv() && b.is_bv()) {
1748  r = Z3_mk_bvsdiv(a.ctx(), a, b);
1749  }
1750  else if (a.is_fpa() && b.is_fpa()) {
1751  r = Z3_mk_fpa_div(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1752  }
1753  else {
1754  // operator is not supported by given arguments.
1755  assert(false);
1756  }
1757  a.check_error();
1758  return expr(a.ctx(), r);
1759  }
1760  inline expr operator/(expr const & a, int b) { return a / a.ctx().num_val(b, a.get_sort()); }
1761  inline expr operator/(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) / b; }
1762 
1763  inline expr operator-(expr const & a) {
1764  Z3_ast r = 0;
1765  if (a.is_arith()) {
1766  r = Z3_mk_unary_minus(a.ctx(), a);
1767  }
1768  else if (a.is_bv()) {
1769  r = Z3_mk_bvneg(a.ctx(), a);
1770  }
1771  else if (a.is_fpa()) {
1772  r = Z3_mk_fpa_neg(a.ctx(), a);
1773  }
1774  else {
1775  // operator is not supported by given arguments.
1776  assert(false);
1777  }
1778  a.check_error();
1779  return expr(a.ctx(), r);
1780  }
1781 
1782  inline expr operator-(expr const & a, expr const & b) {
1783  check_context(a, b);
1784  Z3_ast r = 0;
1785  if (a.is_arith() && b.is_arith()) {
1786  Z3_ast args[2] = { a, b };
1787  r = Z3_mk_sub(a.ctx(), 2, args);
1788  }
1789  else if (a.is_bv() && b.is_bv()) {
1790  r = Z3_mk_bvsub(a.ctx(), a, b);
1791  }
1792  else if (a.is_fpa() && b.is_fpa()) {
1793  r = Z3_mk_fpa_sub(a.ctx(), a.ctx().fpa_rounding_mode(), a, b);
1794  }
1795  else {
1796  // operator is not supported by given arguments.
1797  assert(false);
1798  }
1799  a.check_error();
1800  return expr(a.ctx(), r);
1801  }
1802  inline expr operator-(expr const & a, int b) { return a - a.ctx().num_val(b, a.get_sort()); }
1803  inline expr operator-(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) - b; }
1804 
1805  inline expr operator<=(expr const & a, expr const & b) {
1806  check_context(a, b);
1807  Z3_ast r = 0;
1808  if (a.is_arith() && b.is_arith()) {
1809  r = Z3_mk_le(a.ctx(), a, b);
1810  }
1811  else if (a.is_bv() && b.is_bv()) {
1812  r = Z3_mk_bvsle(a.ctx(), a, b);
1813  }
1814  else if (a.is_fpa() && b.is_fpa()) {
1815  r = Z3_mk_fpa_leq(a.ctx(), a, b);
1816  }
1817  else {
1818  // operator is not supported by given arguments.
1819  assert(false);
1820  }
1821  a.check_error();
1822  return expr(a.ctx(), r);
1823  }
1824  inline expr operator<=(expr const & a, int b) { return a <= a.ctx().num_val(b, a.get_sort()); }
1825  inline expr operator<=(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) <= b; }
1826 
1827  inline expr operator>=(expr const & a, int b) { return a >= a.ctx().num_val(b, a.get_sort()); }
1828  inline expr operator>=(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) >= b; }
1829 
1830  inline expr operator<(expr const & a, expr const & b) {
1831  check_context(a, b);
1832  Z3_ast r = 0;
1833  if (a.is_arith() && b.is_arith()) {
1834  r = Z3_mk_lt(a.ctx(), a, b);
1835  }
1836  else if (a.is_bv() && b.is_bv()) {
1837  r = Z3_mk_bvslt(a.ctx(), a, b);
1838  }
1839  else if (a.is_fpa() && b.is_fpa()) {
1840  r = Z3_mk_fpa_lt(a.ctx(), a, b);
1841  }
1842  else {
1843  // operator is not supported by given arguments.
1844  assert(false);
1845  }
1846  a.check_error();
1847  return expr(a.ctx(), r);
1848  }
1849  inline expr operator<(expr const & a, int b) { return a < a.ctx().num_val(b, a.get_sort()); }
1850  inline expr operator<(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) < b; }
1851 
1852  inline expr operator>(expr const & a, expr const & b) {
1853  check_context(a, b);
1854  Z3_ast r = 0;
1855  if (a.is_arith() && b.is_arith()) {
1856  r = Z3_mk_gt(a.ctx(), a, b);
1857  }
1858  else if (a.is_bv() && b.is_bv()) {
1859  r = Z3_mk_bvsgt(a.ctx(), a, b);
1860  }
1861  else if (a.is_fpa() && b.is_fpa()) {
1862  r = Z3_mk_fpa_gt(a.ctx(), a, b);
1863  }
1864  else {
1865  // operator is not supported by given arguments.
1866  assert(false);
1867  }
1868  a.check_error();
1869  return expr(a.ctx(), r);
1870  }
1871  inline expr operator>(expr const & a, int b) { return a > a.ctx().num_val(b, a.get_sort()); }
1872  inline expr operator>(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) > b; }
1873 
1874  inline expr 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); }
1875  inline expr operator&(expr const & a, int b) { return a & a.ctx().num_val(b, a.get_sort()); }
1876  inline expr operator&(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) & b; }
1877 
1878  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); }
1879  inline expr operator^(expr const & a, int b) { return a ^ a.ctx().num_val(b, a.get_sort()); }
1880  inline expr operator^(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) ^ b; }
1881 
1882  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); }
1883  inline expr operator|(expr const & a, int b) { return a | a.ctx().num_val(b, a.get_sort()); }
1884  inline expr operator|(int a, expr const & b) { return b.ctx().num_val(a, b.get_sort()) | b; }
1885 
1886  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); }
1887  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); }
1888  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); }
1889  inline expr min(expr const& a, expr const& b) {
1890  check_context(a, b);
1891  Z3_ast r;
1892  if (a.is_arith()) {
1893  r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), b, a);
1894  }
1895  else if (a.is_bv()) {
1896  r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), b, a);
1897  }
1898  else {
1899  assert(a.is_fpa());
1900  r = Z3_mk_fpa_min(a.ctx(), a, b);
1901  }
1902  return expr(a.ctx(), r);
1903  }
1904  inline expr max(expr const& a, expr const& b) {
1905  check_context(a, b);
1906  Z3_ast r;
1907  if (a.is_arith()) {
1908  r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), a, b);
1909  }
1910  else if (a.is_bv()) {
1911  r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), a, b);
1912  }
1913  else {
1914  assert(a.is_fpa());
1915  r = Z3_mk_fpa_max(a.ctx(), a, b);
1916  }
1917  return expr(a.ctx(), r);
1918  }
1919  inline expr bvredor(expr const & a) {
1920  assert(a.is_bv());
1921  Z3_ast r = Z3_mk_bvredor(a.ctx(), a);
1922  a.check_error();
1923  return expr(a.ctx(), r);
1924  }
1925  inline expr bvredand(expr const & a) {
1926  assert(a.is_bv());
1927  Z3_ast r = Z3_mk_bvredand(a.ctx(), a);
1928  a.check_error();
1929  return expr(a.ctx(), r);
1930  }
1931  inline expr abs(expr const & a) {
1932  Z3_ast r;
1933  if (a.is_int()) {
1934  expr zero = a.ctx().int_val(0);
1935  expr ge = a >= zero;
1936  expr na = -a;
1937  r = Z3_mk_ite(a.ctx(), ge, a, na);
1938  }
1939  else if (a.is_real()) {
1940  expr zero = a.ctx().real_val(0);
1941  expr ge = a >= zero;
1942  expr na = -a;
1943  r = Z3_mk_ite(a.ctx(), ge, a, na);
1944  }
1945  else {
1946  r = Z3_mk_fpa_abs(a.ctx(), a);
1947  }
1948  a.check_error();
1949  return expr(a.ctx(), r);
1950  }
1951  inline expr sqrt(expr const & a, expr const& rm) {
1952  check_context(a, rm);
1953  assert(a.is_fpa());
1954  Z3_ast r = Z3_mk_fpa_sqrt(a.ctx(), rm, a);
1955  a.check_error();
1956  return expr(a.ctx(), r);
1957  }
1958  inline expr fp_eq(expr const & a, expr const & b) {
1959  check_context(a, b);
1960  assert(a.is_fpa());
1961  Z3_ast r = Z3_mk_fpa_eq(a.ctx(), a, b);
1962  a.check_error();
1963  return expr(a.ctx(), r);
1964  }
1965  inline expr operator~(expr const & a) { Z3_ast r = Z3_mk_bvnot(a.ctx(), a); return expr(a.ctx(), r); }
1966 
1967  inline expr fma(expr const& a, expr const& b, expr const& c, expr const& rm) {
1968  check_context(a, b); check_context(a, c); check_context(a, rm);
1969  assert(a.is_fpa() && b.is_fpa() && c.is_fpa());
1970  Z3_ast r = Z3_mk_fpa_fma(a.ctx(), rm, a, b, c);
1971  a.check_error();
1972  return expr(a.ctx(), r);
1973  }
1974 
1975  inline expr fpa_fp(expr const& sgn, expr const& exp, expr const& sig) {
1976  check_context(sgn, exp); check_context(exp, sig);
1977  assert(sgn.is_bv() && exp.is_bv() && sig.is_bv());
1978  Z3_ast r = Z3_mk_fpa_fp(sgn.ctx(), sgn, exp, sig);
1979  sgn.check_error();
1980  return expr(sgn.ctx(), r);
1981  }
1982 
1983  inline expr fpa_to_sbv(expr const& t, unsigned sz) {
1984  assert(t.is_fpa());
1985  Z3_ast r = Z3_mk_fpa_to_sbv(t.ctx(), t.ctx().fpa_rounding_mode(), t, sz);
1986  t.check_error();
1987  return expr(t.ctx(), r);
1988  }
1989 
1990  inline expr fpa_to_ubv(expr const& t, unsigned sz) {
1991  assert(t.is_fpa());
1992  Z3_ast r = Z3_mk_fpa_to_ubv(t.ctx(), t.ctx().fpa_rounding_mode(), t, sz);
1993  t.check_error();
1994  return expr(t.ctx(), r);
1995  }
1996 
1997  inline expr sbv_to_fpa(expr const& t, sort s) {
1998  assert(t.is_bv());
1999  Z3_ast r = Z3_mk_fpa_to_fp_signed(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2000  t.check_error();
2001  return expr(t.ctx(), r);
2002  }
2003 
2004  inline expr ubv_to_fpa(expr const& t, sort s) {
2005  assert(t.is_bv());
2006  Z3_ast r = Z3_mk_fpa_to_fp_unsigned(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2007  t.check_error();
2008  return expr(t.ctx(), r);
2009  }
2010 
2011  inline expr fpa_to_fpa(expr const& t, sort s) {
2012  assert(t.is_fpa());
2013  Z3_ast r = Z3_mk_fpa_to_fp_float(t.ctx(), t.ctx().fpa_rounding_mode(), t, s);
2014  t.check_error();
2015  return expr(t.ctx(), r);
2016  }
2017 
2019  assert(t.is_fpa());
2020  Z3_ast r = Z3_mk_fpa_round_to_integral(t.ctx(), t.ctx().fpa_rounding_mode(), t);
2021  t.check_error();
2022  return expr(t.ctx(), r);
2023  }
2024 
2030  inline expr ite(expr const & c, expr const & t, expr const & e) {
2031  check_context(c, t); check_context(c, e);
2032  assert(c.is_bool());
2033  Z3_ast r = Z3_mk_ite(c.ctx(), c, t, e);
2034  c.check_error();
2035  return expr(c.ctx(), r);
2036  }
2037 
2038 
2043  inline expr to_expr(context & c, Z3_ast a) {
2044  c.check_error();
2045  assert(Z3_get_ast_kind(c, a) == Z3_APP_AST ||
2046  Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST ||
2047  Z3_get_ast_kind(c, a) == Z3_VAR_AST ||
2049  return expr(c, a);
2050  }
2051 
2052  inline sort to_sort(context & c, Z3_sort s) {
2053  c.check_error();
2054  return sort(c, s);
2055  }
2056 
2057  inline func_decl to_func_decl(context & c, Z3_func_decl f) {
2058  c.check_error();
2059  return func_decl(c, f);
2060  }
2061 
2065  inline expr sle(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsle(a.ctx(), a, b)); }
2066  inline expr sle(expr const & a, int b) { return sle(a, a.ctx().num_val(b, a.get_sort())); }
2067  inline expr sle(int a, expr const & b) { return sle(b.ctx().num_val(a, b.get_sort()), b); }
2071  inline expr slt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvslt(a.ctx(), a, b)); }
2072  inline expr slt(expr const & a, int b) { return slt(a, a.ctx().num_val(b, a.get_sort())); }
2073  inline expr slt(int a, expr const & b) { return slt(b.ctx().num_val(a, b.get_sort()), b); }
2077  inline expr sge(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsge(a.ctx(), a, b)); }
2078  inline expr sge(expr const & a, int b) { return sge(a, a.ctx().num_val(b, a.get_sort())); }
2079  inline expr sge(int a, expr const & b) { return sge(b.ctx().num_val(a, b.get_sort()), b); }
2083  inline expr sgt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsgt(a.ctx(), a, b)); }
2084  inline expr sgt(expr const & a, int b) { return sgt(a, a.ctx().num_val(b, a.get_sort())); }
2085  inline expr sgt(int a, expr const & b) { return sgt(b.ctx().num_val(a, b.get_sort()), b); }
2086 
2087 
2091  inline expr ule(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvule(a.ctx(), a, b)); }
2092  inline expr ule(expr const & a, int b) { return ule(a, a.ctx().num_val(b, a.get_sort())); }
2093  inline expr ule(int a, expr const & b) { return ule(b.ctx().num_val(a, b.get_sort()), b); }
2097  inline expr ult(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvult(a.ctx(), a, b)); }
2098  inline expr ult(expr const & a, int b) { return ult(a, a.ctx().num_val(b, a.get_sort())); }
2099  inline expr ult(int a, expr const & b) { return ult(b.ctx().num_val(a, b.get_sort()), b); }
2103  inline expr uge(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b)); }
2104  inline expr uge(expr const & a, int b) { return uge(a, a.ctx().num_val(b, a.get_sort())); }
2105  inline expr uge(int a, expr const & b) { return uge(b.ctx().num_val(a, b.get_sort()), b); }
2109  inline expr ugt(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvugt(a.ctx(), a, b)); }
2110  inline expr ugt(expr const & a, int b) { return ugt(a, a.ctx().num_val(b, a.get_sort())); }
2111  inline expr ugt(int a, expr const & b) { return ugt(b.ctx().num_val(a, b.get_sort()), b); }
2115  inline expr udiv(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvudiv(a.ctx(), a, b)); }
2116  inline expr udiv(expr const & a, int b) { return udiv(a, a.ctx().num_val(b, a.get_sort())); }
2117  inline expr udiv(int a, expr const & b) { return udiv(b.ctx().num_val(a, b.get_sort()), b); }
2118 
2122  inline expr srem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsrem(a.ctx(), a, b)); }
2123  inline expr srem(expr const & a, int b) { return srem(a, a.ctx().num_val(b, a.get_sort())); }
2124  inline expr srem(int a, expr const & b) { return srem(b.ctx().num_val(a, b.get_sort()), b); }
2125 
2129  inline expr smod(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsmod(a.ctx(), a, b)); }
2130  inline expr smod(expr const & a, int b) { return smod(a, a.ctx().num_val(b, a.get_sort())); }
2131  inline expr smod(int a, expr const & b) { return smod(b.ctx().num_val(a, b.get_sort()), b); }
2132 
2136  inline expr urem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvurem(a.ctx(), a, b)); }
2137  inline expr urem(expr const & a, int b) { return urem(a, a.ctx().num_val(b, a.get_sort())); }
2138  inline expr urem(int a, expr const & b) { return urem(b.ctx().num_val(a, b.get_sort()), b); }
2139 
2143  inline expr shl(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvshl(a.ctx(), a, b)); }
2144  inline expr shl(expr const & a, int b) { return shl(a, a.ctx().num_val(b, a.get_sort())); }
2145  inline expr shl(int a, expr const & b) { return shl(b.ctx().num_val(a, b.get_sort()), b); }
2146 
2150  inline expr lshr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvlshr(a.ctx(), a, b)); }
2151  inline expr lshr(expr const & a, int b) { return lshr(a, a.ctx().num_val(b, a.get_sort())); }
2152  inline expr lshr(int a, expr const & b) { return lshr(b.ctx().num_val(a, b.get_sort()), b); }
2153 
2157  inline expr ashr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvashr(a.ctx(), a, b)); }
2158  inline expr ashr(expr const & a, int b) { return ashr(a, a.ctx().num_val(b, a.get_sort())); }
2159  inline expr ashr(int a, expr const & b) { return ashr(b.ctx().num_val(a, b.get_sort()), b); }
2160 
2164  inline expr zext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_zero_ext(a.ctx(), i, a)); }
2165 
2169  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); }
2170  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); }
2171 
2175  inline expr bvadd_no_overflow(expr const& a, expr const& b, bool is_signed) {
2176  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);
2177  }
2178  inline expr bvadd_no_underflow(expr const& a, expr const& b) {
2179  check_context(a, b); Z3_ast r = Z3_mk_bvadd_no_underflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2180  }
2181  inline expr bvsub_no_overflow(expr const& a, expr const& b) {
2182  check_context(a, b); Z3_ast r = Z3_mk_bvsub_no_overflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2183  }
2184  inline expr bvsub_no_underflow(expr const& a, expr const& b, bool is_signed) {
2185  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);
2186  }
2187  inline expr bvsdiv_no_overflow(expr const& a, expr const& b) {
2188  check_context(a, b); Z3_ast r = Z3_mk_bvsdiv_no_overflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2189  }
2190  inline expr bvneg_no_overflow(expr const& a) {
2191  Z3_ast r = Z3_mk_bvneg_no_overflow(a.ctx(), a); a.check_error(); return expr(a.ctx(), r);
2192  }
2193  inline expr bvmul_no_overflow(expr const& a, expr const& b, bool is_signed) {
2194  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);
2195  }
2196  inline expr bvmul_no_underflow(expr const& a, expr const& b) {
2197  check_context(a, b); Z3_ast r = Z3_mk_bvmul_no_underflow(a.ctx(), a, b); a.check_error(); return expr(a.ctx(), r);
2198  }
2199 
2200 
2204  inline expr sext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_sign_ext(a.ctx(), i, a)); }
2205 
2206  inline func_decl linear_order(sort const& a, unsigned index) {
2207  return to_func_decl(a.ctx(), Z3_mk_linear_order(a.ctx(), a, index));
2208  }
2209  inline func_decl partial_order(sort const& a, unsigned index) {
2210  return to_func_decl(a.ctx(), Z3_mk_partial_order(a.ctx(), a, index));
2211  }
2212  inline func_decl piecewise_linear_order(sort const& a, unsigned index) {
2213  return to_func_decl(a.ctx(), Z3_mk_piecewise_linear_order(a.ctx(), a, index));
2214  }
2215  inline func_decl tree_order(sort const& a, unsigned index) {
2216  return to_func_decl(a.ctx(), Z3_mk_tree_order(a.ctx(), a, index));
2217  }
2218 
2219  template<> class cast_ast<ast> {
2220  public:
2221  ast operator()(context & c, Z3_ast a) { return ast(c, a); }
2222  };
2223 
2224  template<> class cast_ast<expr> {
2225  public:
2226  expr operator()(context & c, Z3_ast a) {
2227  assert(Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST ||
2228  Z3_get_ast_kind(c, a) == Z3_APP_AST ||
2230  Z3_get_ast_kind(c, a) == Z3_VAR_AST);
2231  return expr(c, a);
2232  }
2233  };
2234 
2235  template<> class cast_ast<sort> {
2236  public:
2237  sort operator()(context & c, Z3_ast a) {
2238  assert(Z3_get_ast_kind(c, a) == Z3_SORT_AST);
2239  return sort(c, reinterpret_cast<Z3_sort>(a));
2240  }
2241  };
2242 
2243  template<> class cast_ast<func_decl> {
2244  public:
2245  func_decl operator()(context & c, Z3_ast a) {
2246  assert(Z3_get_ast_kind(c, a) == Z3_FUNC_DECL_AST);
2247  return func_decl(c, reinterpret_cast<Z3_func_decl>(a));
2248  }
2249  };
2250 
2251  template<typename T>
2252  template<typename T2>
2253  array<T>::array(ast_vector_tpl<T2> const & v):m_array(new T[v.size()]), m_size(v.size()) {
2254  for (unsigned i = 0; i < m_size; i++) {
2255  m_array[i] = v[i];
2256  }
2257  }
2258 
2259  // Basic functions for creating quantified formulas.
2260  // The C API should be used for creating quantifiers with patterns, weights, many variables, etc.
2261  inline expr forall(expr const & x, expr const & b) {
2262  check_context(x, b);
2263  Z3_app vars[] = {(Z3_app) x};
2264  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 1, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2265  }
2266  inline expr forall(expr const & x1, expr const & x2, expr const & b) {
2267  check_context(x1, b); check_context(x2, b);
2268  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2269  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 2, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2270  }
2271  inline expr forall(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2272  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2273  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2274  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 3, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2275  }
2276  inline expr forall(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2277  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2278  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2279  Z3_ast r = Z3_mk_forall_const(b.ctx(), 0, 4, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2280  }
2281  inline expr forall(expr_vector const & xs, expr const & b) {
2282  array<Z3_app> vars(xs);
2283  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);
2284  }
2285  inline expr exists(expr const & x, expr const & b) {
2286  check_context(x, b);
2287  Z3_app vars[] = {(Z3_app) x};
2288  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 1, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2289  }
2290  inline expr exists(expr const & x1, expr const & x2, expr const & b) {
2291  check_context(x1, b); check_context(x2, b);
2292  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2293  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 2, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2294  }
2295  inline expr exists(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2296  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2297  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2298  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 3, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2299  }
2300  inline expr exists(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2301  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2302  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2303  Z3_ast r = Z3_mk_exists_const(b.ctx(), 0, 4, vars, 0, 0, b); b.check_error(); return expr(b.ctx(), r);
2304  }
2305  inline expr exists(expr_vector const & xs, expr const & b) {
2306  array<Z3_app> vars(xs);
2307  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);
2308  }
2309  inline expr lambda(expr const & x, expr const & b) {
2310  check_context(x, b);
2311  Z3_app vars[] = {(Z3_app) x};
2312  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 1, vars, b); b.check_error(); return expr(b.ctx(), r);
2313  }
2314  inline expr lambda(expr const & x1, expr const & x2, expr const & b) {
2315  check_context(x1, b); check_context(x2, b);
2316  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2};
2317  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 2, vars, b); b.check_error(); return expr(b.ctx(), r);
2318  }
2319  inline expr lambda(expr const & x1, expr const & x2, expr const & x3, expr const & b) {
2320  check_context(x1, b); check_context(x2, b); check_context(x3, b);
2321  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3 };
2322  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 3, vars, b); b.check_error(); return expr(b.ctx(), r);
2323  }
2324  inline expr lambda(expr const & x1, expr const & x2, expr const & x3, expr const & x4, expr const & b) {
2325  check_context(x1, b); check_context(x2, b); check_context(x3, b); check_context(x4, b);
2326  Z3_app vars[] = {(Z3_app) x1, (Z3_app) x2, (Z3_app) x3, (Z3_app) x4 };
2327  Z3_ast r = Z3_mk_lambda_const(b.ctx(), 4, vars, b); b.check_error(); return expr(b.ctx(), r);
2328  }
2329  inline expr lambda(expr_vector const & xs, expr const & b) {
2330  array<Z3_app> vars(xs);
2331  Z3_ast r = Z3_mk_lambda_const(b.ctx(), vars.size(), vars.ptr(), b); b.check_error(); return expr(b.ctx(), r);
2332  }
2333 
2334  inline expr pble(expr_vector const& es, int const* coeffs, int bound) {
2335  assert(es.size() > 0);
2336  context& ctx = es[0U].ctx();
2337  array<Z3_ast> _es(es);
2338  Z3_ast r = Z3_mk_pble(ctx, _es.size(), _es.ptr(), coeffs, bound);
2339  ctx.check_error();
2340  return expr(ctx, r);
2341  }
2342  inline expr pbge(expr_vector const& es, int const* coeffs, int bound) {
2343  assert(es.size() > 0);
2344  context& ctx = es[0U].ctx();
2345  array<Z3_ast> _es(es);
2346  Z3_ast r = Z3_mk_pbge(ctx, _es.size(), _es.ptr(), coeffs, bound);
2347  ctx.check_error();
2348  return expr(ctx, r);
2349  }
2350  inline expr pbeq(expr_vector const& es, int const* coeffs, int bound) {
2351  assert(es.size() > 0);
2352  context& ctx = es[0U].ctx();
2353  array<Z3_ast> _es(es);
2354  Z3_ast r = Z3_mk_pbeq(ctx, _es.size(), _es.ptr(), coeffs, bound);
2355  ctx.check_error();
2356  return expr(ctx, r);
2357  }
2358  inline expr atmost(expr_vector const& es, unsigned bound) {
2359  assert(es.size() > 0);
2360  context& ctx = es[0U].ctx();
2361  array<Z3_ast> _es(es);
2362  Z3_ast r = Z3_mk_atmost(ctx, _es.size(), _es.ptr(), bound);
2363  ctx.check_error();
2364  return expr(ctx, r);
2365  }
2366  inline expr atleast(expr_vector const& es, unsigned bound) {
2367  assert(es.size() > 0);
2368  context& ctx = es[0U].ctx();
2369  array<Z3_ast> _es(es);
2370  Z3_ast r = Z3_mk_atleast(ctx, _es.size(), _es.ptr(), bound);
2371  ctx.check_error();
2372  return expr(ctx, r);
2373  }
2374  inline expr sum(expr_vector const& args) {
2375  assert(args.size() > 0);
2376  context& ctx = args[0U].ctx();
2377  array<Z3_ast> _args(args);
2378  Z3_ast r = Z3_mk_add(ctx, _args.size(), _args.ptr());
2379  ctx.check_error();
2380  return expr(ctx, r);
2381  }
2382 
2383  inline expr distinct(expr_vector const& args) {
2384  assert(args.size() > 0);
2385  context& ctx = args[0U].ctx();
2386  array<Z3_ast> _args(args);
2387  Z3_ast r = Z3_mk_distinct(ctx, _args.size(), _args.ptr());
2388  ctx.check_error();
2389  return expr(ctx, r);
2390  }
2391 
2392  inline expr concat(expr const& a, expr const& b) {
2393  check_context(a, b);
2394  Z3_ast r;
2395  if (Z3_is_seq_sort(a.ctx(), a.get_sort())) {
2396  Z3_ast _args[2] = { a, b };
2397  r = Z3_mk_seq_concat(a.ctx(), 2, _args);
2398  }
2399  else if (Z3_is_re_sort(a.ctx(), a.get_sort())) {
2400  Z3_ast _args[2] = { a, b };
2401  r = Z3_mk_re_concat(a.ctx(), 2, _args);
2402  }
2403  else {
2404  r = Z3_mk_concat(a.ctx(), a, b);
2405  }
2406  a.ctx().check_error();
2407  return expr(a.ctx(), r);
2408  }
2409 
2410  inline expr concat(expr_vector const& args) {
2411  Z3_ast r;
2412  assert(args.size() > 0);
2413  if (args.size() == 1) {
2414  return args[0U];
2415  }
2416  context& ctx = args[0U].ctx();
2417  array<Z3_ast> _args(args);
2418  if (Z3_is_seq_sort(ctx, args[0U].get_sort())) {
2419  r = Z3_mk_seq_concat(ctx, _args.size(), _args.ptr());
2420  }
2421  else if (Z3_is_re_sort(ctx, args[0U].get_sort())) {
2422  r = Z3_mk_re_concat(ctx, _args.size(), _args.ptr());
2423  }
2424  else {
2425  r = _args[args.size()-1];
2426  for (unsigned i = args.size()-1; i > 0; ) {
2427  --i;
2428  r = Z3_mk_concat(ctx, _args[i], r);
2429  ctx.check_error();
2430  }
2431  }
2432  ctx.check_error();
2433  return expr(ctx, r);
2434  }
2435 
2436  inline expr mk_or(expr_vector const& args) {
2437  array<Z3_ast> _args(args);
2438  Z3_ast r = Z3_mk_or(args.ctx(), _args.size(), _args.ptr());
2439  args.check_error();
2440  return expr(args.ctx(), r);
2441  }
2442  inline expr mk_and(expr_vector const& args) {
2443  array<Z3_ast> _args(args);
2444  Z3_ast r = Z3_mk_and(args.ctx(), _args.size(), _args.ptr());
2445  args.check_error();
2446  return expr(args.ctx(), r);
2447  }
2448  inline expr mk_xor(expr_vector const& args) {
2449  if (args.empty())
2450  return args.ctx().bool_val(false);
2451  expr r = args[0U];
2452  for (unsigned i = 1; i < args.size(); ++i)
2453  r = r ^ args[i];
2454  return r;
2455  }
2456 
2457 
2458  class func_entry : public object {
2459  Z3_func_entry m_entry;
2460  void init(Z3_func_entry e) {
2461  m_entry = e;
2462  Z3_func_entry_inc_ref(ctx(), m_entry);
2463  }
2464  public:
2465  func_entry(context & c, Z3_func_entry e):object(c) { init(e); }
2466  func_entry(func_entry const & s):object(s) { init(s.m_entry); }
2468  operator Z3_func_entry() const { return m_entry; }
2470  Z3_func_entry_inc_ref(s.ctx(), s.m_entry);
2471  Z3_func_entry_dec_ref(ctx(), m_entry);
2472  object::operator=(s);
2473  m_entry = s.m_entry;
2474  return *this;
2475  }
2476  expr value() const { Z3_ast r = Z3_func_entry_get_value(ctx(), m_entry); check_error(); return expr(ctx(), r); }
2477  unsigned num_args() const { unsigned r = Z3_func_entry_get_num_args(ctx(), m_entry); check_error(); return r; }
2478  expr arg(unsigned i) const { Z3_ast r = Z3_func_entry_get_arg(ctx(), m_entry, i); check_error(); return expr(ctx(), r); }
2479  };
2480 
2481  class func_interp : public object {
2482  Z3_func_interp m_interp;
2483  void init(Z3_func_interp e) {
2484  m_interp = e;
2485  Z3_func_interp_inc_ref(ctx(), m_interp);
2486  }
2487  public:
2488  func_interp(context & c, Z3_func_interp e):object(c) { init(e); }
2489  func_interp(func_interp const & s):object(s) { init(s.m_interp); }
2491  operator Z3_func_interp() const { return m_interp; }
2493  Z3_func_interp_inc_ref(s.ctx(), s.m_interp);
2494  Z3_func_interp_dec_ref(ctx(), m_interp);
2495  object::operator=(s);
2496  m_interp = s.m_interp;
2497  return *this;
2498  }
2499  expr else_value() const { Z3_ast r = Z3_func_interp_get_else(ctx(), m_interp); check_error(); return expr(ctx(), r); }
2500  unsigned num_entries() const { unsigned r = Z3_func_interp_get_num_entries(ctx(), m_interp); check_error(); return r; }
2501  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); }
2502  void add_entry(expr_vector const& args, expr& value) {
2503  Z3_func_interp_add_entry(ctx(), m_interp, args, value);
2504  check_error();
2505  }
2506  void set_else(expr& value) {
2507  Z3_func_interp_set_else(ctx(), m_interp, value);
2508  check_error();
2509  }
2510  };
2511 
2512  class model : public object {
2513  Z3_model m_model;
2514  void init(Z3_model m) {
2515  m_model = m;
2516  Z3_model_inc_ref(ctx(), m);
2517  }
2518  public:
2519  struct translate {};
2520  model(context & c):object(c) { init(Z3_mk_model(c)); }
2521  model(context & c, Z3_model m):object(c) { init(m); }
2522  model(model const & s):object(s) { init(s.m_model); }
2523  model(model& src, context& dst, translate) : object(dst) { init(Z3_model_translate(src.ctx(), src, dst)); }
2524  ~model() { Z3_model_dec_ref(ctx(), m_model); }
2525  operator Z3_model() const { return m_model; }
2526  model & operator=(model const & s) {
2527  Z3_model_inc_ref(s.ctx(), s.m_model);
2528  Z3_model_dec_ref(ctx(), m_model);
2529  object::operator=(s);
2530  m_model = s.m_model;
2531  return *this;
2532  }
2533 
2534  expr eval(expr const & n, bool model_completion=false) const {
2535  check_context(*this, n);
2536  Z3_ast r = 0;
2537  bool status = Z3_model_eval(ctx(), m_model, n, model_completion, &r);
2538  check_error();
2539  if (status == false && ctx().enable_exceptions())
2540  Z3_THROW(exception("failed to evaluate expression"));
2541  return expr(ctx(), r);
2542  }
2543 
2544  unsigned num_consts() const { return Z3_model_get_num_consts(ctx(), m_model); }
2545  unsigned num_funcs() const { return Z3_model_get_num_funcs(ctx(), m_model); }
2546  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); }
2547  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); }
2548  unsigned size() const { return num_consts() + num_funcs(); }
2549  func_decl operator[](int i) const {
2550  assert(0 <= i);
2551  return static_cast<unsigned>(i) < num_consts() ? get_const_decl(i) : get_func_decl(i - num_consts());
2552  }
2553 
2554  // returns interpretation of constant declaration c.
2555  // If c is not assigned any value in the model it returns
2556  // an expression with a null ast reference.
2558  check_context(*this, c);
2559  Z3_ast r = Z3_model_get_const_interp(ctx(), m_model, c);
2560  check_error();
2561  return expr(ctx(), r);
2562  }
2564  check_context(*this, f);
2565  Z3_func_interp r = Z3_model_get_func_interp(ctx(), m_model, f);
2566  check_error();
2567  return func_interp(ctx(), r);
2568  }
2569 
2570  // returns true iff the model contains an interpretation
2571  // for function f.
2572  bool has_interp(func_decl f) const {
2573  check_context(*this, f);
2574  return Z3_model_has_interp(ctx(), m_model, f);
2575  }
2576 
2578  Z3_func_interp r = Z3_add_func_interp(ctx(), m_model, f, else_val);
2579  check_error();
2580  return func_interp(ctx(), r);
2581  }
2582 
2583  void add_const_interp(func_decl& f, expr& value) {
2584  Z3_add_const_interp(ctx(), m_model, f, value);
2585  check_error();
2586  }
2587 
2588  friend std::ostream & operator<<(std::ostream & out, model const & m);
2589 
2590  std::string to_string() const { return m_model ? std::string(Z3_model_to_string(ctx(), m_model)) : "null"; }
2591  };
2592  inline std::ostream & operator<<(std::ostream & out, model const & m) { return out << m.to_string(); }
2593 
2594  class stats : public object {
2595  Z3_stats m_stats;
2596  void init(Z3_stats e) {
2597  m_stats = e;
2598  Z3_stats_inc_ref(ctx(), m_stats);
2599  }
2600  public:
2601  stats(context & c):object(c), m_stats(0) {}
2602  stats(context & c, Z3_stats e):object(c) { init(e); }
2603  stats(stats const & s):object(s) { init(s.m_stats); }
2604  ~stats() { if (m_stats) Z3_stats_dec_ref(ctx(), m_stats); }
2605  operator Z3_stats() const { return m_stats; }
2606  stats & operator=(stats const & s) {
2607  Z3_stats_inc_ref(s.ctx(), s.m_stats);
2608  if (m_stats) Z3_stats_dec_ref(ctx(), m_stats);
2609  object::operator=(s);
2610  m_stats = s.m_stats;
2611  return *this;
2612  }
2613  unsigned size() const { return Z3_stats_size(ctx(), m_stats); }
2614  std::string key(unsigned i) const { Z3_string s = Z3_stats_get_key(ctx(), m_stats, i); check_error(); return s; }
2615  bool is_uint(unsigned i) const { bool r = Z3_stats_is_uint(ctx(), m_stats, i); check_error(); return r; }
2616  bool is_double(unsigned i) const { bool r = Z3_stats_is_double(ctx(), m_stats, i); check_error(); return r; }
2617  unsigned uint_value(unsigned i) const { unsigned r = Z3_stats_get_uint_value(ctx(), m_stats, i); check_error(); return r; }
2618  double double_value(unsigned i) const { double r = Z3_stats_get_double_value(ctx(), m_stats, i); check_error(); return r; }
2619  friend std::ostream & operator<<(std::ostream & out, stats const & s);
2620  };
2621  inline std::ostream & operator<<(std::ostream & out, stats const & s) { out << Z3_stats_to_string(s.ctx(), s); return out; }
2622 
2623 
2624  inline std::ostream & operator<<(std::ostream & out, check_result r) {
2625  if (r == unsat) out << "unsat";
2626  else if (r == sat) out << "sat";
2627  else out << "unknown";
2628  return out;
2629  }
2630 
2631 
2632  class solver : public object {
2633  Z3_solver m_solver;
2634  void init(Z3_solver s) {
2635  m_solver = s;
2636  if (s)
2637  Z3_solver_inc_ref(ctx(), s);
2638  }
2639  public:
2640  struct simple {};
2641  struct translate {};
2642  solver(context & c):object(c) { init(Z3_mk_solver(c)); }
2644  solver(context & c, Z3_solver s):object(c) { init(s); }
2645  solver(context & c, char const * logic):object(c) { init(Z3_mk_solver_for_logic(c, c.str_symbol(logic))); }
2646  solver(context & c, solver const& src, translate): object(c) { Z3_solver s = Z3_solver_translate(src.ctx(), src, c); check_error(); init(s); }
2647  solver(solver const & s):object(s) { init(s.m_solver); }
2648  ~solver() { Z3_solver_dec_ref(ctx(), m_solver); }
2649  operator Z3_solver() const { return m_solver; }
2650  solver & operator=(solver const & s) {
2651  Z3_solver_inc_ref(s.ctx(), s.m_solver);
2652  Z3_solver_dec_ref(ctx(), m_solver);
2653  object::operator=(s);
2654  m_solver = s.m_solver;
2655  return *this;
2656  }
2657  void set(params const & p) { Z3_solver_set_params(ctx(), m_solver, p); check_error(); }
2658  void set(char const * k, bool v) { params p(ctx()); p.set(k, v); set(p); }
2659  void set(char const * k, unsigned v) { params p(ctx()); p.set(k, v); set(p); }
2660  void set(char const * k, double v) { params p(ctx()); p.set(k, v); set(p); }
2661  void set(char const * k, symbol const & v) { params p(ctx()); p.set(k, v); set(p); }
2662  void set(char const * k, char const* v) { params p(ctx()); p.set(k, v); set(p); }
2663  void push() { Z3_solver_push(ctx(), m_solver); check_error(); }
2664  void pop(unsigned n = 1) { Z3_solver_pop(ctx(), m_solver, n); check_error(); }
2665  void reset() { Z3_solver_reset(ctx(), m_solver); check_error(); }
2666  void add(expr const & e) { assert(e.is_bool()); Z3_solver_assert(ctx(), m_solver, e); check_error(); }
2667  void add(expr const & e, expr const & p) {
2668  assert(e.is_bool()); assert(p.is_bool()); assert(p.is_const());
2669  Z3_solver_assert_and_track(ctx(), m_solver, e, p);
2670  check_error();
2671  }
2672  void add(expr const & e, char const * p) {
2673  add(e, ctx().bool_const(p));
2674  }
2675  void add(expr_vector const& v) {
2676  check_context(*this, v);
2677  for (unsigned i = 0; i < v.size(); ++i)
2678  add(v[i]);
2679  }
2680  void from_file(char const* file) { Z3_solver_from_file(ctx(), m_solver, file); ctx().check_parser_error(); }
2681  void from_string(char const* s) { Z3_solver_from_string(ctx(), m_solver, s); ctx().check_parser_error(); }
2682 
2684  check_result check(unsigned n, expr * const assumptions) {
2685  array<Z3_ast> _assumptions(n);
2686  for (unsigned i = 0; i < n; i++) {
2687  check_context(*this, assumptions[i]);
2688  _assumptions[i] = assumptions[i];
2689  }
2690  Z3_lbool r = Z3_solver_check_assumptions(ctx(), m_solver, n, _assumptions.ptr());
2691  check_error();
2692  return to_check_result(r);
2693  }
2694  check_result check(expr_vector const& assumptions) {
2695  unsigned n = assumptions.size();
2696  array<Z3_ast> _assumptions(n);
2697  for (unsigned i = 0; i < n; i++) {
2698  check_context(*this, assumptions[i]);
2699  _assumptions[i] = assumptions[i];
2700  }
2701  Z3_lbool r = Z3_solver_check_assumptions(ctx(), m_solver, n, _assumptions.ptr());
2702  check_error();
2703  return to_check_result(r);
2704  }
2705  model get_model() const { Z3_model m = Z3_solver_get_model(ctx(), m_solver); check_error(); return model(ctx(), m); }
2707  Z3_lbool r = Z3_solver_get_consequences(ctx(), m_solver, assumptions, vars, conseq);
2708  check_error();
2709  return to_check_result(r);
2710  }
2711  std::string reason_unknown() const { Z3_string r = Z3_solver_get_reason_unknown(ctx(), m_solver); check_error(); return r; }
2712  stats statistics() const { Z3_stats r = Z3_solver_get_statistics(ctx(), m_solver); check_error(); return stats(ctx(), r); }
2713  expr_vector unsat_core() const { Z3_ast_vector r = Z3_solver_get_unsat_core(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2714  expr_vector assertions() const { Z3_ast_vector r = Z3_solver_get_assertions(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2715  expr_vector non_units() const { Z3_ast_vector r = Z3_solver_get_non_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2716  expr_vector units() const { Z3_ast_vector r = Z3_solver_get_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2717  expr_vector trail() const { Z3_ast_vector r = Z3_solver_get_trail(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); }
2719  Z3_ast_vector r = Z3_solver_get_trail(ctx(), m_solver);
2720  check_error();
2721  expr_vector result(ctx(), r);
2722  unsigned sz = result.size();
2723  levels.resize(sz);
2724  Z3_solver_get_levels(ctx(), m_solver, r, sz, levels.ptr());
2725  check_error();
2726  return result;
2727  }
2728  expr proof() const { Z3_ast r = Z3_solver_get_proof(ctx(), m_solver); check_error(); return expr(ctx(), r); }
2729  friend std::ostream & operator<<(std::ostream & out, solver const & s);
2730 
2731  std::string to_smt2(char const* status = "unknown") {
2732  array<Z3_ast> es(assertions());
2733  Z3_ast const* fmls = es.ptr();
2734  Z3_ast fml = 0;
2735  unsigned sz = es.size();
2736  if (sz > 0) {
2737  --sz;
2738  fml = fmls[sz];
2739  }
2740  else {
2741  fml = ctx().bool_val(true);
2742  }
2743  return std::string(Z3_benchmark_to_smtlib_string(
2744  ctx(),
2745  "", "", status, "",
2746  sz,
2747  fmls,
2748  fml));
2749  }
2750 
2751  std::string dimacs(bool include_names = true) const { return std::string(Z3_solver_to_dimacs_string(ctx(), m_solver, include_names)); }
2752 
2754 
2755 
2756  expr_vector cube(expr_vector& vars, unsigned cutoff) {
2757  Z3_ast_vector r = Z3_solver_cube(ctx(), m_solver, vars, cutoff);
2758  check_error();
2759  return expr_vector(ctx(), r);
2760  }
2761 
2763  solver& m_solver;
2764  unsigned& m_cutoff;
2765  expr_vector& m_vars;
2766  expr_vector m_cube;
2767  bool m_end;
2768  bool m_empty;
2769 
2770  void inc() {
2771  assert(!m_end && !m_empty);
2772  m_cube = m_solver.cube(m_vars, m_cutoff);
2773  m_cutoff = 0xFFFFFFFF;
2774  if (m_cube.size() == 1 && m_cube[0U].is_false()) {
2775  m_cube = z3::expr_vector(m_solver.ctx());
2776  m_end = true;
2777  }
2778  else if (m_cube.empty()) {
2779  m_empty = true;
2780  }
2781  }
2782  public:
2783  cube_iterator(solver& s, expr_vector& vars, unsigned& cutoff, bool end):
2784  m_solver(s),
2785  m_cutoff(cutoff),
2786  m_vars(vars),
2787  m_cube(s.ctx()),
2788  m_end(end),
2789  m_empty(false) {
2790  if (!m_end) {
2791  inc();
2792  }
2793  }
2794 
2796  assert(!m_end);
2797  if (m_empty) {
2798  m_end = true;
2799  }
2800  else {
2801  inc();
2802  }
2803  return *this;
2804  }
2805  cube_iterator operator++(int) { assert(false); return *this; }
2806  expr_vector const * operator->() const { return &(operator*()); }
2807  expr_vector const& operator*() const noexcept { return m_cube; }
2808 
2809  bool operator==(cube_iterator const& other) noexcept {
2810  return other.m_end == m_end;
2811  };
2812  bool operator!=(cube_iterator const& other) noexcept {
2813  return other.m_end != m_end;
2814  };
2815 
2816  };
2817 
2819  solver& m_solver;
2820  unsigned m_cutoff;
2821  expr_vector m_default_vars;
2822  expr_vector& m_vars;
2823  public:
2825  m_solver(s),
2826  m_cutoff(0xFFFFFFFF),
2827  m_default_vars(s.ctx()),
2828  m_vars(m_default_vars)
2829  {}
2830 
2832  m_solver(s),
2833  m_cutoff(0xFFFFFFFF),
2834  m_default_vars(s.ctx()),
2835  m_vars(vars)
2836  {}
2837 
2838  cube_iterator begin() { return cube_iterator(m_solver, m_vars, m_cutoff, false); }
2839  cube_iterator end() { return cube_iterator(m_solver, m_vars, m_cutoff, true); }
2840  void set_cutoff(unsigned c) noexcept { m_cutoff = c; }
2841  };
2842 
2843  cube_generator cubes() { return cube_generator(*this); }
2844  cube_generator cubes(expr_vector& vars) { return cube_generator(*this, vars); }
2845 
2846  };
2847  inline std::ostream & operator<<(std::ostream & out, solver const & s) { out << Z3_solver_to_string(s.ctx(), s); return out; }
2848 
2849  class goal : public object {
2850  Z3_goal m_goal;
2851  void init(Z3_goal s) {
2852  m_goal = s;
2853  Z3_goal_inc_ref(ctx(), s);
2854  }
2855  public:
2856  goal(context & c, bool models=true, bool unsat_cores=false, bool proofs=false):object(c) { init(Z3_mk_goal(c, models, unsat_cores, proofs)); }
2857  goal(context & c, Z3_goal s):object(c) { init(s); }
2858  goal(goal const & s):object(s) { init(s.m_goal); }
2859  ~goal() { Z3_goal_dec_ref(ctx(), m_goal); }
2860  operator Z3_goal() const { return m_goal; }
2861  goal & operator=(goal const & s) {
2862  Z3_goal_inc_ref(s.ctx(), s.m_goal);
2863  Z3_goal_dec_ref(ctx(), m_goal);
2864  object::operator=(s);
2865  m_goal = s.m_goal;
2866  return *this;
2867  }
2868  void add(expr const & f) { check_context(*this, f); Z3_goal_assert(ctx(), m_goal, f); check_error(); }
2869  void add(expr_vector const& v) { check_context(*this, v); for (unsigned i = 0; i < v.size(); ++i) add(v[i]); }
2870  unsigned size() const { return Z3_goal_size(ctx(), m_goal); }
2871  expr operator[](int i) const { assert(0 <= i); Z3_ast r = Z3_goal_formula(ctx(), m_goal, i); check_error(); return expr(ctx(), r); }
2872  Z3_goal_prec precision() const { return Z3_goal_precision(ctx(), m_goal); }
2873  bool inconsistent() const { return Z3_goal_inconsistent(ctx(), m_goal); }
2874  unsigned depth() const { return Z3_goal_depth(ctx(), m_goal); }
2875  void reset() { Z3_goal_reset(ctx(), m_goal); }
2876  unsigned num_exprs() const { return Z3_goal_num_exprs(ctx(), m_goal); }
2877  bool is_decided_sat() const { return Z3_goal_is_decided_sat(ctx(), m_goal); }
2878  bool is_decided_unsat() const { return Z3_goal_is_decided_unsat(ctx(), m_goal); }
2879  model convert_model(model const & m) const {
2880  check_context(*this, m);
2881  Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, m);
2882  check_error();
2883  return model(ctx(), new_m);
2884  }
2885  model get_model() const {
2886  Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, 0);
2887  check_error();
2888  return model(ctx(), new_m);
2889  }
2890  expr as_expr() const {
2891  unsigned n = size();
2892  if (n == 0)
2893  return ctx().bool_val(true);
2894  else if (n == 1)
2895  return operator[](0);
2896  else {
2897  array<Z3_ast> args(n);
2898  for (unsigned i = 0; i < n; i++)
2899  args[i] = operator[](i);
2900  return expr(ctx(), Z3_mk_and(ctx(), n, args.ptr()));
2901  }
2902  }
2903  std::string dimacs(bool include_names = true) const { return std::string(Z3_goal_to_dimacs_string(ctx(), m_goal, include_names)); }
2904  friend std::ostream & operator<<(std::ostream & out, goal const & g);
2905  };
2906  inline std::ostream & operator<<(std::ostream & out, goal const & g) { out << Z3_goal_to_string(g.ctx(), g); return out; }
2907 
2908  class apply_result : public object {
2909  Z3_apply_result m_apply_result;
2910  void init(Z3_apply_result s) {
2911  m_apply_result = s;
2913  }
2914  public:
2915  apply_result(context & c, Z3_apply_result s):object(c) { init(s); }
2916  apply_result(apply_result const & s):object(s) { init(s.m_apply_result); }
2917  ~apply_result() { Z3_apply_result_dec_ref(ctx(), m_apply_result); }
2918  operator Z3_apply_result() const { return m_apply_result; }
2920  Z3_apply_result_inc_ref(s.ctx(), s.m_apply_result);
2921  Z3_apply_result_dec_ref(ctx(), m_apply_result);
2922  object::operator=(s);
2923  m_apply_result = s.m_apply_result;
2924  return *this;
2925  }
2926  unsigned size() const { return Z3_apply_result_get_num_subgoals(ctx(), m_apply_result); }
2927  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); }
2928  friend std::ostream & operator<<(std::ostream & out, apply_result const & r);
2929  };
2930  inline std::ostream & operator<<(std::ostream & out, apply_result const & r) { out << Z3_apply_result_to_string(r.ctx(), r); return out; }
2931 
2932  class tactic : public object {
2933  Z3_tactic m_tactic;
2934  void init(Z3_tactic s) {
2935  m_tactic = s;
2936  Z3_tactic_inc_ref(ctx(), s);
2937  }
2938  public:
2939  tactic(context & c, char const * name):object(c) { Z3_tactic r = Z3_mk_tactic(c, name); check_error(); init(r); }
2940  tactic(context & c, Z3_tactic s):object(c) { init(s); }
2941  tactic(tactic const & s):object(s) { init(s.m_tactic); }
2942  ~tactic() { Z3_tactic_dec_ref(ctx(), m_tactic); }
2943  operator Z3_tactic() const { return m_tactic; }
2944  tactic & operator=(tactic const & s) {
2945  Z3_tactic_inc_ref(s.ctx(), s.m_tactic);
2946  Z3_tactic_dec_ref(ctx(), m_tactic);
2947  object::operator=(s);
2948  m_tactic = s.m_tactic;
2949  return *this;
2950  }
2951  solver mk_solver() const { Z3_solver r = Z3_mk_solver_from_tactic(ctx(), m_tactic); check_error(); return solver(ctx(), r); }
2952  apply_result apply(goal const & g) const {
2953  check_context(*this, g);
2954  Z3_apply_result r = Z3_tactic_apply(ctx(), m_tactic, g);
2955  check_error();
2956  return apply_result(ctx(), r);
2957  }
2958  apply_result operator()(goal const & g) const {
2959  return apply(g);
2960  }
2961  std::string help() const { char const * r = Z3_tactic_get_help(ctx(), m_tactic); check_error(); return r; }
2962  friend tactic operator&(tactic const & t1, tactic const & t2);
2963  friend tactic operator|(tactic const & t1, tactic const & t2);
2964  friend tactic repeat(tactic const & t, unsigned max);
2965  friend tactic with(tactic const & t, params const & p);
2966  friend tactic try_for(tactic const & t, unsigned ms);
2967  friend tactic par_or(unsigned n, tactic const* tactics);
2968  friend tactic par_and_then(tactic const& t1, tactic const& t2);
2970  };
2971 
2972  inline tactic operator&(tactic const & t1, tactic const & t2) {
2973  check_context(t1, t2);
2974  Z3_tactic r = Z3_tactic_and_then(t1.ctx(), t1, t2);
2975  t1.check_error();
2976  return tactic(t1.ctx(), r);
2977  }
2978 
2979  inline tactic operator|(tactic const & t1, tactic const & t2) {
2980  check_context(t1, t2);
2981  Z3_tactic r = Z3_tactic_or_else(t1.ctx(), t1, t2);
2982  t1.check_error();
2983  return tactic(t1.ctx(), r);
2984  }
2985 
2986  inline tactic repeat(tactic const & t, unsigned max=UINT_MAX) {
2987  Z3_tactic r = Z3_tactic_repeat(t.ctx(), t, max);
2988  t.check_error();
2989  return tactic(t.ctx(), r);
2990  }
2991 
2992  inline tactic with(tactic const & t, params const & p) {
2993  Z3_tactic r = Z3_tactic_using_params(t.ctx(), t, p);
2994  t.check_error();
2995  return tactic(t.ctx(), r);
2996  }
2997  inline tactic try_for(tactic const & t, unsigned ms) {
2998  Z3_tactic r = Z3_tactic_try_for(t.ctx(), t, ms);
2999  t.check_error();
3000  return tactic(t.ctx(), r);
3001  }
3002  inline tactic par_or(unsigned n, tactic const* tactics) {
3003  if (n == 0) {
3004  Z3_THROW(exception("a non-zero number of tactics need to be passed to par_or"));
3005  }
3006  array<Z3_tactic> buffer(n);
3007  for (unsigned i = 0; i < n; ++i) buffer[i] = tactics[i];
3008  return tactic(tactics[0].ctx(), Z3_tactic_par_or(tactics[0].ctx(), n, buffer.ptr()));
3009  }
3010 
3011  inline tactic par_and_then(tactic const & t1, tactic const & t2) {
3012  check_context(t1, t2);
3013  Z3_tactic r = Z3_tactic_par_and_then(t1.ctx(), t1, t2);
3014  t1.check_error();
3015  return tactic(t1.ctx(), r);
3016  }
3017 
3018  class probe : public object {
3019  Z3_probe m_probe;
3020  void init(Z3_probe s) {
3021  m_probe = s;
3022  Z3_probe_inc_ref(ctx(), s);
3023  }
3024  public:
3025  probe(context & c, char const * name):object(c) { Z3_probe r = Z3_mk_probe(c, name); check_error(); init(r); }
3026  probe(context & c, double val):object(c) { Z3_probe r = Z3_probe_const(c, val); check_error(); init(r); }
3027  probe(context & c, Z3_probe s):object(c) { init(s); }
3028  probe(probe const & s):object(s) { init(s.m_probe); }
3029  ~probe() { Z3_probe_dec_ref(ctx(), m_probe); }
3030  operator Z3_probe() const { return m_probe; }
3031  probe & operator=(probe const & s) {
3032  Z3_probe_inc_ref(s.ctx(), s.m_probe);
3033  Z3_probe_dec_ref(ctx(), m_probe);
3034  object::operator=(s);
3035  m_probe = s.m_probe;
3036  return *this;
3037  }
3038  double apply(goal const & g) const { double r = Z3_probe_apply(ctx(), m_probe, g); check_error(); return r; }
3039  double operator()(goal const & g) const { return apply(g); }
3040  friend probe operator<=(probe const & p1, probe const & p2);
3041  friend probe operator<=(probe const & p1, double p2);
3042  friend probe operator<=(double p1, probe const & p2);
3043  friend probe operator>=(probe const & p1, probe const & p2);
3044  friend probe operator>=(probe const & p1, double p2);
3045  friend probe operator>=(double p1, probe const & p2);
3046  friend probe operator<(probe const & p1, probe const & p2);
3047  friend probe operator<(probe const & p1, double p2);
3048  friend probe operator<(double p1, probe const & p2);
3049  friend probe operator>(probe const & p1, probe const & p2);
3050  friend probe operator>(probe const & p1, double p2);
3051  friend probe operator>(double p1, probe const & p2);
3052  friend probe operator==(probe const & p1, probe const & p2);
3053  friend probe operator==(probe const & p1, double p2);
3054  friend probe operator==(double p1, probe const & p2);
3055  friend probe operator&&(probe const & p1, probe const & p2);
3056  friend probe operator||(probe const & p1, probe const & p2);
3057  friend probe operator!(probe const & p);
3058  };
3059 
3060  inline probe operator<=(probe const & p1, probe const & p2) {
3061  check_context(p1, p2); Z3_probe r = Z3_probe_le(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3062  }
3063  inline probe operator<=(probe const & p1, double p2) { return p1 <= probe(p1.ctx(), p2); }
3064  inline probe operator<=(double p1, probe const & p2) { return probe(p2.ctx(), p1) <= p2; }
3065  inline probe operator>=(probe const & p1, probe const & p2) {
3066  check_context(p1, p2); Z3_probe r = Z3_probe_ge(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3067  }
3068  inline probe operator>=(probe const & p1, double p2) { return p1 >= probe(p1.ctx(), p2); }
3069  inline probe operator>=(double p1, probe const & p2) { return probe(p2.ctx(), p1) >= p2; }
3070  inline probe operator<(probe const & p1, probe const & p2) {
3071  check_context(p1, p2); Z3_probe r = Z3_probe_lt(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3072  }
3073  inline probe operator<(probe const & p1, double p2) { return p1 < probe(p1.ctx(), p2); }
3074  inline probe operator<(double p1, probe const & p2) { return probe(p2.ctx(), p1) < p2; }
3075  inline probe operator>(probe const & p1, probe const & p2) {
3076  check_context(p1, p2); Z3_probe r = Z3_probe_gt(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3077  }
3078  inline probe operator>(probe const & p1, double p2) { return p1 > probe(p1.ctx(), p2); }
3079  inline probe operator>(double p1, probe const & p2) { return probe(p2.ctx(), p1) > p2; }
3080  inline probe operator==(probe const & p1, probe const & p2) {
3081  check_context(p1, p2); Z3_probe r = Z3_probe_eq(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3082  }
3083  inline probe operator==(probe const & p1, double p2) { return p1 == probe(p1.ctx(), p2); }
3084  inline probe operator==(double p1, probe const & p2) { return probe(p2.ctx(), p1) == p2; }
3085  inline probe operator&&(probe const & p1, probe const & p2) {
3086  check_context(p1, p2); Z3_probe r = Z3_probe_and(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3087  }
3088  inline probe operator||(probe const & p1, probe const & p2) {
3089  check_context(p1, p2); Z3_probe r = Z3_probe_or(p1.ctx(), p1, p2); p1.check_error(); return probe(p1.ctx(), r);
3090  }
3091  inline probe operator!(probe const & p) {
3092  Z3_probe r = Z3_probe_not(p.ctx(), p); p.check_error(); return probe(p.ctx(), r);
3093  }
3094 
3095  class optimize : public object {
3096  Z3_optimize m_opt;
3097 
3098  public:
3099  class handle final {
3100  unsigned m_h;
3101  public:
3102  handle(unsigned h): m_h(h) {}
3103  unsigned h() const { return m_h; }
3104  };
3105  optimize(context& c):object(c) { m_opt = Z3_mk_optimize(c); Z3_optimize_inc_ref(c, m_opt); }
3106  optimize(optimize const & o):object(o), m_opt(o.m_opt) {
3107  Z3_optimize_inc_ref(o.ctx(), o.m_opt);
3108  }
3110  m_opt = Z3_mk_optimize(c);
3111  Z3_optimize_inc_ref(c, m_opt);
3112  add(expr_vector(c, src.assertions()));
3113  expr_vector v(c, src.objectives());
3114  for (expr_vector::iterator it = v.begin(); it != v.end(); ++it) minimize(*it);
3115  }
3117  Z3_optimize_inc_ref(o.ctx(), o.m_opt);
3118  Z3_optimize_dec_ref(ctx(), m_opt);
3119  m_opt = o.m_opt;
3120  object::operator=(o);
3121  return *this;
3122  }
3124  operator Z3_optimize() const { return m_opt; }
3125  void add(expr const& e) {
3126  assert(e.is_bool());
3127  Z3_optimize_assert(ctx(), m_opt, e);
3128  }
3129  void add(expr_vector const& es) {
3130  for (expr_vector::iterator it = es.begin(); it != es.end(); ++it) add(*it);
3131  }
3132  void add(expr const& e, expr const& t) {
3133  assert(e.is_bool());
3134  Z3_optimize_assert_and_track(ctx(), m_opt, e, t);
3135  }
3136  void add(expr const& e, char const* p) {
3137  assert(e.is_bool());
3138  add(e, ctx().bool_const(p));
3139  }
3140  handle add_soft(expr const& e, unsigned weight) {
3141  assert(e.is_bool());
3142  auto str = std::to_string(weight);
3143  return handle(Z3_optimize_assert_soft(ctx(), m_opt, e, str.c_str(), 0));
3144  }
3145  handle add_soft(expr const& e, char const* weight) {
3146  assert(e.is_bool());
3147  return handle(Z3_optimize_assert_soft(ctx(), m_opt, e, weight, 0));
3148  }
3149  handle add(expr const& e, unsigned weight) {
3150  return add_soft(e, weight);
3151  }
3152  handle maximize(expr const& e) {
3153  return handle(Z3_optimize_maximize(ctx(), m_opt, e));
3154  }
3155  handle minimize(expr const& e) {
3156  return handle(Z3_optimize_minimize(ctx(), m_opt, e));
3157  }
3158  void push() {
3159  Z3_optimize_push(ctx(), m_opt);
3160  }
3161  void pop() {
3162  Z3_optimize_pop(ctx(), m_opt);
3163  }
3166  unsigned n = asms.size();
3167  array<Z3_ast> _asms(n);
3168  for (unsigned i = 0; i < n; i++) {
3169  check_context(*this, asms[i]);
3170  _asms[i] = asms[i];
3171  }
3172  Z3_lbool r = Z3_optimize_check(ctx(), m_opt, n, _asms.ptr());
3173  check_error();
3174  return to_check_result(r);
3175  }
3176  model get_model() const { Z3_model m = Z3_optimize_get_model(ctx(), m_opt); check_error(); return model(ctx(), m); }
3177  expr_vector unsat_core() const { Z3_ast_vector r = Z3_optimize_get_unsat_core(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3178  void set(params const & p) { Z3_optimize_set_params(ctx(), m_opt, p); check_error(); }
3179  expr lower(handle const& h) {
3180  Z3_ast r = Z3_optimize_get_lower(ctx(), m_opt, h.h());
3181  check_error();
3182  return expr(ctx(), r);
3183  }
3184  expr upper(handle const& h) {
3185  Z3_ast r = Z3_optimize_get_upper(ctx(), m_opt, h.h());
3186  check_error();
3187  return expr(ctx(), r);
3188  }
3189  expr_vector assertions() const { Z3_ast_vector r = Z3_optimize_get_assertions(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3190  expr_vector objectives() const { Z3_ast_vector r = Z3_optimize_get_objectives(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); }
3191  stats statistics() const { Z3_stats r = Z3_optimize_get_statistics(ctx(), m_opt); check_error(); return stats(ctx(), r); }
3192  friend std::ostream & operator<<(std::ostream & out, optimize const & s);
3193  void from_file(char const* filename) { Z3_optimize_from_file(ctx(), m_opt, filename); check_error(); }
3194  void from_string(char const* constraints) { Z3_optimize_from_string(ctx(), m_opt, constraints); check_error(); }
3195  std::string help() const { char const * r = Z3_optimize_get_help(ctx(), m_opt); check_error(); return r; }
3196  };
3197  inline std::ostream & operator<<(std::ostream & out, optimize const & s) { out << Z3_optimize_to_string(s.ctx(), s.m_opt); return out; }
3198 
3199  class fixedpoint : public object {
3200  Z3_fixedpoint m_fp;
3201  public:
3203  fixedpoint(fixedpoint const & o):object(o), m_fp(o.m_fp) { Z3_fixedpoint_inc_ref(ctx(), m_fp); }
3206  Z3_fixedpoint_inc_ref(o.ctx(), o.m_fp);
3207  Z3_fixedpoint_dec_ref(ctx(), m_fp);
3208  m_fp = o.m_fp;
3209  object::operator=(o);
3210  return *this;
3211  }
3212  operator Z3_fixedpoint() const { return m_fp; }
3213  expr_vector from_string(char const* s) {
3214  Z3_ast_vector r = Z3_fixedpoint_from_string(ctx(), m_fp, s);
3215  check_error();
3216  return expr_vector(ctx(), r);
3217  }
3218  expr_vector from_file(char const* s) {
3219  Z3_ast_vector r = Z3_fixedpoint_from_file(ctx(), m_fp, s);
3220  check_error();
3221  return expr_vector(ctx(), r);
3222  }
3223  void add_rule(expr& rule, symbol const& name) { Z3_fixedpoint_add_rule(ctx(), m_fp, rule, name); check_error(); }
3224  void add_fact(func_decl& f, unsigned * args) { Z3_fixedpoint_add_fact(ctx(), m_fp, f, f.arity(), args); check_error(); }
3227  array<Z3_func_decl> rs(relations);
3228  Z3_lbool r = Z3_fixedpoint_query_relations(ctx(), m_fp, rs.size(), rs.ptr());
3229  check_error();
3230  return to_check_result(r);
3231  }
3232  expr get_answer() { Z3_ast r = Z3_fixedpoint_get_answer(ctx(), m_fp); check_error(); return expr(ctx(), r); }
3233  std::string reason_unknown() { return Z3_fixedpoint_get_reason_unknown(ctx(), m_fp); }
3234  void update_rule(expr& rule, symbol const& name) { Z3_fixedpoint_update_rule(ctx(), m_fp, rule, name); check_error(); }
3235  unsigned get_num_levels(func_decl& p) { unsigned r = Z3_fixedpoint_get_num_levels(ctx(), m_fp, p); check_error(); return r; }
3236  expr get_cover_delta(int level, func_decl& p) {
3237  Z3_ast r = Z3_fixedpoint_get_cover_delta(ctx(), m_fp, level, p);
3238  check_error();
3239  return expr(ctx(), r);
3240  }
3241  void add_cover(int level, func_decl& p, expr& property) { Z3_fixedpoint_add_cover(ctx(), m_fp, level, p, property); check_error(); }
3242  stats statistics() const { Z3_stats r = Z3_fixedpoint_get_statistics(ctx(), m_fp); check_error(); return stats(ctx(), r); }
3244  expr_vector assertions() const { Z3_ast_vector r = Z3_fixedpoint_get_assertions(ctx(), m_fp); check_error(); return expr_vector(ctx(), r); }
3245  expr_vector rules() const { Z3_ast_vector r = Z3_fixedpoint_get_rules(ctx(), m_fp); check_error(); return expr_vector(ctx(), r); }
3246  void set(params const & p) { Z3_fixedpoint_set_params(ctx(), m_fp, p); check_error(); }
3247  std::string help() const { return Z3_fixedpoint_get_help(ctx(), m_fp); }
3249  std::string to_string() { return Z3_fixedpoint_to_string(ctx(), m_fp, 0, 0); }
3250  std::string to_string(expr_vector const& queries) {
3251  array<Z3_ast> qs(queries);
3252  return Z3_fixedpoint_to_string(ctx(), m_fp, qs.size(), qs.ptr());
3253  }
3254  };
3255  inline std::ostream & operator<<(std::ostream & out, fixedpoint const & f) { return out << Z3_fixedpoint_to_string(f.ctx(), f, 0, 0); }
3256 
3257  inline tactic fail_if(probe const & p) {
3258  Z3_tactic r = Z3_tactic_fail_if(p.ctx(), p);
3259  p.check_error();
3260  return tactic(p.ctx(), r);
3261  }
3262  inline tactic when(probe const & p, tactic const & t) {
3263  check_context(p, t);
3264  Z3_tactic r = Z3_tactic_when(t.ctx(), p, t);
3265  t.check_error();
3266  return tactic(t.ctx(), r);
3267  }
3268  inline tactic cond(probe const & p, tactic const & t1, tactic const & t2) {
3269  check_context(p, t1); check_context(p, t2);
3270  Z3_tactic r = Z3_tactic_cond(t1.ctx(), p, t1, t2);
3271  t1.check_error();
3272  return tactic(t1.ctx(), r);
3273  }
3274 
3275  inline symbol context::str_symbol(char const * s) { Z3_symbol r = Z3_mk_string_symbol(m_ctx, s); check_error(); return symbol(*this, r); }
3276  inline symbol context::int_symbol(int n) { Z3_symbol r = Z3_mk_int_symbol(m_ctx, n); check_error(); return symbol(*this, r); }
3277 
3278  inline sort context::bool_sort() { Z3_sort s = Z3_mk_bool_sort(m_ctx); check_error(); return sort(*this, s); }
3279  inline sort context::int_sort() { Z3_sort s = Z3_mk_int_sort(m_ctx); check_error(); return sort(*this, s); }
3280  inline sort context::real_sort() { Z3_sort s = Z3_mk_real_sort(m_ctx); check_error(); return sort(*this, s); }
3281  inline sort context::bv_sort(unsigned sz) { Z3_sort s = Z3_mk_bv_sort(m_ctx, sz); check_error(); return sort(*this, s); }
3282  inline sort context::string_sort() { Z3_sort s = Z3_mk_string_sort(m_ctx); check_error(); return sort(*this, s); }
3283  inline sort context::char_sort() { Z3_sort s = Z3_mk_char_sort(m_ctx); check_error(); return sort(*this, s); }
3284  inline sort context::seq_sort(sort& s) { Z3_sort r = Z3_mk_seq_sort(m_ctx, s); check_error(); return sort(*this, r); }
3285  inline sort context::re_sort(sort& s) { Z3_sort r = Z3_mk_re_sort(m_ctx, s); check_error(); return sort(*this, r); }
3286  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); }
3287 
3288  template<>
3289  inline sort context::fpa_sort<16>() { return fpa_sort(5, 11); }
3290 
3291  template<>
3292  inline sort context::fpa_sort<32>() { return fpa_sort(8, 24); }
3293 
3294  template<>
3295  inline sort context::fpa_sort<64>() { return fpa_sort(11, 53); }
3296 
3297  template<>
3298  inline sort context::fpa_sort<128>() { return fpa_sort(15, 113); }
3299 
3300  inline sort context::fpa_rounding_mode_sort() { Z3_sort r = Z3_mk_fpa_rounding_mode_sort(m_ctx); check_error(); return sort(*this, r); }
3301 
3302  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); }
3304  array<Z3_sort> dom(d);
3305  Z3_sort s = Z3_mk_array_sort_n(m_ctx, dom.size(), dom.ptr(), r); check_error(); return sort(*this, s);
3306  }
3307  inline sort context::enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts) {
3308  array<Z3_symbol> _enum_names(n);
3309  for (unsigned i = 0; i < n; i++) { _enum_names[i] = Z3_mk_string_symbol(*this, enum_names[i]); }
3310  array<Z3_func_decl> _cs(n);
3311  array<Z3_func_decl> _ts(n);
3312  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3313  sort s = to_sort(*this, Z3_mk_enumeration_sort(*this, _name, n, _enum_names.ptr(), _cs.ptr(), _ts.ptr()));
3314  check_error();
3315  for (unsigned i = 0; i < n; i++) { cs.push_back(func_decl(*this, _cs[i])); ts.push_back(func_decl(*this, _ts[i])); }
3316  return s;
3317  }
3318  inline func_decl context::tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs) {
3319  array<Z3_symbol> _names(n);
3320  array<Z3_sort> _sorts(n);
3321  for (unsigned i = 0; i < n; i++) { _names[i] = Z3_mk_string_symbol(*this, names[i]); _sorts[i] = sorts[i]; }
3322  array<Z3_func_decl> _projs(n);
3323  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3324  Z3_func_decl tuple;
3325  sort _ignore_s = to_sort(*this, Z3_mk_tuple_sort(*this, _name, n, _names.ptr(), _sorts.ptr(), &tuple, _projs.ptr()));
3326  check_error();
3327  for (unsigned i = 0; i < n; i++) { projs.push_back(func_decl(*this, _projs[i])); }
3328  return func_decl(*this, tuple);
3329  }
3330 
3331  inline sort context::uninterpreted_sort(char const* name) {
3332  Z3_symbol _name = Z3_mk_string_symbol(*this, name);
3333  return to_sort(*this, Z3_mk_uninterpreted_sort(*this, _name));
3334  }
3336  return to_sort(*this, Z3_mk_uninterpreted_sort(*this, name));
3337  }
3338 
3339  inline func_decl context::function(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3340  array<Z3_sort> args(arity);
3341  for (unsigned i = 0; i < arity; i++) {
3342  check_context(domain[i], range);
3343  args[i] = domain[i];
3344  }
3345  Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, arity, args.ptr(), range);
3346  check_error();
3347  return func_decl(*this, f);
3348  }
3349 
3350  inline func_decl context::function(char const * name, unsigned arity, sort const * domain, sort const & range) {
3351  return function(range.ctx().str_symbol(name), arity, domain, range);
3352  }
3353 
3354  inline func_decl context::function(symbol const& name, sort_vector const& domain, sort const& range) {
3355  array<Z3_sort> args(domain.size());
3356  for (unsigned i = 0; i < domain.size(); i++) {
3357  check_context(domain[i], range);
3358  args[i] = domain[i];
3359  }
3360  Z3_func_decl f = Z3_mk_func_decl(m_ctx, name, domain.size(), args.ptr(), range);
3361  check_error();
3362  return func_decl(*this, f);
3363  }
3364 
3365  inline func_decl context::function(char const * name, sort_vector const& domain, sort const& range) {
3366  return function(range.ctx().str_symbol(name), domain, range);
3367  }
3368 
3369 
3370  inline func_decl context::function(char const * name, sort const & domain, sort const & range) {
3371  check_context(domain, range);
3372  Z3_sort args[1] = { domain };
3373  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 1, args, range);
3374  check_error();
3375  return func_decl(*this, f);
3376  }
3377 
3378  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & range) {
3380  Z3_sort args[2] = { d1, d2 };
3381  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 2, args, range);
3382  check_error();
3383  return func_decl(*this, f);
3384  }
3385 
3386  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range) {
3388  Z3_sort args[3] = { d1, d2, d3 };
3389  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 3, args, range);
3390  check_error();
3391  return func_decl(*this, f);
3392  }
3393 
3394  inline func_decl context::function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range) {
3396  Z3_sort args[4] = { d1, d2, d3, d4 };
3397  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 4, args, range);
3398  check_error();
3399  return func_decl(*this, f);
3400  }
3401 
3402  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) {
3404  Z3_sort args[5] = { d1, d2, d3, d4, d5 };
3405  Z3_func_decl f = Z3_mk_func_decl(m_ctx, str_symbol(name), 5, args, range);
3406  check_error();
3407  return func_decl(*this, f);
3408  }
3409 
3410  inline func_decl context::recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3411  array<Z3_sort> args(arity);
3412  for (unsigned i = 0; i < arity; i++) {
3413  check_context(domain[i], range);
3414  args[i] = domain[i];
3415  }
3416  Z3_func_decl f = Z3_mk_rec_func_decl(m_ctx, name, arity, args.ptr(), range);
3417  check_error();
3418  return func_decl(*this, f);
3419 
3420  }
3421 
3422  inline func_decl context::recfun(char const * name, unsigned arity, sort const * domain, sort const & range) {
3423  return recfun(str_symbol(name), arity, domain, range);
3424  }
3425 
3426  inline func_decl context::recfun(char const * name, sort const& d1, sort const & range) {
3427  return recfun(str_symbol(name), 1, &d1, range);
3428  }
3429 
3430  inline func_decl context::recfun(char const * name, sort const& d1, sort const& d2, sort const & range) {
3431  sort dom[2] = { d1, d2 };
3432  return recfun(str_symbol(name), 2, dom, range);
3433  }
3434 
3435  inline void context::recdef(func_decl f, expr_vector const& args, expr const& body) {
3436  check_context(f, args); check_context(f, body);
3437  array<Z3_ast> vars(args);
3438  Z3_add_rec_def(f.ctx(), f, vars.size(), vars.ptr(), body);
3439  }
3440 
3441  inline func_decl context::user_propagate_function(symbol const& name, sort_vector const& domain, sort const& range) {
3442  check_context(domain, range);
3443  array<Z3_sort> domain1(domain);
3444  Z3_func_decl f = Z3_solver_propagate_declare(range.ctx(), name, domain1.size(), domain1.ptr(), range);
3445  check_error();
3446  return func_decl(*this, f);
3447  }
3448 
3449  inline expr context::constant(symbol const & name, sort const & s) {
3450  Z3_ast r = Z3_mk_const(m_ctx, name, s);
3451  check_error();
3452  return expr(*this, r);
3453  }
3454  inline expr context::constant(char const * name, sort const & s) { return constant(str_symbol(name), s); }
3455  inline expr context::bool_const(char const * name) { return constant(name, bool_sort()); }
3456  inline expr context::int_const(char const * name) { return constant(name, int_sort()); }
3457  inline expr context::real_const(char const * name) { return constant(name, real_sort()); }
3458  inline expr context::string_const(char const * name) { return constant(name, string_sort()); }
3459  inline expr context::bv_const(char const * name, unsigned sz) { return constant(name, bv_sort(sz)); }
3460  inline expr context::fpa_const(char const * name, unsigned ebits, unsigned sbits) { return constant(name, fpa_sort(ebits, sbits)); }
3461 
3462  template<size_t precision>
3463  inline expr context::fpa_const(char const * name) { return constant(name, fpa_sort<precision>()); }
3464 
3465  inline void context::set_rounding_mode(rounding_mode rm) { m_rounding_mode = rm; }
3466 
3468  switch (m_rounding_mode) {
3469  case RNA: return expr(*this, Z3_mk_fpa_rna(m_ctx));
3470  case RNE: return expr(*this, Z3_mk_fpa_rne(m_ctx));
3471  case RTP: return expr(*this, Z3_mk_fpa_rtp(m_ctx));
3472  case RTN: return expr(*this, Z3_mk_fpa_rtn(m_ctx));
3473  case RTZ: return expr(*this, Z3_mk_fpa_rtz(m_ctx));
3474  default: return expr(*this);
3475  }
3476  }
3477 
3478  inline expr context::bool_val(bool b) { return b ? expr(*this, Z3_mk_true(m_ctx)) : expr(*this, Z3_mk_false(m_ctx)); }
3479 
3480  inline expr context::int_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, int_sort()); check_error(); return expr(*this, r); }
3481  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); }
3482  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); }
3483  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); }
3484  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); }
3485 
3486  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); }
3487  inline expr context::real_val(int n) { Z3_ast r = Z3_mk_int(m_ctx, n, real_sort()); check_error(); return expr(*this, r); }
3488  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); }
3489  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); }
3490  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); }
3491  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); }
3492 
3493  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); }
3494  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); }
3495  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); }
3496  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); }
3497  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); }
3498  inline expr context::bv_val(unsigned n, bool const* bits) {
3499  array<bool> _bits(n);
3500  for (unsigned i = 0; i < n; ++i) _bits[i] = bits[i] ? 1 : 0;
3501  Z3_ast r = Z3_mk_bv_numeral(m_ctx, n, _bits.ptr()); check_error(); return expr(*this, r);
3502  }
3503 
3504  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); }
3505  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); }
3506  inline expr context::fpa_nan(sort const & s) { Z3_ast r = Z3_mk_fpa_nan(m_ctx, s); check_error(); return expr(*this, r); }
3507  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); }
3508 
3509  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); }
3510  inline expr context::string_val(char const* s) { Z3_ast r = Z3_mk_string(m_ctx, s); check_error(); return expr(*this, r); }
3511  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); }
3512  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); }
3513 
3514  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); }
3515 
3516  inline expr func_decl::operator()(unsigned n, expr const * args) const {
3517  array<Z3_ast> _args(n);
3518  for (unsigned i = 0; i < n; i++) {
3519  check_context(*this, args[i]);
3520  _args[i] = args[i];
3521  }
3522  Z3_ast r = Z3_mk_app(ctx(), *this, n, _args.ptr());
3523  check_error();
3524  return expr(ctx(), r);
3525 
3526  }
3527  inline expr func_decl::operator()(expr_vector const& args) const {
3528  array<Z3_ast> _args(args.size());
3529  for (unsigned i = 0; i < args.size(); i++) {
3530  check_context(*this, args[i]);
3531  _args[i] = args[i];
3532  }
3533  Z3_ast r = Z3_mk_app(ctx(), *this, args.size(), _args.ptr());
3534  check_error();
3535  return expr(ctx(), r);
3536  }
3537  inline expr func_decl::operator()() const {
3538  Z3_ast r = Z3_mk_app(ctx(), *this, 0, 0);
3539  ctx().check_error();
3540  return expr(ctx(), r);
3541  }
3542  inline expr func_decl::operator()(expr const & a) const {
3543  check_context(*this, a);
3544  Z3_ast args[1] = { a };
3545  Z3_ast r = Z3_mk_app(ctx(), *this, 1, args);
3546  ctx().check_error();
3547  return expr(ctx(), r);
3548  }
3549  inline expr func_decl::operator()(int a) const {
3550  Z3_ast args[1] = { ctx().num_val(a, domain(0)) };
3551  Z3_ast r = Z3_mk_app(ctx(), *this, 1, args);
3552  ctx().check_error();
3553  return expr(ctx(), r);
3554  }
3555  inline expr func_decl::operator()(expr const & a1, expr const & a2) const {
3556  check_context(*this, a1); check_context(*this, a2);
3557  Z3_ast args[2] = { a1, a2 };
3558  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3559  ctx().check_error();
3560  return expr(ctx(), r);
3561  }
3562  inline expr func_decl::operator()(expr const & a1, int a2) const {
3563  check_context(*this, a1);
3564  Z3_ast args[2] = { a1, ctx().num_val(a2, domain(1)) };
3565  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3566  ctx().check_error();
3567  return expr(ctx(), r);
3568  }
3569  inline expr func_decl::operator()(int a1, expr const & a2) const {
3570  check_context(*this, a2);
3571  Z3_ast args[2] = { ctx().num_val(a1, domain(0)), a2 };
3572  Z3_ast r = Z3_mk_app(ctx(), *this, 2, args);
3573  ctx().check_error();
3574  return expr(ctx(), r);
3575  }
3576  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3) const {
3577  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3);
3578  Z3_ast args[3] = { a1, a2, a3 };
3579  Z3_ast r = Z3_mk_app(ctx(), *this, 3, args);
3580  ctx().check_error();
3581  return expr(ctx(), r);
3582  }
3583  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4) const {
3584  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3); check_context(*this, a4);
3585  Z3_ast args[4] = { a1, a2, a3, a4 };
3586  Z3_ast r = Z3_mk_app(ctx(), *this, 4, args);
3587  ctx().check_error();
3588  return expr(ctx(), r);
3589  }
3590  inline expr func_decl::operator()(expr const & a1, expr const & a2, expr const & a3, expr const & a4, expr const & a5) const {
3591  check_context(*this, a1); check_context(*this, a2); check_context(*this, a3); check_context(*this, a4); check_context(*this, a5);
3592  Z3_ast args[5] = { a1, a2, a3, a4, a5 };
3593  Z3_ast r = Z3_mk_app(ctx(), *this, 5, args);
3594  ctx().check_error();
3595  return expr(ctx(), r);
3596  }
3597 
3598  inline expr to_real(expr const & a) { Z3_ast r = Z3_mk_int2real(a.ctx(), a); a.check_error(); return expr(a.ctx(), r); }
3599 
3600  inline func_decl function(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3601  return range.ctx().function(name, arity, domain, range);
3602  }
3603  inline func_decl function(char const * name, unsigned arity, sort const * domain, sort const & range) {
3604  return range.ctx().function(name, arity, domain, range);
3605  }
3606  inline func_decl function(char const * name, sort const & domain, sort const & range) {
3607  return range.ctx().function(name, domain, range);
3608  }
3609  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & range) {
3610  return range.ctx().function(name, d1, d2, range);
3611  }
3612  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & range) {
3613  return range.ctx().function(name, d1, d2, d3, range);
3614  }
3615  inline func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range) {
3616  return range.ctx().function(name, d1, d2, d3, d4, range);
3617  }
3618  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) {
3619  return range.ctx().function(name, d1, d2, d3, d4, d5, range);
3620  }
3621  inline func_decl function(char const* name, sort_vector const& domain, sort const& range) {
3622  return range.ctx().function(name, domain, range);
3623  }
3624  inline func_decl function(std::string const& name, sort_vector const& domain, sort const& range) {
3625  return range.ctx().function(name.c_str(), domain, range);
3626  }
3627 
3628  inline func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) {
3629  return range.ctx().recfun(name, arity, domain, range);
3630  }
3631  inline func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range) {
3632  return range.ctx().recfun(name, arity, domain, range);
3633  }
3634  inline func_decl recfun(char const * name, sort const& d1, sort const & range) {
3635  return range.ctx().recfun(name, d1, range);
3636  }
3637  inline func_decl recfun(char const * name, sort const& d1, sort const& d2, sort const & range) {
3638  return range.ctx().recfun(name, d1, d2, range);
3639  }
3640 
3641  inline expr select(expr const & a, expr const & i) {
3642  check_context(a, i);
3643  Z3_ast r = Z3_mk_select(a.ctx(), a, i);
3644  a.check_error();
3645  return expr(a.ctx(), r);
3646  }
3647  inline expr select(expr const & a, int i) {
3648  return select(a, a.ctx().num_val(i, a.get_sort().array_domain()));
3649  }
3650  inline expr select(expr const & a, expr_vector const & i) {
3651  check_context(a, i);
3652  array<Z3_ast> idxs(i);
3653  Z3_ast r = Z3_mk_select_n(a.ctx(), a, idxs.size(), idxs.ptr());
3654  a.check_error();
3655  return expr(a.ctx(), r);
3656  }
3657 
3658  inline expr store(expr const & a, expr const & i, expr const & v) {
3659  check_context(a, i); check_context(a, v);
3660  Z3_ast r = Z3_mk_store(a.ctx(), a, i, v);
3661  a.check_error();
3662  return expr(a.ctx(), r);
3663  }
3664 
3665  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); }
3666  inline expr store(expr const & a, expr i, int v) { return store(a, i, a.ctx().num_val(v, a.get_sort().array_range())); }
3667  inline expr store(expr const & a, int i, int v) {
3668  return store(a, a.ctx().num_val(i, a.get_sort().array_domain()), a.ctx().num_val(v, a.get_sort().array_range()));
3669  }
3670  inline expr store(expr const & a, expr_vector const & i, expr const & v) {
3671  check_context(a, i); check_context(a, v);
3672  array<Z3_ast> idxs(i);
3673  Z3_ast r = Z3_mk_store_n(a.ctx(), a, idxs.size(), idxs.ptr(), v);
3674  a.check_error();
3675  return expr(a.ctx(), r);
3676  }
3677 
3678  inline expr as_array(func_decl & f) {
3679  Z3_ast r = Z3_mk_as_array(f.ctx(), f);
3680  f.check_error();
3681  return expr(f.ctx(), r);
3682  }
3683 
3684 #define MK_EXPR1(_fn, _arg) \
3685  Z3_ast r = _fn(_arg.ctx(), _arg); \
3686  _arg.check_error(); \
3687  return expr(_arg.ctx(), r);
3688 
3689 #define MK_EXPR2(_fn, _arg1, _arg2) \
3690  check_context(_arg1, _arg2); \
3691  Z3_ast r = _fn(_arg1.ctx(), _arg1, _arg2); \
3692  _arg1.check_error(); \
3693  return expr(_arg1.ctx(), r);
3694 
3695  inline expr const_array(sort const & d, expr const & v) {
3696  MK_EXPR2(Z3_mk_const_array, d, v);
3697  }
3698 
3699  inline expr empty_set(sort const& s) {
3701  }
3702 
3703  inline expr full_set(sort const& s) {
3705  }
3706 
3707  inline expr set_add(expr const& s, expr const& e) {
3708  MK_EXPR2(Z3_mk_set_add, s, e);
3709  }
3710 
3711  inline expr set_del(expr const& s, expr const& e) {
3712  MK_EXPR2(Z3_mk_set_del, s, e);
3713  }
3714 
3715  inline expr set_union(expr const& a, expr const& b) {
3716  check_context(a, b);
3717  Z3_ast es[2] = { a, b };
3718  Z3_ast r = Z3_mk_set_union(a.ctx(), 2, es);
3719  a.check_error();
3720  return expr(a.ctx(), r);
3721  }
3722 
3723  inline expr set_intersect(expr const& a, expr const& b) {
3724  check_context(a, b);
3725  Z3_ast es[2] = { a, b };
3726  Z3_ast r = Z3_mk_set_intersect(a.ctx(), 2, es);
3727  a.check_error();
3728  return expr(a.ctx(), r);
3729  }
3730 
3731  inline expr set_difference(expr const& a, expr const& b) {
3733  }
3734 
3735  inline expr set_complement(expr const& a) {
3737  }
3738 
3739  inline expr set_member(expr const& s, expr const& e) {
3740  MK_EXPR2(Z3_mk_set_member, s, e);
3741  }
3742 
3743  inline expr set_subset(expr const& a, expr const& b) {
3744  MK_EXPR2(Z3_mk_set_subset, a, b);
3745  }
3746 
3747  // sequence and regular expression operations.
3748  // union is +
3749  // concat is overloaded to handle sequences and regular expressions
3750 
3751  inline expr empty(sort const& s) {
3752  Z3_ast r = Z3_mk_seq_empty(s.ctx(), s);
3753  s.check_error();
3754  return expr(s.ctx(), r);
3755  }
3756  inline expr suffixof(expr const& a, expr const& b) {
3757  check_context(a, b);
3758  Z3_ast r = Z3_mk_seq_suffix(a.ctx(), a, b);
3759  a.check_error();
3760  return expr(a.ctx(), r);
3761  }
3762  inline expr prefixof(expr const& a, expr const& b) {
3763  check_context(a, b);
3764  Z3_ast r = Z3_mk_seq_prefix(a.ctx(), a, b);
3765  a.check_error();
3766  return expr(a.ctx(), r);
3767  }
3768  inline expr indexof(expr const& s, expr const& substr, expr const& offset) {
3769  check_context(s, substr); check_context(s, offset);
3770  Z3_ast r = Z3_mk_seq_index(s.ctx(), s, substr, offset);
3771  s.check_error();
3772  return expr(s.ctx(), r);
3773  }
3774  inline expr last_indexof(expr const& s, expr const& substr) {
3775  check_context(s, substr);
3776  Z3_ast r = Z3_mk_seq_last_index(s.ctx(), s, substr);
3777  s.check_error();
3778  return expr(s.ctx(), r);
3779  }
3780  inline expr to_re(expr const& s) {
3782  }
3783  inline expr in_re(expr const& s, expr const& re) {
3784  MK_EXPR2(Z3_mk_seq_in_re, s, re);
3785  }
3786  inline expr plus(expr const& re) {
3787  MK_EXPR1(Z3_mk_re_plus, re);
3788  }
3789  inline expr option(expr const& re) {
3791  }
3792  inline expr star(expr const& re) {
3793  MK_EXPR1(Z3_mk_re_star, re);
3794  }
3795  inline expr re_empty(sort const& s) {
3796  Z3_ast r = Z3_mk_re_empty(s.ctx(), s);
3797  s.check_error();
3798  return expr(s.ctx(), r);
3799  }
3800  inline expr re_full(sort const& s) {
3801  Z3_ast r = Z3_mk_re_full(s.ctx(), s);
3802  s.check_error();
3803  return expr(s.ctx(), r);
3804  }
3805  inline expr re_intersect(expr_vector const& args) {
3806  assert(args.size() > 0);
3807  context& ctx = args[0U].ctx();
3808  array<Z3_ast> _args(args);
3809  Z3_ast r = Z3_mk_re_intersect(ctx, _args.size(), _args.ptr());
3810  ctx.check_error();
3811  return expr(ctx, r);
3812  }
3813  inline expr re_diff(expr const& a, expr const& b) {
3814  check_context(a, b);
3815  context& ctx = a.ctx();
3816  Z3_ast r = Z3_mk_re_diff(ctx, a, b);
3817  ctx.check_error();
3818  return expr(ctx, r);
3819  }
3820  inline expr re_complement(expr const& a) {
3822  }
3823  inline expr range(expr const& lo, expr const& hi) {
3824  check_context(lo, hi);
3825  Z3_ast r = Z3_mk_re_range(lo.ctx(), lo, hi);
3826  lo.check_error();
3827  return expr(lo.ctx(), r);
3828  }
3829 
3830 
3831 
3832 
3833 
3834  inline expr_vector context::parse_string(char const* s) {
3835  Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, 0, 0, 0, 0, 0, 0);
3836  check_error();
3837  return expr_vector(*this, r);
3838 
3839  }
3840  inline expr_vector context::parse_file(char const* s) {
3841  Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, 0, 0, 0, 0, 0, 0);
3842  check_error();
3843  return expr_vector(*this, r);
3844  }
3845 
3846  inline expr_vector context::parse_string(char const* s, sort_vector const& sorts, func_decl_vector const& decls) {
3847  array<Z3_symbol> sort_names(sorts.size());
3848  array<Z3_symbol> decl_names(decls.size());
3849  array<Z3_sort> sorts1(sorts);
3850  array<Z3_func_decl> decls1(decls);
3851  for (unsigned i = 0; i < sorts.size(); ++i) {
3852  sort_names[i] = sorts[i].name();
3853  }
3854  for (unsigned i = 0; i < decls.size(); ++i) {
3855  decl_names[i] = decls[i].name();
3856  }
3857 
3858  Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
3859  check_error();
3860  return expr_vector(*this, r);
3861  }
3862 
3863  inline expr_vector context::parse_file(char const* s, sort_vector const& sorts, func_decl_vector const& decls) {
3864  array<Z3_symbol> sort_names(sorts.size());
3865  array<Z3_symbol> decl_names(decls.size());
3866  array<Z3_sort> sorts1(sorts);
3867  array<Z3_func_decl> decls1(decls);
3868  for (unsigned i = 0; i < sorts.size(); ++i) {
3869  sort_names[i] = sorts[i].name();
3870  }
3871  for (unsigned i = 0; i < decls.size(); ++i) {
3872  decl_names[i] = decls[i].name();
3873  }
3874  Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, sorts.size(), sort_names.ptr(), sorts1.ptr(), decls.size(), decl_names.ptr(), decls1.ptr());
3875  check_error();
3876  return expr_vector(*this, r);
3877  }
3878 
3880  assert(is_datatype());
3881  func_decl_vector cs(ctx());
3882  unsigned n = Z3_get_datatype_sort_num_constructors(ctx(), *this);
3883  for (unsigned i = 0; i < n; ++i)
3885  return cs;
3886  }
3887 
3889  assert(is_datatype());
3890  func_decl_vector rs(ctx());
3891  unsigned n = Z3_get_datatype_sort_num_constructors(ctx(), *this);
3892  for (unsigned i = 0; i < n; ++i)
3894  return rs;
3895  }
3896 
3898  sort s = range();
3899  assert(s.is_datatype());
3900  unsigned n = Z3_get_datatype_sort_num_constructors(ctx(), s);
3901  unsigned idx = 0;
3902  for (; idx < n; ++idx) {
3904  if (id() == f.id())
3905  break;
3906  }
3907  assert(idx < n);
3908  n = arity();
3909  func_decl_vector as(ctx());
3910  for (unsigned i = 0; i < n; ++i)
3912  return as;
3913  }
3914 
3915 
3916  inline expr expr::substitute(expr_vector const& src, expr_vector const& dst) {
3917  assert(src.size() == dst.size());
3918  array<Z3_ast> _src(src.size());
3919  array<Z3_ast> _dst(dst.size());
3920  for (unsigned i = 0; i < src.size(); ++i) {
3921  _src[i] = src[i];
3922  _dst[i] = dst[i];
3923  }
3924  Z3_ast r = Z3_substitute(ctx(), m_ast, src.size(), _src.ptr(), _dst.ptr());
3925  check_error();
3926  return expr(ctx(), r);
3927  }
3928 
3929  inline expr expr::substitute(expr_vector const& dst) {
3930  array<Z3_ast> _dst(dst.size());
3931  for (unsigned i = 0; i < dst.size(); ++i) {
3932  _dst[i] = dst[i];
3933  }
3934  Z3_ast r = Z3_substitute_vars(ctx(), m_ast, dst.size(), _dst.ptr());
3935  check_error();
3936  return expr(ctx(), r);
3937  }
3938 
3939 
3941 
3942  typedef std::function<void(expr const&, expr const&)> fixed_eh_t;
3943  typedef std::function<void(void)> final_eh_t;
3944  typedef std::function<void(expr const&, expr const&)> eq_eh_t;
3945  typedef std::function<void(expr const&)> created_eh_t;
3946 
3947  final_eh_t m_final_eh;
3948  eq_eh_t m_eq_eh;
3949  fixed_eh_t m_fixed_eh;
3950  created_eh_t m_created_eh;
3951  solver* s;
3952  context* c;
3953  std::vector<z3::context*> subcontexts;
3954 
3955  Z3_solver_callback cb { nullptr };
3956 
3957  struct scoped_cb {
3959  scoped_cb(void* _p, Z3_solver_callback cb):p(*static_cast<user_propagator_base*>(_p)) {
3960  p.cb = cb;
3961  }
3962  ~scoped_cb() {
3963  p.cb = nullptr;
3964  }
3965  };
3966 
3967  static void push_eh(void* p) {
3968  static_cast<user_propagator_base*>(p)->push();
3969  }
3970 
3971  static void pop_eh(void* p, unsigned num_scopes) {
3972  static_cast<user_propagator_base*>(p)->pop(num_scopes);
3973  }
3974 
3975  static void* fresh_eh(void* p, Z3_context ctx) {
3976  context* c = new context(ctx);
3977  static_cast<user_propagator_base*>(p)->subcontexts.push_back(c);
3978  return static_cast<user_propagator_base*>(p)->fresh(*c);
3979  }
3980 
3981  static void fixed_eh(void* _p, Z3_solver_callback cb, Z3_ast _var, Z3_ast _value) {
3982  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
3983  scoped_cb _cb(p, cb);
3984  expr value(p->ctx(), _value);
3985  expr var(p->ctx(), _var);
3986  p->m_fixed_eh(var, value);
3987  }
3988 
3989  static void eq_eh(void* _p, Z3_solver_callback cb, Z3_ast _x, Z3_ast _y) {
3990  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
3991  scoped_cb _cb(p, cb);
3992  expr x(p->ctx(), _x), y(p->ctx(), _y);
3993  p->m_eq_eh(x, y);
3994  }
3995 
3996  static void final_eh(void* p, Z3_solver_callback cb) {
3997  scoped_cb _cb(p, cb);
3998  static_cast<user_propagator_base*>(p)->m_final_eh();
3999  }
4000 
4001  static void created_eh(void* _p, Z3_solver_callback cb, Z3_ast _e) {
4002  user_propagator_base* p = static_cast<user_propagator_base*>(_p);
4003  scoped_cb _cb(p, cb);
4004  expr e(p->ctx(), _e);
4005  p->m_created_eh(e);
4006  }
4007 
4008 
4009  public:
4010  user_propagator_base(context& c) : s(nullptr), c(&c) {}
4011 
4012  user_propagator_base(solver* s): s(s), c(nullptr) {
4013  Z3_solver_propagate_init(ctx(), *s, this, push_eh, pop_eh, fresh_eh);
4014  }
4015 
4016  virtual void push() = 0;
4017  virtual void pop(unsigned num_scopes) = 0;
4018 
4020  for (auto& subcontext : subcontexts) {
4021  subcontext->detach(); // detach first; the subcontexts will be freed internally!
4022  delete subcontext;
4023  }
4024  }
4025 
4027  return c ? *c : s->ctx();
4028  }
4029 
4039 
4046  void register_fixed(fixed_eh_t& f) {
4047  m_fixed_eh = f;
4048  if (s) {
4049  Z3_solver_propagate_fixed(ctx(), *s, fixed_eh);
4050  }
4051  }
4052 
4054  m_fixed_eh = [this](expr const &id, expr const &e) {
4055  fixed(id, e);
4056  };
4057  if (s) {
4058  Z3_solver_propagate_fixed(ctx(), *s, fixed_eh);
4059  }
4060  }
4061 
4062  void register_eq(eq_eh_t& f) {
4063  m_eq_eh = f;
4064  if (s) {
4065  Z3_solver_propagate_eq(ctx(), *s, eq_eh);
4066  }
4067  }
4068 
4069  void register_eq() {
4070  m_eq_eh = [this](expr const& x, expr const& y) {
4071  eq(x, y);
4072  };
4073  if (s) {
4074  Z3_solver_propagate_eq(ctx(), *s, eq_eh);
4075  }
4076  }
4077 
4086  void register_final(final_eh_t& f) {
4087  m_final_eh = f;
4088  if (s) {
4089  Z3_solver_propagate_final(ctx(), *s, final_eh);
4090  }
4091  }
4092 
4094  m_final_eh = [this]() {
4095  final();
4096  };
4097  if (s) {
4098  Z3_solver_propagate_final(ctx(), *s, final_eh);
4099  }
4100  }
4101 
4102  void register_created(created_eh_t& c) {
4103  m_created_eh = c;
4104  if (s) {
4105  Z3_solver_propagate_created(ctx(), *s, created_eh);
4106  }
4107  }
4108 
4110  m_created_eh = [this](expr const& e) {
4111  created(e);
4112  };
4113  if (s) {
4114  Z3_solver_propagate_created(ctx(), *s, created_eh);
4115  }
4116  }
4117 
4118  virtual void fixed(expr const& /*id*/, expr const& /*e*/) { }
4119 
4120  virtual void eq(expr const& /*x*/, expr const& /*y*/) { }
4121 
4122  virtual void final() { }
4123 
4124  virtual void created(expr const& /*e*/) {}
4125 
4140  void add(expr const& e) {
4141  if (cb)
4143  else if (s)
4145  else
4146  assert(false);
4147  }
4148 
4149  void conflict(expr_vector const& fixed) {
4150  assert(cb);
4151  expr conseq = ctx().bool_val(false);
4152  array<Z3_ast> _fixed(fixed);
4153  Z3_solver_propagate_consequence(ctx(), cb, fixed.size(), _fixed.ptr(), 0, nullptr, nullptr, conseq);
4154  }
4155 
4156  void propagate(expr_vector const& fixed, expr const& conseq) {
4157  assert(cb);
4158  assert((Z3_context)conseq.ctx() == (Z3_context)ctx());
4159  array<Z3_ast> _fixed(fixed);
4160  Z3_solver_propagate_consequence(ctx(), cb, _fixed.size(), _fixed.ptr(), 0, nullptr, nullptr, conseq);
4161  }
4162 
4164  expr_vector const& lhs, expr_vector const& rhs,
4165  expr const& conseq) {
4166  assert(cb);
4167  assert((Z3_context)conseq.ctx() == (Z3_context)ctx());
4168  assert(lhs.size() == rhs.size());
4169  array<Z3_ast> _fixed(fixed);
4170  array<Z3_ast> _lhs(lhs);
4171  array<Z3_ast> _rhs(rhs);
4172 
4173  Z3_solver_propagate_consequence(ctx(), cb, _fixed.size(), _fixed.ptr(), lhs.size(), _lhs.ptr(), _rhs.ptr(), conseq);
4174  }
4175  };
4176 
4177 }
4178 
4181 #undef Z3_THROW
4182 
unsigned size() const
Definition: z3++.h:2926
apply_result & operator=(apply_result const &s)
Definition: z3++.h:2919
apply_result(context &c, Z3_apply_result s)
Definition: z3++.h:2915
goal operator[](int i) const
Definition: z3++.h:2927
apply_result(apply_result const &s)
Definition: z3++.h:2916
friend std::ostream & operator<<(std::ostream &out, apply_result const &r)
Definition: z3++.h:2930
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:2221
expr operator()(context &c, Z3_ast a)
Definition: z3++.h:2226
func_decl operator()(context &c, Z3_ast a)
Definition: z3++.h:2245
sort operator()(context &c, Z3_ast a)
Definition: z3++.h:2237
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:3486
symbol str_symbol(char const *s)
Create a Z3 symbol based on the given string.
Definition: z3++.h:3275
expr num_val(int n, sort const &s)
Definition: z3++.h:3514
expr fpa_rounding_mode()
Definition: z3++.h:3467
context()
Definition: z3++.h:181
expr bv_val(int n, unsigned sz)
Definition: z3++.h:3493
func_decl recfun(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3410
expr bool_val(bool b)
Definition: z3++.h:3478
expr fpa_const(char const *name, unsigned ebits, unsigned sbits)
Definition: z3++.h:3460
expr string_val(char const *s)
Definition: z3++.h:3510
sort real_sort()
Return the Real sort.
Definition: z3++.h:3280
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:3459
expr string_const(char const *name)
Definition: z3++.h:3458
sort array_sort(sort d, sort r)
Return an array sort for arrays from d to r.
Definition: z3++.h:3302
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:3282
sort re_sort(sort &seq_sort)
Return a regular expression sort over sequences seq_sort.
Definition: z3++.h:3285
sort uninterpreted_sort(char const *name)
create an uninterpreted sort with the name given by the string or symbol.
Definition: z3++.h:3331
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:3307
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:3278
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:3455
void check_parser_error() const
Definition: z3++.h:196
expr_vector parse_string(char const *s)
parsing
Definition: z3++.h:3834
sort fpa_sort()
Definition: z3++.h:3289
symbol int_symbol(int n)
Create a Z3 symbol based on the given integer.
Definition: z3++.h:3276
expr real_const(char const *name)
Definition: z3++.h:3457
expr int_const(char const *name)
Definition: z3++.h:3456
expr fpa_nan(sort const &s)
Definition: z3++.h:3506
expr fpa_val(double n)
Definition: z3++.h:3504
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:3281
expr int_val(int n)
Definition: z3++.h:3480
expr fpa_inf(sort const &s, bool sgn)
Definition: z3++.h:3507
func_decl function(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3339
sort fpa_rounding_mode_sort()
Return a RoundingMode sort.
Definition: z3++.h:3300
expr_vector parse_file(char const *file)
Definition: z3++.h:3840
expr constant(symbol const &name, sort const &s)
Definition: z3++.h:3449
sort char_sort()
Return the sort for Unicode characters.
Definition: z3++.h:3283
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:3318
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:3279
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:3465
func_decl user_propagate_function(symbol const &name, sort_vector const &domain, sort const &range)
Definition: z3++.h:3441
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:3435
sort seq_sort(sort &s)
Return a sequence sort over base sort s.
Definition: z3++.h:3284
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:1552
bool operator!=(iterator const &other) noexcept
Definition: z3++.h:1547
iterator(expr &e, unsigned i)
Definition: z3++.h:1543
bool operator==(iterator const &other) noexcept
Definition: z3++.h:1544
expr operator*() const
Definition: z3++.h:1550
iterator & operator++()
Definition: z3++.h:1551
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:1575
friend expr sbv_to_fpa(expr const &t, sort s)
Conversion of a signed bit-vector term into a floating-point.
Definition: z3++.h:1997
friend expr bvneg_no_overflow(expr const &a)
Definition: z3++.h:2190
expr loop(unsigned lo, unsigned hi)
Definition: z3++.h:1498
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:2178
expr ubvtos() const
Definition: z3++.h:1458
friend expr sum(expr_vector const &args)
Definition: z3++.h:2374
expr substitute(expr_vector const &src, expr_vector const &dst)
Apply substitution. Replace src expressions by dst.
Definition: z3++.h:3916
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:1741
friend expr fp_eq(expr const &a, expr const &b)
Definition: z3++.h:1958
friend expr concat(expr const &a, expr const &b)
Definition: z3++.h:2392
friend expr bvmul_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2196
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:2011
friend expr operator&&(expr const &a, expr const &b)
Return an expression representing a and b.
Definition: z3++.h:1619
friend expr operator!=(expr const &a, expr const &b)
Definition: z3++.h:1655
friend expr operator+(expr const &a, expr const &b)
Definition: z3++.h:1667
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:1468
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:1889
expr at(expr const &index) const
Definition: z3++.h:1431
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:1852
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:1483
friend expr bv2int(expr const &a, bool is_signed)
bit-vector and integer conversions.
Definition: z3++.h:2169
friend expr operator~(expr const &a)
Definition: z3++.h:1965
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:1887
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:1975
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:2184
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:2448
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:1697
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:1886
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:1990
friend expr bvredor(expr const &a)
Definition: z3++.h:1919
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:2170
friend expr max(expr const &a, expr const &b)
Definition: z3++.h:1904
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:1888
friend expr abs(expr const &a)
Definition: z3++.h:1931
friend expr pbge(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2342
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:2018
friend expr distinct(expr_vector const &args)
Definition: z3++.h:2383
friend expr bvmul_no_overflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2193
friend expr bvsub_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2181
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:1443
friend expr mod(expr const &a, expr const &b)
Definition: z3++.h:1579
friend expr fma(expr const &a, expr const &b, expr const &c, expr const &rm)
FloatingPoint fused multiply-add.
Definition: z3++.h:1967
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:2436
expr contains(expr const &s) const
Definition: z3++.h:1425
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:2030
expr algebraic_lower(unsigned precision) const
Definition: z3++.h:964
unsigned hi() const
Definition: z3++.h:1363
expr simplify() const
Return a simplified version of this expression.
Definition: z3++.h:1522
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:1448
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:2350
friend expr operator^(expr const &a, expr const &b)
Definition: z3++.h:1878
friend expr operator<=(expr const &a, expr const &b)
Definition: z3++.h:1805
friend expr operator>=(expr const &a, expr const &b)
Definition: z3++.h:1721
friend expr sqrt(expr const &a, expr const &rm)
Definition: z3++.h:1951
friend expr pble(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2334
friend expr operator==(expr const &a, expr const &b)
Definition: z3++.h:1644
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:1515
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:1567
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:2175
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:1526
expr loop(unsigned lo)
create a looping regular expression.
Definition: z3++.h:1493
expr sbvtos() const
Definition: z3++.h:1463
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:1925
friend expr operator&(expr const &a, expr const &b)
Definition: z3++.h:1874
friend expr operator-(expr const &a)
Definition: z3++.h:1763
friend expr bvsdiv_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2187
expr extract(expr const &offset, expr const &length) const
sequence and regular expression operations.
Definition: z3++.h:1410
bool is_eq() const
Definition: z3++.h:1245
expr unit() const
Definition: z3++.h:1420
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:1595
friend expr operator!(expr const &a)
Return an expression representing not(a).
Definition: z3++.h:1613
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:2442
expr itos() const
Definition: z3++.h:1453
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:1556
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:1414
iterator begin()
Definition: z3++.h:1555
friend expr operator||(expr const &a, expr const &b)
Return an expression representing a or b.
Definition: z3++.h:1631
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:1362
friend expr ubv_to_fpa(expr const &t, sort s)
Conversion of an unsigned bit-vector term into a floating-point.
Definition: z3++.h:2004
expr nth(expr const &index) const
Definition: z3++.h:1437
friend expr fpa_to_sbv(expr const &t, unsigned sz)
Conversion of a floating-point term into a signed bit-vector.
Definition: z3++.h:1983
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:1882
friend expr atmost(expr_vector const &es, unsigned bound)
Definition: z3++.h:2358
friend expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3823
expr char_from_bv() const
Definition: z3++.h:1478
friend expr atleast(expr_vector const &es, unsigned bound)
Definition: z3++.h:2366
friend expr operator<(expr const &a, expr const &b)
Definition: z3++.h:1830
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:1507
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:1473
std::string to_string(expr_vector const &queries)
Definition: z3++.h:3250
std::string help() const
Definition: z3++.h:3247
expr_vector from_string(char const *s)
Definition: z3++.h:3213
void add_fact(func_decl &f, unsigned *args)
Definition: z3++.h:3224
fixedpoint & operator=(fixedpoint const &o)
Definition: z3++.h:3205
void add_cover(int level, func_decl &p, expr &property)
Definition: z3++.h:3241
expr_vector rules() const
Definition: z3++.h:3245
stats statistics() const
Definition: z3++.h:3242
expr get_answer()
Definition: z3++.h:3232
expr get_cover_delta(int level, func_decl &p)
Definition: z3++.h:3236
fixedpoint(context &c)
Definition: z3++.h:3202
std::string reason_unknown()
Definition: z3++.h:3233
check_result query(func_decl_vector &relations)
Definition: z3++.h:3226
void register_relation(func_decl &p)
Definition: z3++.h:3243
std::string to_string()
Definition: z3++.h:3249
check_result query(expr &q)
Definition: z3++.h:3225
param_descrs get_param_descrs()
Definition: z3++.h:3248
expr_vector from_file(char const *s)
Definition: z3++.h:3218
void update_rule(expr &rule, symbol const &name)
Definition: z3++.h:3234
expr_vector assertions() const
Definition: z3++.h:3244
fixedpoint(fixedpoint const &o)
Definition: z3++.h:3203
unsigned get_num_levels(func_decl &p)
Definition: z3++.h:3235
void add_rule(expr &rule, symbol const &name)
Definition: z3++.h:3223
void set(params const &p)
Definition: z3++.h:3246
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:3537
bool is_const() const
Definition: z3++.h:727
func_decl_vector accessors()
Definition: z3++.h:3897
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:2458
~func_entry()
Definition: z3++.h:2467
func_entry & operator=(func_entry const &s)
Definition: z3++.h:2469
unsigned num_args() const
Definition: z3++.h:2477
expr arg(unsigned i) const
Definition: z3++.h:2478
func_entry(context &c, Z3_func_entry e)
Definition: z3++.h:2465
expr value() const
Definition: z3++.h:2476
func_entry(func_entry const &s)
Definition: z3++.h:2466
expr else_value() const
Definition: z3++.h:2499
void set_else(expr &value)
Definition: z3++.h:2506
func_interp(context &c, Z3_func_interp e)
Definition: z3++.h:2488
func_interp(func_interp const &s)
Definition: z3++.h:2489
func_interp & operator=(func_interp const &s)
Definition: z3++.h:2492
func_entry entry(unsigned i) const
Definition: z3++.h:2501
void add_entry(expr_vector const &args, expr &value)
Definition: z3++.h:2502
unsigned num_entries() const
Definition: z3++.h:2500
void add(expr const &f)
Definition: z3++.h:2868
unsigned size() const
Definition: z3++.h:2870
Z3_goal_prec precision() const
Definition: z3++.h:2872
model convert_model(model const &m) const
Definition: z3++.h:2879
bool is_decided_unsat() const
Definition: z3++.h:2878
goal(goal const &s)
Definition: z3++.h:2858
friend std::ostream & operator<<(std::ostream &out, goal const &g)
Definition: z3++.h:2906
bool inconsistent() const
Definition: z3++.h:2873
model get_model() const
Definition: z3++.h:2885
std::string dimacs(bool include_names=true) const
Definition: z3++.h:2903
unsigned num_exprs() const
Definition: z3++.h:2876
goal(context &c, Z3_goal s)
Definition: z3++.h:2857
goal & operator=(goal const &s)
Definition: z3++.h:2861
goal(context &c, bool models=true, bool unsat_cores=false, bool proofs=false)
Definition: z3++.h:2856
void add(expr_vector const &v)
Definition: z3++.h:2869
~goal()
Definition: z3++.h:2859
void reset()
Definition: z3++.h:2875
unsigned depth() const
Definition: z3++.h:2874
bool is_decided_sat() const
Definition: z3++.h:2877
expr as_expr() const
Definition: z3++.h:2890
expr operator[](int i) const
Definition: z3++.h:2871
expr eval(expr const &n, bool model_completion=false) const
Definition: z3++.h:2534
unsigned size() const
Definition: z3++.h:2548
~model()
Definition: z3++.h:2524
expr get_const_interp(func_decl c) const
Definition: z3++.h:2557
unsigned num_consts() const
Definition: z3++.h:2544
unsigned num_funcs() const
Definition: z3++.h:2545
friend std::ostream & operator<<(std::ostream &out, model const &m)
Definition: z3++.h:2592
model & operator=(model const &s)
Definition: z3++.h:2526
func_interp get_func_interp(func_decl f) const
Definition: z3++.h:2563
func_decl get_func_decl(unsigned i) const
Definition: z3++.h:2547
func_interp add_func_interp(func_decl &f, expr &else_val)
Definition: z3++.h:2577
func_decl operator[](int i) const
Definition: z3++.h:2549
model(model const &s)
Definition: z3++.h:2522
model(context &c)
Definition: z3++.h:2520
void add_const_interp(func_decl &f, expr &value)
Definition: z3++.h:2583
func_decl get_const_decl(unsigned i) const
Definition: z3++.h:2546
bool has_interp(func_decl f) const
Definition: z3++.h:2572
std::string to_string() const
Definition: z3++.h:2590
model(model &src, context &dst, translate)
Definition: z3++.h:2523
model(context &c, Z3_model m)
Definition: z3++.h:2521
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:3102
unsigned h() const
Definition: z3++.h:3103
std::string help() const
Definition: z3++.h:3195
handle add_soft(expr const &e, char const *weight)
Definition: z3++.h:3145
void add(expr const &e, expr const &t)
Definition: z3++.h:3132
expr lower(handle const &h)
Definition: z3++.h:3179
void pop()
Definition: z3++.h:3161
expr_vector objectives() const
Definition: z3++.h:3190
void add(expr_vector const &es)
Definition: z3++.h:3129
void add(expr const &e, char const *p)
Definition: z3++.h:3136
model get_model() const
Definition: z3++.h:3176
handle add(expr const &e, unsigned weight)
Definition: z3++.h:3149
check_result check()
Definition: z3++.h:3164
check_result check(expr_vector const &asms)
Definition: z3++.h:3165
stats statistics() const
Definition: z3++.h:3191
void add(expr const &e)
Definition: z3++.h:3125
friend std::ostream & operator<<(std::ostream &out, optimize const &s)
Definition: z3++.h:3197
void push()
Definition: z3++.h:3158
handle add_soft(expr const &e, unsigned weight)
Definition: z3++.h:3140
handle maximize(expr const &e)
Definition: z3++.h:3152
~optimize()
Definition: z3++.h:3123
optimize(optimize const &o)
Definition: z3++.h:3106
void from_file(char const *filename)
Definition: z3++.h:3193
expr_vector assertions() const
Definition: z3++.h:3189
void from_string(char const *constraints)
Definition: z3++.h:3194
expr upper(handle const &h)
Definition: z3++.h:3184
optimize(context &c, optimize &src)
Definition: z3++.h:3109
handle minimize(expr const &e)
Definition: z3++.h:3155
optimize & operator=(optimize const &o)
Definition: z3++.h:3116
optimize(context &c)
Definition: z3++.h:3105
void set(params const &p)
Definition: z3++.h:3178
expr_vector unsat_core() const
Definition: z3++.h:3177
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:3070
double operator()(goal const &g) const
Definition: z3++.h:3039
probe & operator=(probe const &s)
Definition: z3++.h:3031
friend probe operator==(probe const &p1, probe const &p2)
Definition: z3++.h:3080
friend probe operator<=(probe const &p1, probe const &p2)
Definition: z3++.h:3060
probe(context &c, Z3_probe s)
Definition: z3++.h:3027
probe(context &c, double val)
Definition: z3++.h:3026
probe(context &c, char const *name)
Definition: z3++.h:3025
friend probe operator&&(probe const &p1, probe const &p2)
Definition: z3++.h:3085
probe(probe const &s)
Definition: z3++.h:3028
~probe()
Definition: z3++.h:3029
friend probe operator!(probe const &p)
Definition: z3++.h:3091
double apply(goal const &g) const
Definition: z3++.h:3038
friend probe operator>=(probe const &p1, probe const &p2)
Definition: z3++.h:3065
friend probe operator>(probe const &p1, probe const &p2)
Definition: z3++.h:3075
friend probe operator||(probe const &p1, probe const &p2)
Definition: z3++.h:3088
cube_iterator end()
Definition: z3++.h:2839
cube_generator(solver &s, expr_vector &vars)
Definition: z3++.h:2831
cube_iterator begin()
Definition: z3++.h:2838
cube_generator(solver &s)
Definition: z3++.h:2824
void set_cutoff(unsigned c) noexcept
Definition: z3++.h:2840
expr_vector const & operator*() const noexcept
Definition: z3++.h:2807
cube_iterator & operator++()
Definition: z3++.h:2795
cube_iterator operator++(int)
Definition: z3++.h:2805
expr_vector const * operator->() const
Definition: z3++.h:2806
bool operator!=(cube_iterator const &other) noexcept
Definition: z3++.h:2812
cube_iterator(solver &s, expr_vector &vars, unsigned &cutoff, bool end)
Definition: z3++.h:2783
bool operator==(cube_iterator const &other) noexcept
Definition: z3++.h:2809
void from_string(char const *s)
Definition: z3++.h:2681
expr proof() const
Definition: z3++.h:2728
~solver()
Definition: z3++.h:2648
cube_generator cubes(expr_vector &vars)
Definition: z3++.h:2844
solver(context &c, solver const &src, translate)
Definition: z3++.h:2646
expr_vector non_units() const
Definition: z3++.h:2715
solver(context &c, simple)
Definition: z3++.h:2643
solver(context &c, Z3_solver s)
Definition: z3++.h:2644
solver(context &c, char const *logic)
Definition: z3++.h:2645
void set(char const *k, bool v)
Definition: z3++.h:2658
void add(expr const &e, expr const &p)
Definition: z3++.h:2667
void add(expr const &e, char const *p)
Definition: z3++.h:2672
check_result consequences(expr_vector &assumptions, expr_vector &vars, expr_vector &conseq)
Definition: z3++.h:2706
void set(char const *k, char const *v)
Definition: z3++.h:2662
check_result check(unsigned n, expr *const assumptions)
Definition: z3++.h:2684
model get_model() const
Definition: z3++.h:2705
std::string dimacs(bool include_names=true) const
Definition: z3++.h:2751
check_result check()
Definition: z3++.h:2683
stats statistics() const
Definition: z3++.h:2712
expr_vector units() const
Definition: z3++.h:2716
expr_vector trail() const
Definition: z3++.h:2717
void add(expr const &e)
Definition: z3++.h:2666
solver & operator=(solver const &s)
Definition: z3++.h:2650
friend std::ostream & operator<<(std::ostream &out, solver const &s)
Definition: z3++.h:2847
void set(char const *k, double v)
Definition: z3++.h:2660
void pop(unsigned n=1)
Definition: z3++.h:2664
void push()
Definition: z3++.h:2663
std::string to_smt2(char const *status="unknown")
Definition: z3++.h:2731
solver(context &c)
Definition: z3++.h:2642
param_descrs get_param_descrs()
Definition: z3++.h:2753
void set(char const *k, unsigned v)
Definition: z3++.h:2659
void add(expr_vector const &v)
Definition: z3++.h:2675
expr_vector assertions() const
Definition: z3++.h:2714
void from_file(char const *file)
Definition: z3++.h:2680
expr_vector trail(array< unsigned > &levels) const
Definition: z3++.h:2718
void reset()
Definition: z3++.h:2665
std::string reason_unknown() const
Definition: z3++.h:2711
void set(params const &p)
Definition: z3++.h:2657
expr_vector cube(expr_vector &vars, unsigned cutoff)
Definition: z3++.h:2756
cube_generator cubes()
Definition: z3++.h:2843
expr_vector unsat_core() const
Definition: z3++.h:2713
solver(solver const &s)
Definition: z3++.h:2647
void set(char const *k, symbol const &v)
Definition: z3++.h:2661
check_result check(expr_vector const &assumptions)
Definition: z3++.h:2694
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:3879
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:3888
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:2613
bool is_uint(unsigned i) const
Definition: z3++.h:2615
bool is_double(unsigned i) const
Definition: z3++.h:2616
~stats()
Definition: z3++.h:2604
stats(stats const &s)
Definition: z3++.h:2603
double double_value(unsigned i) const
Definition: z3++.h:2618
unsigned uint_value(unsigned i) const
Definition: z3++.h:2617
stats & operator=(stats const &s)
Definition: z3++.h:2606
stats(context &c, Z3_stats e)
Definition: z3++.h:2602
std::string key(unsigned i) const
Definition: z3++.h:2614
stats(context &c)
Definition: z3++.h:2601
friend std::ostream & operator<<(std::ostream &out, stats const &s)
Definition: z3++.h:2621
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:3002
friend tactic par_and_then(tactic const &t1, tactic const &t2)
Definition: z3++.h:3011
std::string help() const
Definition: z3++.h:2961
solver mk_solver() const
Definition: z3++.h:2951
tactic & operator=(tactic const &s)
Definition: z3++.h:2944
tactic(context &c, char const *name)
Definition: z3++.h:2939
tactic(context &c, Z3_tactic s)
Definition: z3++.h:2940
friend tactic repeat(tactic const &t, unsigned max)
Definition: z3++.h:2986
~tactic()
Definition: z3++.h:2942
friend tactic with(tactic const &t, params const &p)
Definition: z3++.h:2992
apply_result apply(goal const &g) const
Definition: z3++.h:2952
friend tactic operator&(tactic const &t1, tactic const &t2)
Definition: z3++.h:2972
friend tactic try_for(tactic const &t, unsigned ms)
Definition: z3++.h:2997
param_descrs get_param_descrs()
Definition: z3++.h:2969
apply_result operator()(goal const &g) const
Definition: z3++.h:2958
tactic(tactic const &s)
Definition: z3++.h:2941
friend tactic operator|(tactic const &t1, tactic const &t2)
Definition: z3++.h:2979
void propagate(expr_vector const &fixed, expr const &conseq)
Definition: z3++.h:4156
void register_created(created_eh_t &c)
Definition: z3++.h:4102
virtual ~user_propagator_base()
Definition: z3++.h:4019
virtual void eq(expr const &, expr const &)
Definition: z3++.h:4120
void register_eq(eq_eh_t &f)
Definition: z3++.h:4062
void propagate(expr_vector const &fixed, expr_vector const &lhs, expr_vector const &rhs, expr const &conseq)
Definition: z3++.h:4163
void add(expr const &e)
tracks e by a unique identifier that is returned by the call.
Definition: z3++.h:4140
virtual void created(expr const &)
Definition: z3++.h:4124
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:4086
virtual void pop(unsigned num_scopes)=0
virtual void fixed(expr const &, expr const &)
Definition: z3++.h:4118
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:4149
context & ctx()
Definition: z3++.h:4026
user_propagator_base(solver *s)
Definition: z3++.h:4012
user_propagator_base(context &c)
Definition: z3++.h:4010
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:4046
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:1430
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:1001
unsigned Z3_API Z3_get_arity(Z3_context c, Z3_func_decl d)
Alias for Z3_get_domain_size.
void Z3_API Z3_ast_vector_set(Z3_context c, Z3_ast_vector v, unsigned i, Z3_ast a)
Update position i of the AST vector v with the AST a.
Z3_ast Z3_API Z3_mk_bvxor(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise exclusive-or.
Z3_string Z3_API Z3_stats_to_string(Z3_context c, Z3_stats s)
Convert a statistics into a string.
Z3_param_descrs Z3_API Z3_fixedpoint_get_param_descrs(Z3_context c, Z3_fixedpoint f)
Return the parameter description set for the given fixedpoint object.
Z3_sort Z3_API Z3_mk_real_sort(Z3_context c)
Create the real type.
void Z3_API Z3_optimize_from_file(Z3_context c, Z3_optimize o, Z3_string s)
Parse an SMT-LIB2 file with assertions, soft constraints and optimization objectives....
Z3_ast Z3_API Z3_mk_le(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than or equal to.
bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g)
Return true if the given goal contains the formula false.
Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c, unsigned num_bound, Z3_app const bound[], Z3_ast body)
Create a lambda expression using a list of constants that form the set of bound variables.
Z3_tactic Z3_API Z3_tactic_par_and_then(Z3_context c, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal and then t2 to every subgoal produced by t1....
void Z3_API Z3_fixedpoint_update_rule(Z3_context c, Z3_fixedpoint d, Z3_ast a, Z3_symbol name)
Update a named rule. A rule with the same name must have been previously created.
void Z3_API Z3_solver_dec_ref(Z3_context c, Z3_solver s)
Decrement the reference counter of the given solver.
Z3_ast Z3_API Z3_mk_bvslt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed less than.
Z3_func_decl Z3_API Z3_model_get_func_decl(Z3_context c, Z3_model m, unsigned i)
Return the declaration of the i-th function in the given model.
Z3_ast Z3_API Z3_mk_seq_length(Z3_context c, Z3_ast s)
Return the length of the sequence s.
Z3_ast Z3_API Z3_mk_numeral(Z3_context c, Z3_string numeral, Z3_sort ty)
Create a numeral of a given sort.
unsigned Z3_API Z3_func_entry_get_num_args(Z3_context c, Z3_func_entry e)
Return the number of arguments in a Z3_func_entry object.
Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p)
Interface to simplifier.
Z3_ast Z3_API Z3_get_numerator(Z3_context c, Z3_ast a)
Return the numerator (as a numeral AST) of a numeral AST of sort Real.
Z3_ast Z3_API Z3_mk_unary_minus(Z3_context c, Z3_ast arg)
Create an AST node representing - arg.
Z3_ast Z3_API Z3_mk_fpa_rna(Z3_context c)
Create a numeral of RoundingMode sort which represents the NearestTiesToAway rounding mode.
Z3_probe Z3_API Z3_probe_ge(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is greater than or equal to the...
Z3_ast Z3_API Z3_mk_and(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] and ... and args[num_args-1].
void Z3_API Z3_interrupt(Z3_context c)
Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers,...
Z3_ast Z3_API Z3_mk_str_to_int(Z3_context c, Z3_ast s)
Convert string to integer.
Z3_ast Z3_API Z3_mk_fpa_sub(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point subtraction.
void Z3_API Z3_goal_assert(Z3_context c, Z3_goal g, Z3_ast a)
Add a new formula a to the given goal. The formula is split according to the following procedure that...
Z3_symbol Z3_API Z3_param_descrs_get_name(Z3_context c, Z3_param_descrs p, unsigned i)
Return the name of the parameter at given index i.
Z3_ast Z3_API Z3_func_entry_get_value(Z3_context c, Z3_func_entry e)
Return the value of this point.
bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a)
Determine if ast is an existential quantifier.
Z3_ast_vector Z3_API Z3_fixedpoint_from_string(Z3_context c, Z3_fixedpoint f, Z3_string s)
Parse an SMT-LIB2 string with fixedpoint rules. Add the rules to the current fixedpoint context....
Z3_sort Z3_API Z3_mk_uninterpreted_sort(Z3_context c, Z3_symbol s)
Create a free (uninterpreted) type using the given name (symbol).
void Z3_API Z3_optimize_pop(Z3_context c, Z3_optimize d)
Backtrack one level.
Z3_ast Z3_API Z3_mk_fpa_is_normal(Z3_context c, Z3_ast t)
Predicate indicating whether t is a normal floating-point number.
Z3_ast Z3_API Z3_mk_false(Z3_context c)
Create an AST node representing false.
Z3_lbool Z3_API Z3_solver_check(Z3_context c, Z3_solver s)
Check whether the assertions in a given solver are consistent or not.
Z3_ast Z3_API Z3_mk_fpa_to_ubv(Z3_context c, Z3_ast rm, Z3_ast t, unsigned sz)
Conversion of a floating-point term into an unsigned bit-vector.
Z3_ast Z3_API Z3_mk_rotate_right(Z3_context c, unsigned i, Z3_ast t1)
Rotate bits of t1 to the right i times.
Z3_ast Z3_API Z3_mk_bvmul(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement multiplication.
Z3_ast Z3_API Z3_mk_seq_at(Z3_context c, Z3_ast s, Z3_ast index)
Retrieve from s the unit sequence positioned at position index. The sequence is empty if the index is...
Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m)
Convert a model of the formulas of a goal to a model of an original goal. The model may be null,...
Z3_ast Z3_API Z3_mk_bvsgt(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed greater than.
Z3_string Z3_API Z3_ast_to_string(Z3_context c, Z3_ast a)
Convert the given AST node into a string.
Z3_ast Z3_API Z3_mk_re_complement(Z3_context c, Z3_ast re)
Create the complement of the regular language re.
Z3_ast_vector Z3_API Z3_fixedpoint_get_assertions(Z3_context c, Z3_fixedpoint f)
Retrieve set of background assertions from fixedpoint context.
Z3_context Z3_API Z3_mk_context_rc(Z3_config c)
Create a context using the given configuration. This function is similar to Z3_mk_context....
unsigned Z3_API Z3_fpa_get_ebits(Z3_context c, Z3_sort s)
Retrieves the number of bits reserved for the exponent in a FloatingPoint sort.
Z3_ast_vector Z3_API Z3_solver_get_assertions(Z3_context c, Z3_solver s)
Return the set of asserted formulas on the solver.
Z3_solver Z3_API Z3_mk_solver_from_tactic(Z3_context c, Z3_tactic t)
Create a new solver that is implemented using the given tactic. The solver supports the commands Z3_s...
Z3_ast Z3_API Z3_mk_set_complement(Z3_context c, Z3_ast arg)
Take the complement of a set.
bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx)
Return true if the given statistical data is a unsigned integer.
bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx)
Return true if the given statistical data is a double.
Z3_ast Z3_API Z3_mk_fpa_rtn(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardNegative rounding mode.
unsigned Z3_API Z3_model_get_num_consts(Z3_context c, Z3_model m)
Return the number of constants assigned by the given model.
Z3_ast Z3_API Z3_get_algebraic_number_lower(Z3_context c, Z3_ast a, unsigned precision)
Return a lower bound for the given real algebraic number. The interval isolating the number is smalle...
Z3_ast Z3_API Z3_mk_extract(Z3_context c, unsigned high, unsigned low, Z3_ast t1)
Extract the bits high down to low from a bit-vector of size m to yield a new bit-vector of size n,...
Z3_ast Z3_API Z3_mk_mod(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 mod arg2.
Z3_ast Z3_API Z3_mk_bvredand(Z3_context c, Z3_ast t1)
Take conjunction of bits in vector, return vector of length 1.
Z3_ast Z3_API Z3_mk_set_add(Z3_context c, Z3_ast set, Z3_ast elem)
Add an element to a set.
Z3_ast Z3_API Z3_mk_ge(Z3_context c, Z3_ast t1, Z3_ast t2)
Create greater than or equal to.
Z3_ast Z3_API Z3_mk_bvadd_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2)
Create a predicate that checks that the bit-wise signed addition of t1 and t2 does not underflow.
Z3_ast Z3_API Z3_mk_fpa_rtp(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardPositive rounding mode.
void Z3_API Z3_update_param_value(Z3_context c, Z3_string param_id, Z3_string param_value)
Set a value of a context parameter.
Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed)
Create a predicate that checks that the bit-wise addition of t1 and t2 does not overflow.
void Z3_API Z3_set_ast_print_mode(Z3_context c, Z3_ast_print_mode mode)
Select mode for the format used for pretty-printing AST nodes.
unsigned Z3_API Z3_fpa_get_sbits(Z3_context c, Z3_sort s)
Retrieves the number of bits reserved for the significand in a FloatingPoint sort.
Z3_ast Z3_API Z3_mk_forall_const(Z3_context c, unsigned weight, unsigned num_bound, Z3_app const bound[], unsigned num_patterns, Z3_pattern const patterns[], Z3_ast body)
Create a universal quantifier using a list of constants that will form the set of bound variables.
Z3_param_kind
The different kinds of parameters that can be associated with parameter sets. (see Z3_mk_params).
Definition: z3_api.h:1339
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_string Z3_API Z3_goal_to_dimacs_string(Z3_context c, Z3_goal g, bool include_names)
Convert a goal into a DIMACS formatted string. The goal must be in CNF. You can convert a goal to CNF...
Z3_ast Z3_API Z3_mk_lt(Z3_context c, Z3_ast t1, Z3_ast t2)
Create less than.
double Z3_API Z3_stats_get_double_value(Z3_context c, Z3_stats s, unsigned idx)
Return the double value of the given statistical data.
Z3_ast Z3_API Z3_mk_fpa_numeral_float(Z3_context c, float v, Z3_sort ty)
Create a numeral of FloatingPoint sort from a float.
Z3_ast Z3_API Z3_mk_bvugt(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned greater than.
Z3_lbool Z3_API Z3_fixedpoint_query(Z3_context c, Z3_fixedpoint d, Z3_ast query)
Pose a query against the asserted rules.
unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g)
Return the depth of the given goal. It tracks how many transformations were applied to it.
Z3_ast Z3_API Z3_mk_fpa_rtz(Z3_context c)
Create a numeral of RoundingMode sort which represents the TowardZero rounding mode.
Z3_string Z3_API Z3_get_symbol_string(Z3_context c, Z3_symbol s)
Return the symbol name.
Z3_lbool Z3_API Z3_get_bool_value(Z3_context c, Z3_ast a)
Return Z3_L_TRUE if a is true, Z3_L_FALSE if it is false, and Z3_L_UNDEF otherwise.
Z3_ast Z3_API Z3_mk_bvnot(Z3_context c, Z3_ast t1)
Bitwise negation.
Z3_ast Z3_API Z3_mk_bvurem(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned remainder.
Z3_ast_vector Z3_API Z3_solver_get_non_units(Z3_context c, Z3_solver s)
Return the set of non units in the solver state.
Z3_ast Z3_API Z3_mk_seq_to_re(Z3_context c, Z3_ast seq)
Create a regular expression that accepts the sequence seq.
Z3_ast Z3_API Z3_mk_bvsub(Z3_context c, Z3_ast t1, Z3_ast t2)
Standard two's complement subtraction.
Z3_ast_vector Z3_API Z3_optimize_get_objectives(Z3_context c, Z3_optimize o)
Return objectives on the optimization context. If the objective function is a max-sat objective it is...
Z3_ast Z3_API Z3_mk_seq_index(Z3_context c, Z3_ast s, Z3_ast substr, Z3_ast offset)
Return index of first occurrence of substr in s starting from offset offset. If s does not contain su...
Z3_ast Z3_API Z3_get_algebraic_number_upper(Z3_context c, Z3_ast a, unsigned precision)
Return a upper bound for the given real algebraic number. The interval isolating the number is smalle...
Z3_ast Z3_API Z3_mk_power(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Create an AST node representing arg1 ^ arg2.
Z3_ast Z3_API Z3_mk_seq_concat(Z3_context c, unsigned n, Z3_ast const args[])
Concatenate sequences.
Z3_sort Z3_API Z3_mk_enumeration_sort(Z3_context c, Z3_symbol name, unsigned n, Z3_symbol const enum_names[], Z3_func_decl enum_consts[], Z3_func_decl enum_testers[])
Create a enumeration sort.
Z3_ast Z3_API Z3_mk_re_range(Z3_context c, Z3_ast lo, Z3_ast hi)
Create the range regular expression over two sequences of length 1.
unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t)
Return the size of the given bit-vector sort.
Z3_ast_vector Z3_API Z3_fixedpoint_get_rules(Z3_context c, Z3_fixedpoint f)
Retrieve set of rules from fixedpoint context.
Z3_ast Z3_API Z3_mk_set_member(Z3_context c, Z3_ast elem, Z3_ast set)
Check for set membership.
void Z3_API Z3_ast_vector_dec_ref(Z3_context c, Z3_ast_vector v)
Decrement the reference counter of the given AST vector.
Z3_tactic Z3_API Z3_tactic_fail_if(Z3_context c, Z3_probe p)
Return a tactic that fails if the probe p evaluates to false.
void Z3_API Z3_goal_reset(Z3_context c, Z3_goal g)
Erase all formulas from the given goal.
void Z3_API Z3_func_interp_dec_ref(Z3_context c, Z3_func_interp f)
Decrement the reference counter of the given Z3_func_interp object.
void Z3_API Z3_probe_dec_ref(Z3_context c, Z3_probe p)
Decrement the reference counter of the given probe.
void Z3_API Z3_params_inc_ref(Z3_context c, Z3_params p)
Increment the reference counter of the given parameter set.
void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h)
Register a Z3 error handler.
Z3_ast Z3_API Z3_mk_distinct(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing distinct(args[0], ..., args[num_args-1]).
Z3_ast Z3_API Z3_mk_seq_prefix(Z3_context c, Z3_ast prefix, Z3_ast s)
Check if prefix is a prefix of s.
Z3_config Z3_API Z3_mk_config(void)
Create a configuration object for the Z3 context object.
void Z3_API Z3_set_param_value(Z3_config c, Z3_string param_id, Z3_string param_value)
Set a configuration parameter.
Z3_sort Z3_API Z3_mk_bv_sort(Z3_context c, unsigned sz)
Create a bit-vector type of the given size.
Z3_ast Z3_API Z3_mk_fpa_rem(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point remainder.
Z3_ast Z3_API Z3_mk_bvult(Z3_context c, Z3_ast t1, Z3_ast t2)
Unsigned less than.
Z3_probe Z3_API Z3_probe_or(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when p1 or p2 evaluates to true.
Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c)
Create a new fixedpoint context.
Z3_string Z3_API Z3_params_to_string(Z3_context c, Z3_params p)
Convert a parameter set into a string. This function is mainly used for printing the contents of a pa...
void Z3_API Z3_solver_propagate_init(Z3_context c, Z3_solver s, void *user_context, Z3_push_eh push_eh, Z3_pop_eh pop_eh, Z3_fresh_eh fresh_eh)
register a user-properator with the solver.
Z3_func_decl Z3_API Z3_model_get_const_decl(Z3_context c, Z3_model m, unsigned i)
Return the i-th constant in the given model.
void Z3_API Z3_tactic_dec_ref(Z3_context c, Z3_tactic g)
Decrement the reference counter of the given tactic.
Z3_ast Z3_API Z3_mk_bvnand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise nand.
Z3_solver Z3_API Z3_mk_simple_solver(Z3_context c)
Create a new incremental solver.
Z3_sort Z3_API Z3_get_range(Z3_context c, Z3_func_decl d)
Return the range of the given declaration.
void Z3_API Z3_global_param_set(Z3_string param_id, Z3_string param_value)
Set a global (or module) parameter. This setting is shared by all Z3 contexts.
void Z3_API Z3_optimize_assert(Z3_context c, Z3_optimize o, Z3_ast a)
Assert hard constraint to the optimization context.
Z3_string Z3_API Z3_benchmark_to_smtlib_string(Z3_context c, Z3_string name, Z3_string logic, Z3_string status, Z3_string attributes, unsigned num_assumptions, Z3_ast const assumptions[], Z3_ast formula)
Convert the given benchmark into SMT-LIB formatted string.
Z3_ast Z3_API Z3_mk_re_star(Z3_context c, Z3_ast re)
Create the regular language re*.
Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, bool const *bits)
create a bit-vector numeral from a vector of Booleans.
void Z3_API Z3_func_entry_dec_ref(Z3_context c, Z3_func_entry e)
Decrement the reference counter of the given Z3_func_entry object.
unsigned Z3_API Z3_stats_size(Z3_context c, Z3_stats s)
Return the number of statistical data in s.
Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o)
Print the current context as a string.
Z3_ast Z3_API Z3_get_quantifier_body(Z3_context c, Z3_ast a)
Return body of quantifier.
void Z3_API Z3_param_descrs_dec_ref(Z3_context c, Z3_param_descrs p)
Decrement the reference counter of the given parameter description set.
Z3_ast Z3_API Z3_mk_re_full(Z3_context c, Z3_sort re)
Create an universal regular expression of sort re.
Z3_ast Z3_API Z3_mk_fpa_min(Z3_context c, Z3_ast t1, Z3_ast t2)
Minimum of floating-point numbers.
Z3_model Z3_API Z3_mk_model(Z3_context c)
Create a fresh model object. It has reference count 0.
Z3_symbol Z3_API Z3_get_decl_name(Z3_context c, Z3_func_decl d)
Return the constant declaration name as a symbol.
Z3_ast Z3_API Z3_mk_bvneg_no_overflow(Z3_context c, Z3_ast t1)
Check that bit-wise negation does not overflow when t1 is interpreted as a signed bit-vector.
Z3_ast Z3_API Z3_mk_fpa_round_to_integral(Z3_context c, Z3_ast rm, Z3_ast t)
Floating-point roundToIntegral. Rounds a floating-point number to the closest integer,...
Z3_string Z3_API Z3_stats_get_key(Z3_context c, Z3_stats s, unsigned idx)
Return the key (a string) for a particular statistical data.
Z3_ast Z3_API Z3_mk_re_diff(Z3_context c, Z3_ast re1, Z3_ast re2)
Create the difference of regular expressions.
unsigned Z3_API Z3_fixedpoint_get_num_levels(Z3_context c, Z3_fixedpoint d, Z3_func_decl pred)
Query the PDR engine for the maximal levels properties are known about predicate.
Z3_ast Z3_API Z3_mk_int64(Z3_context c, int64_t v, Z3_sort ty)
Create a numeral of a int, bit-vector, or finite-domain sort.
Z3_symbol_kind
The different kinds of symbol. In Z3, a symbol can be represented using integers and strings (See Z3_...
Definition: z3_api.h:116
Z3_ast Z3_API Z3_mk_re_empty(Z3_context c, Z3_sort re)
Create an empty regular expression of sort re.
void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name)
load solver assertions from a string.
Z3_ast Z3_API Z3_mk_fpa_add(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point addition.
Z3_ast Z3_API Z3_mk_bvand(Z3_context c, Z3_ast t1, Z3_ast t2)
Bitwise and.
Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c)
Return the parameter description set for the simplify procedure.
bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g)
Return true if the goal contains false, and it is precise or the product of an over approximation.
Z3_ast Z3_API Z3_mk_add(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] + ... + args[num_args-1].
Z3_ast_kind Z3_API Z3_get_ast_kind(Z3_context c, Z3_ast a)
Return the kind of the given AST.
Z3_ast_vector Z3_API Z3_parse_smtlib2_file(Z3_context c, Z3_string file_name, unsigned num_sorts, Z3_symbol const sort_names[], Z3_sort const sorts[], unsigned num_decls, Z3_symbol const decl_names[], Z3_func_decl const decls[])
Similar to Z3_parse_smtlib2_string, but reads the benchmark from a file.
Z3_ast Z3_API Z3_mk_bvsmod(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed remainder (sign follows divisor).
Z3_tactic Z3_API Z3_tactic_cond(Z3_context c, Z3_probe p, Z3_tactic t1, Z3_tactic t2)
Return a tactic that applies t1 to a given goal if the probe p evaluates to true, and t2 if p evaluat...
Z3_model Z3_API Z3_model_translate(Z3_context c, Z3_model m, Z3_context dst)
translate model from context c to context dst.
Z3_string Z3_API Z3_fixedpoint_to_string(Z3_context c, Z3_fixedpoint f, unsigned num_queries, Z3_ast queries[])
Print the current rules and background axioms as a string.
void Z3_API Z3_solver_get_levels(Z3_context c, Z3_solver s, Z3_ast_vector literals, unsigned sz, unsigned levels[])
retrieve the decision depth of Boolean literals (variables or their negations). Assumes a check-sat c...
Z3_ast Z3_API Z3_fixedpoint_get_cover_delta(Z3_context c, Z3_fixedpoint d, int level, Z3_func_decl pred)
Z3_ast Z3_API Z3_mk_fpa_to_fp_unsigned(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort.
Z3_ast Z3_API Z3_mk_int2bv(Z3_context c, unsigned n, Z3_ast t1)
Create an n bit bit-vector from the integer argument t1.
void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a)
Assert a constraint into the solver.
Z3_tactic Z3_API Z3_mk_tactic(Z3_context c, Z3_string name)
Return a tactic associated with the given name. The complete list of tactics may be obtained using th...
Z3_ast Z3_API Z3_mk_fpa_abs(Z3_context c, Z3_ast t)
Floating-point absolute value.
unsigned Z3_API Z3_ast_vector_size(Z3_context c, Z3_ast_vector v)
Return the size of the given AST vector.
Z3_optimize Z3_API Z3_mk_optimize(Z3_context c)
Create a new optimize context.
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:1381
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 the last occurrence of substr in s. If s does not contain substr, then the value is -1,...
void Z3_API Z3_param_descrs_inc_ref(Z3_context c, Z3_param_descrs p)
Increment the reference counter of the given parameter description set.
Z3_goal Z3_API Z3_apply_result_get_subgoal(Z3_context c, Z3_apply_result r, unsigned i)
Return one of the subgoals in the Z3_apply_result object returned by Z3_tactic_apply.
Z3_probe Z3_API Z3_probe_le(Z3_context x, Z3_probe p1, Z3_probe p2)
Return a probe that evaluates to "true" when the value returned by p1 is less than or equal to the va...
void Z3_API Z3_stats_dec_ref(Z3_context c, Z3_stats s)
Decrement the reference counter of the given statistics object.
Z3_ast Z3_API Z3_mk_re_concat(Z3_context c, unsigned n, Z3_ast const args[])
Create the concatenation of the regular languages.
Z3_func_entry Z3_API Z3_func_interp_get_entry(Z3_context c, Z3_func_interp f, unsigned i)
Return a "point" of the given function interpretation. It represents the value of f in a particular p...
Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const domain[], Z3_sort range)
Declare a recursive function.
unsigned Z3_API Z3_get_ast_id(Z3_context c, Z3_ast t)
Return a unique identifier for t. The identifier is unique up to structural equality....
Z3_ast Z3_API Z3_mk_concat(Z3_context c, Z3_ast t1, Z3_ast t2)
Concatenate the given bit-vectors.
Z3_ast Z3_API Z3_mk_fpa_to_fp_float(Z3_context c, Z3_ast rm, Z3_ast t, Z3_sort s)
Conversion of a FloatingPoint term into another term of different FloatingPoint sort.
Z3_apply_result Z3_API Z3_tactic_apply(Z3_context c, Z3_tactic t, Z3_goal g)
Apply tactic t to the goal g.
Z3_ast Z3_API Z3_mk_fpa_leq(Z3_context c, Z3_ast t1, Z3_ast t2)
Floating-point less than or equal.
void Z3_API Z3_solver_propagate_created(Z3_context c, Z3_solver s, Z3_created_eh created_eh)
register a callback when a new expression with a registered function is used by the solver The regist...
Z3_ast Z3_API Z3_mk_fpa_numeral_double(Z3_context c, double v, Z3_sort ty)
Create a numeral of FloatingPoint sort from a double.
unsigned Z3_API Z3_get_sort_id(Z3_context c, Z3_sort s)
Return a unique identifier for s.
Z3_ast Z3_API Z3_mk_fpa_mul(Z3_context c, Z3_ast rm, Z3_ast t1, Z3_ast t2)
Floating-point multiplication.
Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const args[])
Create a constant or function application.
Z3_sort_kind Z3_API Z3_get_sort_kind(Z3_context c, Z3_sort t)
Return the sort kind (e.g., array, tuple, int, bool, etc).
Z3_stats Z3_API Z3_solver_get_statistics(Z3_context c, Z3_solver s)
Return statistics for the given solver.
Z3_ast Z3_API Z3_mk_bvneg(Z3_context c, Z3_ast t1)
Standard two's complement unary minus.
Z3_ast Z3_API Z3_mk_store_n(Z3_context c, Z3_ast a, unsigned n, Z3_ast const *idxs, Z3_ast v)
n-ary Array update.
Z3_string Z3_API Z3_fixedpoint_get_reason_unknown(Z3_context c, Z3_fixedpoint d)
Retrieve a string that describes the last status returned by Z3_fixedpoint_query.
Z3_func_decl Z3_API Z3_mk_linear_order(Z3_context c, Z3_sort a, unsigned id)
create a linear ordering relation over signature a. The relation is identified by the index id.
Z3_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint f)
Return a string describing all fixedpoint available parameters.
Z3_sort Z3_API Z3_get_domain(Z3_context c, Z3_func_decl d, unsigned i)
Return the sort of the i-th parameter of the given function declaration.
Z3_ast Z3_API Z3_mk_seq_in_re(Z3_context c, Z3_ast seq, Z3_ast re)
Check if seq is in the language generated by the regular expression re.
Z3_sort Z3_API Z3_mk_bool_sort(Z3_context c)
Create the Boolean type.
Z3_ast Z3_API Z3_mk_sub(Z3_context c, unsigned num_args, Z3_ast const args[])
Create an AST node representing args[0] - ... - args[num_args - 1].
void Z3_API Z3_params_set_symbol(Z3_context c, Z3_params p, Z3_symbol k, Z3_symbol v)
Add a symbol parameter k with value v to the parameter set p.
Z3_ast Z3_API Z3_ast_vector_get(Z3_context c, Z3_ast_vector v, unsigned i)
Return the AST at position i in the AST vector v.
Z3_string Z3_API Z3_solver_to_dimacs_string(Z3_context c, Z3_solver s, bool include_names)
Convert a solver into a DIMACS formatted string.
unsigned Z3_API Z3_get_func_decl_id(Z3_context c, Z3_func_decl f)
Return a unique identifier for f.
Z3_ast Z3_API Z3_mk_set_difference(Z3_context c, Z3_ast arg1, Z3_ast arg2)
Take the set difference between two sets.
Z3_ast Z3_API Z3_mk_lstring(Z3_context c, unsigned len, Z3_string s)
Create a string constant out of the string that is passed in It takes the length of the string as wel...
Z3_ast Z3_API Z3_mk_bvsdiv(Z3_context c, Z3_ast t1, Z3_ast t2)
Two's complement signed division.
Z3_ast Z3_API Z3_mk_bvlshr(Z3_context c, Z3_ast t1, Z3_ast t2)
Logical shift right.
double Z3_API Z3_probe_apply(Z3_context c, Z3_probe p, Z3_goal g)
Execute the probe over the goal. The probe always produce a double value. "Boolean" probes return 0....
void Z3_API Z3_func_interp_set_else(Z3_context c, Z3_func_interp f, Z3_ast else_value)
Return the 'else' value of the given function interpretation.
void Z3_API Z3_goal_dec_ref(Z3_context c, Z3_goal g)
Decrement the reference counter of the given goal.
Z3_ast Z3_API Z3_mk_not(Z3_context c, Z3_ast a)
Create an AST node representing not(a).
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:1359
@ Z3_APP_AST
Definition: z3_api.h:183
@ Z3_VAR_AST
Definition: z3_api.h:184
@ Z3_SORT_AST
Definition: z3_api.h:186
@ Z3_NUMERAL_AST
Definition: z3_api.h:182
@ Z3_FUNC_DECL_AST
Definition: z3_api.h:187
@ Z3_QUANTIFIER_AST
Definition: z3_api.h:185
@ Z3_OP_DISTINCT
Definition: z3_api.h:1006
@ Z3_OP_AND
Definition: z3_api.h:1008
@ Z3_OP_FALSE
Definition: z3_api.h:1004
@ Z3_OP_XOR
Definition: z3_api.h:1011
@ Z3_OP_IMPLIES
Definition: z3_api.h:1013
@ Z3_OP_ITE
Definition: z3_api.h:1007
@ Z3_OP_EQ
Definition: z3_api.h:1005
@ Z3_OP_OR
Definition: z3_api.h:1009
@ Z3_OP_NOT
Definition: z3_api.h:1012
@ Z3_OP_TRUE
Definition: z3_api.h:1003
@ Z3_RELATION_SORT
Definition: z3_api.h:158
@ Z3_BOOL_SORT
Definition: z3_api.h:152
@ Z3_BV_SORT
Definition: z3_api.h:155
@ Z3_DATATYPE_SORT
Definition: z3_api.h:157
@ Z3_INT_SORT
Definition: z3_api.h:153
@ Z3_FINITE_DOMAIN_SORT
Definition: z3_api.h:159
@ Z3_RE_SORT
Definition: z3_api.h:163
@ Z3_FLOATING_POINT_SORT
Definition: z3_api.h:160
@ Z3_ARRAY_SORT
Definition: z3_api.h:156
@ Z3_REAL_SORT
Definition: z3_api.h:154
@ Z3_SEQ_SORT
Definition: z3_api.h:162
@ Z3_L_TRUE
Definition: z3_api.h:105
@ Z3_L_FALSE
Definition: z3_api.h:103
@ Z3_STRING_SYMBOL
Definition: z3_api.h:118
@ Z3_INT_SYMBOL
Definition: z3_api.h:117
@ Z3_OK
Definition: z3_api.h:1382
Z3 C++ namespace.
Definition: z3++.h:50
expr re_intersect(expr_vector const &args)
Definition: z3++.h:3805
expr indexof(expr const &s, expr const &substr, expr const &offset)
Definition: z3++.h:3768
expr mk_and(expr_vector const &args)
Definition: z3++.h:2442
expr fpa_to_ubv(expr const &t, unsigned sz)
Definition: z3++.h:1990
expr star(expr const &re)
Definition: z3++.h:3792
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:2181
expr operator==(expr const &a, expr const &b)
Definition: z3++.h:1644
expr operator>=(expr const &a, expr const &b)
Definition: z3++.h:1721
expr srem(expr const &a, expr const &b)
signed remainder operator for bitvectors
Definition: z3++.h:2122
expr bvadd_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2178
expr pble(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2334
expr store(expr const &a, expr const &i, expr const &v)
Definition: z3++.h:3658
expr mod(expr const &a, expr const &b)
Definition: z3++.h:1579
expr fma(expr const &a, expr const &b, expr const &c, expr const &rm)
Definition: z3++.h:1967
expr range(expr const &lo, expr const &hi)
Definition: z3++.h:3823
expr round_fpa_to_closest_integer(expr const &t)
Definition: z3++.h:2018
expr distinct(expr_vector const &args)
Definition: z3++.h:2383
expr bvmul_no_underflow(expr const &a, expr const &b)
Definition: z3++.h:2196
expr operator|(expr const &a, expr const &b)
Definition: z3++.h:1882
expr pbeq(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2350
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:2150
expr bv2int(expr const &a, bool is_signed)
bit-vector and integer conversions.
Definition: z3++.h:2169
expr max(expr const &a, expr const &b)
Definition: z3++.h:1904
expr operator^(expr const &a, expr const &b)
Definition: z3++.h:1878
func_decl linear_order(sort const &a, unsigned index)
Definition: z3++.h:2206
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:1830
expr set_intersect(expr const &a, expr const &b)
Definition: z3++.h:3723
func_decl tree_order(sort const &a, unsigned index)
Definition: z3++.h:2215
expr forall(expr const &x, expr const &b)
Definition: z3++.h:2261
expr bvneg_no_overflow(expr const &a)
Definition: z3++.h:2190
expr set_member(expr const &s, expr const &e)
Definition: z3++.h:3739
expr set_difference(expr const &a, expr const &b)
Definition: z3++.h:3731
func_decl recfun(symbol const &name, unsigned arity, sort const *domain, sort const &range)
Definition: z3++.h:3628
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:2204
expr bvadd_no_overflow(expr const &a, expr const &b, bool is_signed)
bit-vector overflow/underflow checks
Definition: z3++.h:2175
expr slt(expr const &a, expr const &b)
signed less than operator for bitvectors.
Definition: z3++.h:2071
expr bvsdiv_no_overflow(expr const &a, expr const &b)
Definition: z3++.h:2187
expr empty_set(sort const &s)
Definition: z3++.h:3699
expr plus(expr const &re)
Definition: z3++.h:3786
expr rem(expr const &a, expr const &b)
Definition: z3++.h:1595
expr re_diff(expr const &a, expr const &b)
Definition: z3++.h:3813
expr operator!(expr const &a)
Definition: z3++.h:1613
expr fpa_fp(expr const &sgn, expr const &exp, expr const &sig)
Definition: z3++.h:1975
expr mk_xor(expr_vector const &args)
Definition: z3++.h:2448
void set_param(char const *param, char const *value)
Definition: z3++.h:78
expr full_set(sort const &s)
Definition: z3++.h:3703
ast_vector_tpl< sort > sort_vector
Definition: z3++.h:75
expr as_array(func_decl &f)
Definition: z3++.h:3678
tactic when(probe const &p, tactic const &t)
Definition: z3++.h:3262
expr operator*(expr const &a, expr const &b)
Definition: z3++.h:1697
expr uge(expr const &a, expr const &b)
unsigned greater than or equal to operator for bitvectors.
Definition: z3++.h:2103
expr nand(expr const &a, expr const &b)
Definition: z3++.h:1886
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:2164
expr is_int(expr const &e)
Definition: z3++.h:1615
expr empty(sort const &s)
Definition: z3++.h:3751
expr operator-(expr const &a)
Definition: z3++.h:1763
expr re_complement(expr const &a)
Definition: z3++.h:3820
expr set_del(expr const &s, expr const &e)
Definition: z3++.h:3711
expr mk_or(expr_vector const &args)
Definition: z3++.h:2436
expr concat(expr const &a, expr const &b)
Definition: z3++.h:2392
tactic with(tactic const &t, params const &p)
Definition: z3++.h:2992
expr operator%(expr const &a, expr const &b)
Definition: z3++.h:1590
expr re_full(sort const &s)
Definition: z3++.h:3800
func_decl partial_order(sort const &a, unsigned index)
Definition: z3++.h:2209
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:3011
bool eq(ast const &a, ast const &b)
Definition: z3++.h:531
expr operator~(expr const &a)
Definition: z3++.h:1965
expr exists(expr const &x, expr const &b)
Definition: z3++.h:2285
expr ite(expr const &c, expr const &t, expr const &e)
Create the if-then-else expression ite(c, t, e)
Definition: z3++.h:2030
expr bvsub_no_underflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2184
expr set_add(expr const &s, expr const &e)
Definition: z3++.h:3707
expr sum(expr_vector const &args)
Definition: z3++.h:2374
expr last_indexof(expr const &s, expr const &substr)
Definition: z3++.h:3774
expr pbge(expr_vector const &es, int const *coeffs, int bound)
Definition: z3++.h:2342
expr set_union(expr const &a, expr const &b)
Definition: z3++.h:3715
func_decl to_func_decl(context &c, Z3_func_decl f)
Definition: z3++.h:2057
tactic cond(probe const &p, tactic const &t1, tactic const &t2)
Definition: z3++.h:3268
expr sbv_to_fpa(expr const &t, sort s)
Definition: z3++.h:1997
expr ubv_to_fpa(expr const &t, sort s)
Definition: z3++.h:2004
expr operator||(expr const &a, expr const &b)
Definition: z3++.h:1631
expr const_array(sort const &d, expr const &v)
Definition: z3++.h:3695
tactic par_or(unsigned n, tactic const *tactics)
Definition: z3++.h:3002
func_decl piecewise_linear_order(sort const &a, unsigned index)
Definition: z3++.h:2212
expr operator&&(expr const &a, expr const &b)
Definition: z3++.h:1619
func_decl function(std::string const &name, sort_vector const &domain, sort const &range)
Definition: z3++.h:3624
expr atleast(expr_vector const &es, unsigned bound)
Definition: z3++.h:2366
expr atmost(expr_vector const &es, unsigned bound)
Definition: z3++.h:2358
expr operator>(expr const &a, expr const &b)
Definition: z3++.h:1852
tactic repeat(tactic const &t, unsigned max=UINT_MAX)
Definition: z3++.h:2986
expr re_empty(sort const &s)
Definition: z3++.h:3795
expr select(expr const &a, expr const &i)
forward declarations
Definition: z3++.h:3641
expr urem(expr const &a, expr const &b)
unsigned reminder operator for bitvectors
Definition: z3++.h:2136
expr in_re(expr const &s, expr const &re)
Definition: z3++.h:3783
expr to_re(expr const &s)
Definition: z3++.h:3780
expr operator/(expr const &a, expr const &b)
Definition: z3++.h:1741
expr fp_eq(expr const &a, expr const &b)
Definition: z3++.h:1958
expr bvredor(expr const &a)
Definition: z3++.h:1919
expr nor(expr const &a, expr const &b)
Definition: z3++.h:1887
expr bvmul_no_overflow(expr const &a, expr const &b, bool is_signed)
Definition: z3++.h:2193
expr min(expr const &a, expr const &b)
Definition: z3++.h:1889
expr sle(expr const &a, expr const &b)
signed less than or equal to operator for bitvectors.
Definition: z3++.h:2065
sort to_sort(context &c, Z3_sort s)
Definition: z3++.h:2052
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:2109
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:2083
expr lambda(expr const &x, expr const &b)
Definition: z3++.h:2309
expr to_real(expr const &a)
Definition: z3++.h:3598
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:1667
expr int2bv(unsigned n, expr const &a)
Definition: z3++.h:2170
expr udiv(expr const &a, expr const &b)
unsigned division operator for bitvectors.
Definition: z3++.h:2115
expr prefixof(expr const &a, expr const &b)
Definition: z3++.h:3762
expr suffixof(expr const &a, expr const &b)
Definition: z3++.h:3756
expr set_complement(expr const &a)
Definition: z3++.h:3735
expr abs(expr const &a)
Definition: z3++.h:1931
expr fpa_to_sbv(expr const &t, unsigned sz)
Definition: z3++.h:1983
expr ule(expr const &a, expr const &b)
unsigned less than or equal to operator for bitvectors.
Definition: z3++.h:2091
void reset_params()
Definition: z3++.h:81
expr operator<=(expr const &a, expr const &b)
Definition: z3++.h:1805
expr option(expr const &re)
Definition: z3++.h:3789
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:2043
expr operator!=(expr const &a, expr const &b)
Definition: z3++.h:1655
tactic fail_if(probe const &p)
Definition: z3++.h:3257
ast_vector_tpl< ast > ast_vector
Definition: z3++.h:72
expr sqrt(expr const &a, expr const &rm)
Definition: z3++.h:1951
expr shl(expr const &a, expr const &b)
shift left operator for bitvectors
Definition: z3++.h:2143
expr implies(expr const &a, expr const &b)
Definition: z3++.h:1567
expr operator&(expr const &a, expr const &b)
Definition: z3++.h:1874
expr sge(expr const &a, expr const &b)
signed greater than or equal to operator for bitvectors.
Definition: z3++.h:2077
expr smod(expr const &a, expr const &b)
signed modulus operator for bitvectors
Definition: z3++.h:2129
expr set_subset(expr const &a, expr const &b)
Definition: z3++.h:3743
expr ult(expr const &a, expr const &b)
unsigned less than operator for bitvectors.
Definition: z3++.h:2097
expr pw(expr const &a, expr const &b)
Definition: z3++.h:1575
expr ashr(expr const &a, expr const &b)
arithmetic shift right operator for bitvectors
Definition: z3++.h:2157
expr xnor(expr const &a, expr const &b)
Definition: z3++.h:1888
expr bvredand(expr const &a)
Definition: z3++.h:1925
tactic try_for(tactic const &t, unsigned ms)
Definition: z3++.h:2997
expr fpa_to_fpa(expr const &t, sort s)
Definition: z3++.h:2011
def tactics(ctx=None)
Definition: z3py.py:8358
#define _Z3_MK_BIN_(a, b, binop)
Definition: z3++.h:1560
#define MK_EXPR1(_fn, _arg)
Definition: z3++.h:3684
#define MK_EXPR2(_fn, _arg1, _arg2)
Definition: z3++.h:3689
#define Z3_THROW(x)
Definition: z3++.h:101
#define _Z3_MK_UN_(a, mkun)
Definition: z3++.h:1607