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